from cycode.cyclient.models import (

ApiToken,

ApiTokenGenerationPollingResponse,

ApiTokenGenerationPollingResponseSchema,

ApiTokenSchema,

AuthenticationSession,

AuthenticationSessionSchema,

ClassificationData,

ClassificationDataSchema,

Detection,

DetectionRule,

DetectionRuleSchema,

DetectionSchema,

Member,

MemberDetails,

MemberSchema,

ReportExecution,

ReportExecutionSchema,

RequestedMemberDetailsResultSchema,

RequestedSbomReportResultSchema,

SbomReport,

SbomReportStorageDetails,

SbomReportStorageDetailsSchema,

ScanConfiguration,

ScanConfigurationSchema,

ScanInitializationResponse,

ScanInitializationResponseSchema,

ScanResult,

ScanResultSchema,

ScanResultsSyncFlow,

ScanResultsSyncFlowSchema,

SupportedModulesPreferences,

SupportedModulesPreferencesSchema,

UserAgentOption,

UserAgentOptionScheme,

)

# --- DetectionSchema ---

def test_detection_schema_load() -> None:

raw = {

'id': 'det-123',

'message': 'API key exposed',

'type': 'secret',

'severity': 'critical',

'detection_type_id': 'secret-1',

'detection_details': {'alert': True, 'value': 'sk_live_xxx'},

'detection_rule_id': 'rule-456',

}

result = DetectionSchema().load(raw)

assert isinstance(result, Detection)

assert result.id == 'det-123'

assert result.message == 'API key exposed'

assert result.type == 'secret'

assert result.severity == 'critical'

assert result.detection_type_id == 'secret-1'

assert result.detection_details == {'alert': True, 'value': 'sk_live_xxx'}

assert result.detection_rule_id == 'rule-456'

def test_detection_schema_load_defaults() -> None:

raw = {

'message': 'Vulnerability found',

'type': 'sca',

'detection_type_id': 'vuln-1',

'detection_details': {},

'detection_rule_id': 'rule-789',

}

result = DetectionSchema().load(raw)

assert result.id is None

assert result.severity is None

def test_detection_schema_excludes_unknown_fields() -> None:

raw = {

'message': 'Test',

'type': 'test',

'detection_type_id': 'test-1',

'detection_details': {},

'detection_rule_id': 'test-rule',

'unknown_field': 'should_be_ignored',

'another_unknown': 123,

}

result = DetectionSchema().load(raw)

assert isinstance(result, Detection)

assert not hasattr(result, 'unknown_field')

def test_detection_has_alert_true() -> None:

detection = Detection(

detection_type_id='secret-1',

type='secret',

message='Key found',

detection_details={'alert': {'severity': 'high'}},

detection_rule_id='rule-1',

)

assert detection.has_alert is True

def test_detection_has_alert_false() -> None:

detection = Detection(

detection_type_id='license-1',

type='sca',

message='License issue',

detection_details={'license': 'GPL'},

detection_rule_id='rule-2',

)

assert detection.has_alert is False

def test_detection_repr() -> None:

detection = Detection(

detection_type_id='secret-1',

type='secret',

message='API key exposed',

detection_details={'value': 'sk_live_xxx'},

detection_rule_id='rule-1',

severity='critical',

)

repr_str = repr(detection)

assert 'secret' in repr_str

assert 'critical' in repr_str

assert 'API key exposed' in repr_str

assert 'rule-1' in repr_str

# --- ScanResultSchema ---

def test_scan_result_schema_load_with_detections() -> None:

raw = {

'did_detect': True,

'scan_id': 'scan-abc',

'detections': [

{

'id': 'det-1',

'message': 'Secret found',

'type': 'secret',

'detection_type_id': 'secret-1',

'detection_details': {'alert': {}},

'detection_rule_id': 'rule-1',

}

],

'err': '',

}

result = ScanResultSchema().load(raw)

assert isinstance(result, ScanResult)

assert result.did_detect is True

assert result.scan_id == 'scan-abc'

assert len(result.detections) == 1

assert isinstance(result.detections[0], Detection)

assert result.detections[0].id == 'det-1'

def test_scan_result_schema_load_no_detections() -> None:

raw = {

'did_detect': False,

'scan_id': 'scan-def',

'detections': None,

'err': 'No files to scan',

}

