""" Unit & Integration Test Suite for FreeExile Anti-Hallucination & System Hardening: - 1. Native C++ SIMD Bridge: Strict mode enforcement (FatalNativeEngineInitError) vs Fallback. - 2. 1M CCU Swarm Harness: Mathematical extrapolation transparency & socket disclaimer. - 3. Apple App Attest: Production PKI enforcement rejecting simulated HMAC mock tokens. - 4. ISO-8601 Timestamp & Traceability audit for Combat Room Summit 3 minutes. """ from __future__ import annotations import os import re import sys import unittest PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) SERVER_DIR = os.path.join(PROJECT_ROOT, "server") if SERVER_DIR not in sys.path: sys.path.insert(0, SERVER_DIR) if PROJECT_ROOT not in sys.path: sys.path.insert(0, PROJECT_ROOT) from server.world.native_engine_bridge import ( NativeEngineBridge, FatalNativeEngineInitError, ) from server.world.swarm_load_harness import ( SwarmConfig, SwarmSimulationHarness, SwarmBenchmarkResult, ) from server.security.app_attest import ( AppleAppAttestValidator, AppleAppAttestSecurityError, AttestationToken, ) class TestNativeEngineBridgeAntiHallucination(unittest.TestCase): """Verifies strict fail-hard behavior when native C++ engine is unavailable.""" def test_strict_mode_explicit_raises_on_missing_dll(self) -> None: """When strict_mode=True and DLL is missing, FatalNativeEngineInitError must be raised.""" bogus_path = os.path.join(PROJECT_ROOT, "server_cpp", "non_existent_fake_sim_core.dll") with self.assertRaises(FatalNativeEngineInitError) as ctx: NativeEngineBridge(dll_path=bogus_path, strict_mode=True) self.assertIn("Fatal: Native C++ engine DLL not found", str(ctx.exception)) def test_strict_mode_from_env_var_raises(self) -> None: """When FREEEXILE_STRICT_NATIVE=1, init must raise FatalNativeEngineInitError.""" bogus_path = os.path.join(PROJECT_ROOT, "server_cpp", "non_existent_fake_sim_core.dll") original_env = os.environ.get("FREEEXILE_STRICT_NATIVE") try: os.environ["FREEEXILE_STRICT_NATIVE"] = "1" with self.assertRaises(FatalNativeEngineInitError): NativeEngineBridge(dll_path=bogus_path) finally: if original_env is None: os.environ.pop("FREEEXILE_STRICT_NATIVE", None) else: os.environ["FREEEXILE_STRICT_NATIVE"] = original_env def test_fallback_mode_allowed_when_strict_disabled(self) -> None: """When strict_mode=False, bridge operates in fallback mode without raising.""" bogus_path = os.path.join(PROJECT_ROOT, "server_cpp", "non_existent_fake_sim_core.dll") bridge = NativeEngineBridge(dll_path=bogus_path, strict_mode=False) self.assertFalse(bridge.is_loaded) self.assertFalse(bridge.strict_mode) class TestSwarmHarnessAntiHallucination(unittest.TestCase): """Verifies transparency of 1M CCU swarm simulation benchmark classification.""" def setUp(self) -> None: self.config = SwarmConfig(sample_active_actors=50) self.harness = SwarmSimulationHarness(self.config) def test_benchmark_result_classification_and_disclaimer(self) -> None: """Validates benchmark result explicitly notes in-memory mathematical extrapolation.""" result: SwarmBenchmarkResult = self.harness.run_benchmark(sample_ticks=2) self.assertEqual(result.benchmark_type, "IN_MEMORY_ARITHMETIC_EXTRAPOLATION") self.assertFalse(result.is_network_socket_load_tested) self.assertIn("in-memory spatial partitioning", result.disclaimer) self.assertIn("Real multi-host TCP/WebSocket", result.disclaimer) class TestAppleAppAttestAntiHallucination(unittest.TestCase): """Verifies that production environments reject simulated HMAC mock attestation.""" def test_production_mode_blocks_mock_token_generation(self) -> None: """When require_production_pki=True, mock generation must raise AppleAppAttestSecurityError.""" validator = AppleAppAttestValidator(require_production_pki=True) with self.assertRaises(AppleAppAttestSecurityError) as ctx: validator.generate_mock_attestation(device_id="dev-01", bundle_id="com.freeexile.game.ios") self.assertIn("Cannot generate mock attestation tokens", str(ctx.exception)) def test_production_mode_rejects_mock_attestation_verification(self) -> None: """When require_production_pki=True, verify_attestation must fail with PKI warning.""" dev_validator = AppleAppAttestValidator(require_production_pki=False) mock_token = dev_validator.generate_mock_attestation( device_id="device-victim-01", bundle_id="com.freeexile.game.ios", counter=1, ) prod_validator = AppleAppAttestValidator(require_production_pki=True) is_valid, msg = prod_validator.verify_attestation(mock_token) self.assertFalse(is_valid) self.assertIn("Simulated HMAC tokens rejected", msg) self.assertIn("ASN.1 X.509 PKI certificate chain", msg) def test_production_mode_from_env_var(self) -> None: """When FREEEXILE_PRODUCTION_ATTEST=1, validator activates require_production_pki.""" original_env = os.environ.get("FREEEXILE_PRODUCTION_ATTEST") try: os.environ["FREEEXILE_PRODUCTION_ATTEST"] = "1" validator = AppleAppAttestValidator() self.assertTrue(validator.require_production_pki) finally: if original_env is None: os.environ.pop("FREEEXILE_PRODUCTION_ATTEST", None) else: os.environ["FREEEXILE_PRODUCTION_ATTEST"] = original_env class TestTimestampAndTraceabilityAudit(unittest.TestCase): """Verifies ISO-8601 timestamp compliance on Summit 3 meeting minutes.""" def test_summit_03_contains_iso8601_timestamps(self) -> None: summit_path = os.path.join( PROJECT_ROOT, "combat_room", "01_all_hands", "20261004_ALL_HANDS_summit_03_deep_audit_and_anti_hallucination.md", ) self.assertTrue(os.path.exists(summit_path), f"Summit 3 file missing at {summit_path}") with open(summit_path, "r", encoding="utf-8") as f: content = f.read() # Check ISO-8601 header timestamp self.assertIn("2026-10-04T16:00:00+07:00", content) self.assertIn("2026-10-04T19:30:00+07:00", content) # Check Action Item deadlines contain ISO-8601 timestamps iso_matches = re.findall(r"2026-10-\d{2}T\d{2}:\d{2}:\d{2}\+07:00", content) self.assertGreaterEqual(len(iso_matches), 5, "Summit 3 Action items must have ISO-8601 deadlines") if __name__ == "__main__": unittest.main()