dss/dss-claude-plugin/tests/test_context_compiler.py

"""
Test Suite for DSS Context Compiler
Validates all core functionality: cascade merging, token resolution, security, and error handling.
"""

import json
import os
import sys
from pathlib import Path

# Add parent directory to path for imports
sys.path.insert(0, str(Path(__file__).parent.parent))

from core import (
    ContextCompiler,
    get_active_context,
    resolve_token,
    validate_manifest,
    list_skins,
    get_compiler_status,
    EMERGENCY_SKIN
)


class TestContextCompiler:
    """Test suite for Context Compiler"""

    def __init__(self):
        self.base_dir = Path(__file__).parent.parent
        self.skins_dir = self.base_dir / "core" / "skins"
        self.admin_manifest = self.base_dir.parent / "admin-ui" / "ds.config.json"
        self.compiler = ContextCompiler(skins_dir=str(self.skins_dir))
        self.passed = 0
        self.failed = 0

    def assert_equal(self, actual, expected, message):
        """Simple assertion helper"""
        if actual == expected:
            print(f"✓ {message}")
            self.passed += 1
            return True
        else:
            print(f"✗ {message}")
            print(f"  Expected: {expected}")
            print(f"  Actual: {actual}")
            self.failed += 1
            return False

    def assert_true(self, condition, message):
        """Assert condition is true"""
        if condition:
            print(f"✓ {message}")
            self.passed += 1
            return True
        else:
            print(f"✗ {message}")
            self.failed += 1
            return False

    def assert_in(self, needle, haystack, message):
        """Assert needle is in haystack"""
        if needle in haystack:
            print(f"✓ {message}")
            self.passed += 1
            return True
        else:
            print(f"✗ {message}")
            print(f"  '{needle}' not found in {haystack}")
            self.failed += 1
            return False

    def test_basic_compilation(self):
        """Test 1: Basic 3-layer cascade compilation"""
        print("\n=== Test 1: Basic Compilation (3-Layer Cascade) ===")

        try:
            context = self.compiler.compile(str(self.admin_manifest))

            # Test project override (Layer 3)
            self.assert_equal(
                context.get("tokens", {}).get("colors", {}).get("primary"),
                "#6366f1",
                "Project override applied correctly (colors.primary)"
            )

            # Test skin value (Layer 2 - workbench)
            self.assert_equal(
                context.get("tokens", {}).get("colors", {}).get("background"),
                "#0F172A",
                "Workbench skin value inherited (colors.background)"
            )

            # Test base value (Layer 1)
            self.assert_equal(
                context.get("tokens", {}).get("spacing", {}).get("0"),
                "0px",
                "Base skin value inherited (spacing.0)"
            )

            # Test metadata injection
            self.assert_in("_meta", context, "Metadata injected into context")
            self.assert_equal(
                context.get("_meta", {}).get("project_id"),
                "dss-admin",
                "Project ID in metadata"
            )

        except Exception as e:
            print(f"✗ Basic compilation failed with error: {e}")
            self.failed += 1

    def test_debug_provenance(self):
        """Test 2: Debug provenance tracking"""
        print("\n=== Test 2: Debug Provenance Tracking ===")

        try:
            context = self.compiler.compile(str(self.admin_manifest), debug=True)

            self.assert_in("_provenance", context, "Provenance data included in debug mode")
            self.assert_true(
                isinstance(context.get("_provenance", []), list),
                "Provenance is a list"
            )
            self.assert_true(
                len(context.get("_provenance", [])) > 0,
                "Provenance contains tracking entries"
            )

        except Exception as e:
            print(f"✗ Debug provenance test failed with error: {e}")
            self.failed += 1

    def test_token_resolution(self):
        """Test 3: Token resolution via MCP tool"""
        print("\n=== Test 3: Token Resolution ===")

        try:
            # Test project override token
            result = resolve_token(str(self.admin_manifest), "colors.primary")
            self.assert_equal(result, "#6366f1", "Resolved project override token")

            # Test skin-level token
            result = resolve_token(str(self.admin_manifest), "colors.background")
            self.assert_equal(result, "#0F172A", "Resolved skin-level token")

            # Test base-level token
            result = resolve_token(str(self.admin_manifest), "spacing.0")
            self.assert_equal(result, "0px", "Resolved base-level token")

            # Test nested token
            result = resolve_token(str(self.admin_manifest), "typography.fontFamily.sans")
            self.assert_true(
                "Inter" in result or "system-ui" in result,
                "Resolved nested token"
            )

            # Test non-existent token
            result = resolve_token(str(self.admin_manifest), "nonexistent.token")
            self.assert_in("not found", result, "Non-existent token returns error message")

        except Exception as e:
            print(f"✗ Token resolution test failed with error: {e}")
            self.failed += 1

    def test_skin_listing(self):
        """Test 4: Skin listing functionality"""
        print("\n=== Test 4: Skin Listing ===")

        try:
            skins_json = list_skins()
            skins = json.loads(skins_json)

            self.assert_in("base", skins, "Base skin listed")
            self.assert_in("classic", skins, "Classic skin listed")
            self.assert_in("workbench", skins, "Workbench skin listed")
            self.assert_true(len(skins) >= 3, "At least 3 skins available")

        except Exception as e:
            print(f"✗ Skin listing test failed with error: {e}")
            self.failed += 1

    def test_safe_boot_protocol(self):
        """Test 5: Safe Boot Protocol (emergency fallback)"""
        print("\n=== Test 5: Safe Boot Protocol ===")

        try:
            # Test with non-existent manifest
            context = self.compiler.compile("/nonexistent/path.json")

            self.assert_equal(
                context.get("status"),
                "emergency_mode",
                "Emergency mode activated for invalid path"
            )

            self.assert_in("_error", context, "Error details included in safe boot")

            # Validate emergency skin has required structure
            self.assert_in("tokens", context, "Emergency skin has tokens")
            self.assert_in("colors", context.get("tokens", {}), "Emergency skin has colors")
            self.assert_in("primary", context.get("tokens", {}).get("colors", {}), "Emergency skin has primary color")

        except Exception as e:
            print(f"✗ Safe Boot Protocol test failed with error: {e}")
            self.failed += 1

    def test_path_traversal_prevention(self):
        """Test 6: Security - Path traversal prevention"""
        print("\n=== Test 6: Path Traversal Prevention (Security) ===")

        try:
            # Attempt path traversal attack
            try:
                self.compiler._load_skin("../../etc/passwd")
                print("✗ Path traversal not prevented!")
                self.failed += 1
            except ValueError as e:
                self.assert_in(
                    "path traversal",
                    str(e).lower(),
                    "Path traversal attack blocked"
                )

            # Attempt another variant
            try:
                self.compiler._load_skin("../../../root/.ssh/id_rsa")
                print("✗ Path traversal variant not prevented!")
                self.failed += 1
            except ValueError as e:
                self.assert_in(
                    "path traversal",
                    str(e).lower(),
                    "Path traversal variant blocked"
                )

        except Exception as e:
            print(f"✗ Path traversal prevention test failed with unexpected error: {e}")
            self.failed += 1

    def test_compiler_status(self):
        """Bonus Test: Compiler status tool"""
        print("\n=== Bonus Test: Compiler Status ===")

        try:
            status_json = get_compiler_status()
            status = json.loads(status_json)

            self.assert_equal(status.get("status"), "active", "Compiler status is active")
            self.assert_in("skins_directory", status, "Status includes skins directory")
            self.assert_in("safe_boot_ready", status, "Status confirms Safe Boot ready")

        except Exception as e:
            print(f"✗ Compiler status test failed with error: {e}")
            self.failed += 1

    def run_all_tests(self):
        """Execute all tests and report results"""
        print("=" * 60)
        print("DSS Context Compiler Test Suite")
        print("=" * 60)

        self.test_basic_compilation()
        self.test_debug_provenance()
        self.test_token_resolution()
        self.test_skin_listing()
        self.test_safe_boot_protocol()
        self.test_path_traversal_prevention()
        self.test_compiler_status()

        print("\n" + "=" * 60)
        print(f"Test Results: {self.passed} passed, {self.failed} failed")
        print("=" * 60)

        if self.failed == 0:
            print("✓ ALL TESTS PASSED - Ready for production deployment")
            return True
        else:
            print("✗ SOME TESTS FAILED - Review errors before deploying")
            return False


if __name__ == "__main__":
    tester = TestContextCompiler()
    success = tester.run_all_tests()
    sys.exit(0 if success else 1)