Valerio Tenace

"""
Unit tests for Mach-O dataclasses.
"""
import pytest
from typing import List, Dict, Optional

pytestmark = [pytest.mark.unit, pytest.mark.dataclass, pytest.mark.macho]


class TestMachODataclass:
    """Tests for MachO dataclass."""

    def test_macho_required_fields(self):
        """Test MachO dataclass with required fields."""
        from redb.models.dataclasses import MachO

        macho = MachO(
            magic=0xFEEDFACF,
            cputype=0x01000007,
            cpusubtype=0x00000003,
            filetype=2,
            ncmds=15,
            sizeofcmds=1024,
            flags=0x00200085,
            architecture=0x01000007,
            architectures=[0x01000007],
            magic_str="MH_MAGIC_64",
            cputype_str="CPU_TYPE_X86_64",
            cpusubtype_str="CPU_SUBTYPE_X86_64_ALL",
            filetype_str="MH_EXECUTE",
            flags_str=["MH_NOUNDEFS", "MH_DYLDLINK", "MH_TWOLEVEL", "MH_PIE"],
            architecture_str="x86_64",
            architectures_str=["x86_64"],
            is_64bit=True,
            is_signed=True
        )

        assert macho.magic == 0xFEEDFACF
        assert macho.cputype == 0x01000007
        assert macho.is_64bit is True
        assert macho.is_signed is True
        assert macho.magic_str == "MH_MAGIC_64"
        assert macho.filetype_str == "MH_EXECUTE"

    def test_macho_optional_fields_defaults(self):
        """Test MachO dataclass optional fields default to correct values."""
        from redb.models.dataclasses import MachO

        macho = MachO(
            magic=0xFEEDFACF,
            cputype=0x01000007,
            cpusubtype=0x00000003,
            filetype=2,
            ncmds=15,
            sizeofcmds=1024,
            flags=0x00200085,
            architecture=0x01000007,
            architectures=[0x01000007],
            magic_str="MH_MAGIC_64",
            cputype_str="CPU_TYPE_X86_64",
            cpusubtype_str="CPU_SUBTYPE_X86_64_ALL",
            filetype_str="MH_EXECUTE",
            flags_str=["MH_NOUNDEFS"],
            architecture_str="x86_64",
            architectures_str=["x86_64"],
            is_64bit=True,
            is_signed=False
        )

        assert macho.number_of_load_commands == 0
        assert macho.load_commands_set is None
        assert macho.number_of_segments == 0
        assert macho.number_of_dylibs == 0
        assert macho.number_of_imports == 0
        assert macho.number_of_exports == 0
        assert macho.entry_point is None
        assert macho.uuid is None
        assert macho.version_info is None
        assert macho.version_info_str is None

    def test_macho_with_all_fields(self):
        """Test MachO dataclass with all fields populated."""
        from redb.models.dataclasses import MachO

        macho = MachO(
            magic=0xFEEDFACF,
            cputype=0x01000007,
            cpusubtype=0x00000003,
            filetype=2,
            ncmds=15,
            sizeofcmds=1024,
            flags=0x00200085,
            architecture=0x01000007,
            architectures=[0x01000007],
            magic_str="MH_MAGIC_64",
            cputype_str="CPU_TYPE_X86_64",
            cpusubtype_str="CPU_SUBTYPE_X86_64_ALL",
            filetype_str="MH_EXECUTE",
            flags_str=["MH_PIE"],
            architecture_str="x86_64",
            architectures_str=["x86_64"],
            is_64bit=True,
            is_signed=True,
            number_of_load_commands=15,
            load_commands_set=["LC_SEGMENT_64", "LC_DYLD_INFO_ONLY"],
            number_of_segments=4,
            number_of_dylibs=5,
            number_of_imports=100,
            number_of_exports=10,
            entry_point=0x100001234,
            uuid="12345678-1234-1234-1234-123456789012",
            version_info={"min_os": "10.15"},
            version_info_str={"min_os": "macOS 10.15"}
        )

        assert macho.number_of_load_commands == 15
        assert macho.uuid == "12345678-1234-1234-1234-123456789012"
        assert macho.entry_point == 0x100001234