result = ScanResultSchema().load(raw)

assert result.did_detect is False

assert result.detections is None

assert result.err == 'No files to scan'

def test_scan_result_schema_excludes_unknown_fields() -> None:

raw = {

'did_detect': False,

'scan_id': 'scan-1',

'detections': None,

'err': '',

'extra_field': 'ignored',

}

result = ScanResultSchema().load(raw)

assert isinstance(result, ScanResult)

# --- ScanInitializationResponseSchema ---

def test_scan_initialization_response_schema_load() -> None:

raw = {'scan_id': 'scan-init-123', 'err': ''}

result = ScanInitializationResponseSchema().load(raw)

assert isinstance(result, ScanInitializationResponse)

assert result.scan_id == 'scan-init-123'

# --- AuthenticationSessionSchema ---

def test_authentication_session_schema_load() -> None:

raw = {'session_id': 'sess-123'}

result = AuthenticationSessionSchema().load(raw)

assert isinstance(result, AuthenticationSession)

assert result.session_id == 'sess-123'

# --- ApiTokenSchema (tests data_key mapping) ---

def test_api_token_schema_load_data_key() -> None:

raw = {

'clientId': 'client-123',

'secret': 'secret-456',

'description': 'My API Token',

}

result = ApiTokenSchema().load(raw)

assert isinstance(result, ApiToken)

assert result.client_id == 'client-123'

assert result.secret == 'secret-456'

assert result.description == 'My API Token'

# --- ApiTokenGenerationPollingResponseSchema (nested) ---

def test_api_token_generation_polling_schema_load() -> None:

raw = {

'status': 'completed',

'api_token': {

'clientId': 'client-abc',

'secret': 'secret-xyz',

'description': 'Generated token',

},

}

result = ApiTokenGenerationPollingResponseSchema().load(raw)

assert isinstance(result, ApiTokenGenerationPollingResponse)

assert result.status == 'completed'

assert isinstance(result.api_token, ApiToken)

assert result.api_token.client_id == 'client-abc'

def test_api_token_generation_polling_schema_load_null_token() -> None:

raw = {

'status': 'pending',

'api_token': None,

}

result = ApiTokenGenerationPollingResponseSchema().load(raw)

assert result.status == 'pending'

assert result.api_token is None

# --- SbomReportStorageDetailsSchema / ReportExecutionSchema / RequestedSbomReportResultSchema ---

def test_sbom_report_storage_details_schema_load() -> None:

raw = {'path': '/reports/sbom.json', 'folder': '/reports', 'size': 4096}

result = SbomReportStorageDetailsSchema().load(raw)

assert isinstance(result, SbomReportStorageDetails)

assert result.path == '/reports/sbom.json'

assert result.size == 4096

def test_report_execution_schema_load() -> None:

raw = {

'id': 1,

'status': 'completed',

'error_message': None,

'status_message': 'Success',

'storage_details': {'path': '/reports/sbom.json', 'folder': '/reports', 'size': 4096},

}

result = ReportExecutionSchema().load(raw)

assert isinstance(result, ReportExecution)

assert result.id == 1

assert result.status == 'completed'

assert isinstance(result.storage_details, SbomReportStorageDetails)

def test_requested_sbom_report_result_schema_load() -> None:

raw = {

'report_executions': [

{

'id': 1,

'status': 'completed',

'error_message': None,

'status_message': 'Done',

'storage_details': {'path': '/r/sbom.json', 'folder': '/r', 'size': 1024},

},

{

'id': 2,

'status': 'failed',

'error_message': 'Timeout',

'status_message': None,

'storage_details': None,

},

]

}

result = RequestedSbomReportResultSchema().load(raw)

assert isinstance(result, SbomReport)

assert len(result.report_executions) == 2

assert result.report_executions[0].storage_details.path == '/r/sbom.json'

assert result.report_executions[1].error_message == 'Timeout'

assert result.report_executions[1].storage_details is None

# --- UserAgentOptionScheme ---

def test_user_agent_option_schema_load() -> None:

raw = {

'app_name': 'vscode_extension',

'app_version': '0.2.3',

'env_name': 'Visual Studio Code',

'env_version': '1.78.2',

}

result = UserAgentOptionScheme().load(raw)

assert isinstance(result, UserAgentOption)