class TestMachOSegmentDataclass:
    """Tests for MachOSegment dataclass."""

    def test_segment_creation(self):
        """Test MachOSegment dataclass creation."""
        from redb.models.dataclasses import MachOSegment

        segment = MachOSegment(
            segment_name="__TEXT",
            segment_vaddr=0x100000000,
            segment_vsize=0x1000,
            segment_offset=0,
            segment_size=0x1000,
            segment_max_vm_protection=7,
            segment_initial_vm_protection=5,
            segment_nsects=4,
            segment_flags=0,
            segment_entropy=6.5,
            segment_sha256="abc123def456789012345678901234567890123456789012345678901234"
        )

        assert segment.segment_name == "__TEXT"
        assert segment.segment_vaddr == 0x100000000
        assert segment.segment_entropy == 6.5


class TestMachOImportDataclass:
    """Tests for MachOImport dataclass."""

    def test_import_creation(self):
        """Test MachOImport dataclass creation."""
        from redb.models.dataclasses import MachOImport

        import_info = MachOImport(
            macho_imports_total=50,
            macho_import_libraryName=["libSystem.B.dylib", "CoreFoundation"],
            macho_import_functions=["_printf", "_malloc", "_free"]
        )

        assert import_info.macho_imports_total == 50
        assert len(import_info.macho_import_libraryName) == 2
        assert "_printf" in import_info.macho_import_functions

    def test_import_optional_fields(self):
        """Test MachOImport with optional fields as None."""
        from redb.models.dataclasses import MachOImport

        import_info = MachOImport(macho_imports_total=0)

        assert import_info.macho_imports_total == 0
        assert import_info.macho_import_libraryName is None
        assert import_info.macho_import_functions is None


class TestMachOExportDataclass:
    """Tests for MachOExport dataclass."""

    def test_export_creation(self):
        """Test MachOExport dataclass creation."""
        from redb.models.dataclasses import MachOExport

        export_info = MachOExport(
            macho_exports_total=10,
            macho_export_symbols=["_main", "_helper_func"]
        )

        assert export_info.macho_exports_total == 10
        assert "_main" in export_info.macho_export_symbols


class TestMachODylibDataclass:
    """Tests for MachODylib dataclass."""

    def test_dylib_creation(self):
        """Test MachODylib dataclass creation."""
        from redb.models.dataclasses import MachODylib

        dylib = MachODylib(
            dylib_name="/usr/lib/libSystem.B.dylib",
            dylib_timestamp=2,
            dylib_current_version=0x04E10200,
            dylib_compat_version=0x00010000
        )

        assert dylib.dylib_name == "/usr/lib/libSystem.B.dylib"
        assert dylib.dylib_timestamp == 2


class TestMachOLoadCommandDataclass:
    """Tests for MachOLoadCommand dataclass."""

    def test_load_command_creation(self):
        """Test MachOLoadCommand dataclass creation."""
        from redb.models.dataclasses import MachOLoadCommand

        lc = MachOLoadCommand(
            load_command=0x19,
            load_command_str="LC_SEGMENT_64",
            load_command_size=72
        )

        assert lc.load_command == 0x19
        assert lc.load_command_str == "LC_SEGMENT_64"
        assert lc.load_command_size == 72


class TestMachOUniversalDataclass:
    """Tests for MachOUniversal dataclass."""

    def test_universal_fat_binary(self):
        """Test MachOUniversal for FAT binary."""
        from redb.models.dataclasses import MachOUniversal

        universal = MachOUniversal(
            is_fat=True,
            architecture_count=2,
            architectures=["x86_64", "arm64"],
            architecture_info=[
                {"arch": "x86_64", "offset": 0x1000},
                {"arch": "arm64", "offset": 0x10000}
            ],
            fat_hash="abc123def456789012345678901234567890123456789012345678901234",
            fat_md5="abc123def456789012345678901234",
            fat_sha1="abc123def456789012345678901234567890"
        )

        assert universal.is_fat is True
        assert universal.architecture_count == 2
        assert "x86_64" in universal.architectures
        assert "arm64" in universal.architectures

    def test_universal_single_arch(self):
        """Test MachOUniversal for single-architecture binary."""
        from redb.models.dataclasses import MachOUniversal

        universal = MachOUniversal(
            is_fat=False,
            architecture_count=1,
            architectures=["arm64"],
            architecture_info=[{"arch": "arm64", "offset": 0}]
        )

        assert universal.is_fat is False
        assert universal.architecture_count == 1
        assert universal.fat_hash is None


class TestMachOCertificateDataclass:
    """Tests for MachOCertificate dataclass."""

    def test_certificate_creation(self):
        """Test MachOCertificate dataclass creation."""
        from redb.models.dataclasses import MachOCertificate

        cert = MachOCertificate(
            subject="CN=Apple Development",
            issuer="CN=Apple Worldwide Developer Relations",
            serial_number="123456789",
            not_before="2023-01-01T00:00:00Z",
            not_after="2024-01-01T00:00:00Z",
            thumbprint="abc123def456789012345678901234567890",
            certificate_type="leaf",
            order=0,
            algorithm="sha256WithRSAEncryption",
            common_name="Apple Development",
            organizational_unit="Development",
            organization="Apple Inc."
        )

        assert cert.subject == "CN=Apple Development"
        assert cert.certificate_type == "leaf"
        assert cert.order == 0


class TestMachOCodeDirectoryDataclass:
    """Tests for MachOCodeDirectory dataclass."""

    def test_code_directory_creation(self):
        """Test MachOCodeDirectory dataclass creation."""
        from redb.models.dataclasses import MachOCodeDirectory

        cd = MachOCodeDirectory(
            identifier="com.example.app",
            team_id="ABC123DEF",
            flags=0x10000,
            cd_hash="abc123def456789012345678901234567890123456789012345678901234"
        )

        assert cd.identifier == "com.example.app"
        assert cd.team_id == "ABC123DEF"
        assert cd.flags == 0x10000


class TestMachOCodeSigningInfoDataclass:
    """Tests for MachOCodeSigningInfo dataclass."""

    def test_code_signing_info_unsigned(self):
        """Test MachOCodeSigningInfo for unsigned binary."""
        from redb.models.dataclasses import MachOCodeSigningInfo

        info = MachOCodeSigningInfo(
            _id="abc123def456789012345678901234567890123456789012345678901234",
            signing_type="unsigned",
            has_signature=False,
            number_of_certificates=0
        )

        assert info.signing_type == "unsigned"
        assert info.has_signature is False
        assert info.number_of_certificates == 0

    def test_code_signing_info_signed(self):
        """Test MachOCodeSigningInfo for signed binary."""
        from redb.models.dataclasses import MachOCodeSigningInfo, MachOCodeDirectory

        cd = MachOCodeDirectory(
            identifier="com.example.app",
            team_id="ABC123DEF"
        )

        info = MachOCodeSigningInfo(
            _id="abc123def456789012345678901234567890123456789012345678901234",
            signing_type="certificate",
            has_signature=True,
            number_of_certificates=3,
            code_directories=[cd],
            entitlements={"com.apple.security.app-sandbox": True},
            has_hardened_runtime=True,
            has_library_validation=True
        )

        assert info.signing_type == "certificate"
        assert info.has_signature is True
        assert info.number_of_certificates == 3
        assert info.has_hardened_runtime is True

    def test_code_signing_info_adhoc(self):
        """Test MachOCodeSigningInfo for ad-hoc signed binary."""
        from redb.models.dataclasses import MachOCodeSigningInfo

        info = MachOCodeSigningInfo(
            _id="abc123def456789012345678901234567890123456789012345678901234",
            signing_type="ad-hoc",
            has_signature=True,
            number_of_certificates=0,
            arch_identifier="x86_64"
        )

        assert info.signing_type == "ad-hoc"
        assert info.number_of_certificates == 0
        assert info.arch_identifier == "x86_64"


class TestMachOEntitlementDataclass:
    """Tests for MachOEntitlement dataclass."""

    def test_entitlement_boolean(self):
        """Test MachOEntitlement with boolean value."""
        from redb.models.dataclasses import MachOEntitlement

        ent = MachOEntitlement(
            key="com.apple.security.app-sandbox",
            value_type="boolean",
            value_bool=True
        )

        assert ent.key == "com.apple.security.app-sandbox"
        assert ent.value_type == "boolean"
        assert ent.value_bool is True

    def test_entitlement_string(self):
        """Test MachOEntitlement with string value."""
        from redb.models.dataclasses import MachOEntitlement

        ent = MachOEntitlement(
            key="com.apple.developer.team-identifier",
            value_type="string",
            value_string="ABC123DEF"
        )

        assert ent.key == "com.apple.developer.team-identifier"
        assert ent.value_type == "string"
        assert ent.value_string == "ABC123DEF"

    def test_entitlement_array(self):
        """Test MachOEntitlement with array value."""
        from redb.models.dataclasses import MachOEntitlement

        ent = MachOEntitlement(
            key="com.apple.security.application-groups",
            value_type="array",
            value_array=["group.com.example.app", "group.com.example.shared"]
        )

        assert ent.key == "com.apple.security.application-groups"
        assert ent.value_type == "array"
        assert len(ent.value_array) == 2