assert result.app_name == 'vscode_extension'

assert 'vscode_extension' in result.user_agent_suffix

assert 'AppVersion: 0.2.3' in result.user_agent_suffix

# --- MemberSchema / RequestedMemberDetailsResultSchema ---

def test_member_schema_load() -> None:

raw = {'external_id': 'user-ext-123'}

result = MemberSchema().load(raw)

assert isinstance(result, Member)

assert result.external_id == 'user-ext-123'

def test_requested_member_details_schema_load() -> None:

raw = {

'items': [{'external_id': 'u1'}, {'external_id': 'u2'}],

'page_size': 50,

'next_page_token': 'token-abc',

}

result = RequestedMemberDetailsResultSchema().load(raw)

assert isinstance(result, MemberDetails)

assert len(result.items) == 2

assert result.page_size == 50

assert result.next_page_token == 'token-abc'

def test_requested_member_details_schema_load_null_token() -> None:

raw = {

'items': [],

'page_size': 50,

'next_page_token': None,

}

result = RequestedMemberDetailsResultSchema().load(raw)

assert result.next_page_token is None

# --- ClassificationDataSchema / DetectionRuleSchema ---

def test_classification_data_schema_load() -> None:

raw = {'severity': 'high'}

result = ClassificationDataSchema().load(raw)

assert isinstance(result, ClassificationData)

assert result.severity == 'high'

def test_detection_rule_schema_load() -> None:

raw = {

'classification_data': [{'severity': 'high'}, {'severity': 'medium'}],

'detection_rule_id': 'rule-123',

'custom_remediation_guidelines': 'Rotate the key',

'remediation_guidelines': 'See docs',

'description': 'Exposed API key',

'policy_name': 'secrets-policy',

'display_name': 'API Key Exposure',

}

result = DetectionRuleSchema().load(raw)

assert isinstance(result, DetectionRule)

assert len(result.classification_data) == 2

assert result.classification_data[0].severity == 'high'

assert result.detection_rule_id == 'rule-123'

assert result.custom_remediation_guidelines == 'Rotate the key'

def test_detection_rule_schema_load_optional_nulls() -> None:

raw = {

'classification_data': [{'severity': 'low'}],

'detection_rule_id': 'rule-456',

'custom_remediation_guidelines': None,

'remediation_guidelines': None,

'description': None,

'policy_name': None,

'display_name': None,

}

result = DetectionRuleSchema().load(raw)

assert result.custom_remediation_guidelines is None

assert result.display_name is None

# --- ScanResultsSyncFlowSchema ---

def test_scan_results_sync_flow_schema_load() -> None:

raw = {

'id': 'sync-123',

'detection_messages': [{'msg': 'found secret'}, {'msg': 'found vuln'}],

}

result = ScanResultsSyncFlowSchema().load(raw)

assert isinstance(result, ScanResultsSyncFlow)

assert result.id == 'sync-123'

assert len(result.detection_messages) == 2

# --- SupportedModulesPreferencesSchema ---

def test_supported_modules_preferences_schema_load() -> None:

raw = {

'secret_scanning': True,

'leak_scanning': True,

'iac_scanning': False,

'sca_scanning': True,

'ci_cd_scanning': False,

'sast_scanning': True,

'container_scanning': False,

'access_review': True,

'asoc': False,

'cimon': True,

'ai_machine_learning': True,

'ai_large_language_model': False,

}

result = SupportedModulesPreferencesSchema().load(raw)

assert isinstance(result, SupportedModulesPreferences)

assert result.secret_scanning is True

assert result.iac_scanning is False

assert result.ai_large_language_model is False

# --- ScanConfigurationSchema ---

def test_scan_configuration_schema_load() -> None:

raw = {

'scannable_extensions': ['.py', '.js', '.ts'],

'is_cycode_ignore_allowed': True,

}

result = ScanConfigurationSchema().load(raw)

assert isinstance(result, ScanConfiguration)

assert result.scannable_extensions == ['.py', '.js', '.ts']

assert result.is_cycode_ignore_allowed is True

def test_scan_configuration_schema_load_defaults() -> None:

raw = {

'scannable_extensions': None,

}

result = ScanConfigurationSchema().load(raw)

assert result.scannable_extensions is None

assert result.is_cycode_ignore_allowed is True # load_default=True