2125_GCE/tests/test_cognitive_kernel.py

#!/usr/bin/env python3
"""Tests for GlyphOS Cognitive Kernel

Tests verify:
- CognitiveKernel initialization and warmup
- GX execution through LAIN pipeline
- Result caching and accessors
- Glyph registry integration
- Functional API (singleton, run_gx, kernel_status)
"""

import sys
import tempfile
from pathlib import Path

sys.path.insert(0, str(Path.cwd()))

from glyphos.cognitive_kernel import (
    CognitiveKernel,
    get_kernel,
    run_gx,
    kernel_status,
)
from gx_cli.main import main as gx_main
from glyphs.super_registry import super_stats


def _create_test_gx() -> Path:
    """Create a test .gx file for kernel execution tests.

    Returns:
        Path to compiled .gx file
    """
    # Use sample_code.py as source
    source = Path("/home/dave/sample_code.py")
    if not source.exists():
        raise FileNotFoundError("Sample code not found")

    # Compile to temporary .gx
    temp_gx = Path(tempfile.gettempdir()) / "test_kernel.gx"

    # Clean up old file
    if temp_gx.exists():
        temp_gx.unlink()

    # Compile
    exit_code = gx_main(["compile", str(source), "-o", str(temp_gx)])
    if exit_code != 0:
        raise RuntimeError(f"Compilation failed with exit code {exit_code}")

    if not temp_gx.exists():
        raise RuntimeError("Compilation did not produce output file")

    return temp_gx


def test_kernel_initialization():
    """Test CognitiveKernel initialization."""
    kernel = CognitiveKernel(auto_load_glyphs=True)

    if kernel is None:
        print("FAIL: Could not create CognitiveKernel")
        return False

    if kernel._warmed_up:
        print("FAIL: Kernel should not be warmed up on initialization")
        return False

    if kernel._last_result is not None:
        print("FAIL: Last result should be None initially")
        return False

    print("PASS: CognitiveKernel initializes correctly")
    return True


def test_kernel_warmup():
    """Test kernel warmup and glyph loading."""
    kernel = CognitiveKernel(auto_load_glyphs=True)

    kernel.warmup()

    if not kernel._warmed_up:
        print("FAIL: Kernel not marked as warmed up")
        return False

    if kernel._startup_time is None:
        print("FAIL: Startup time not recorded")
        return False

    if kernel._glyph_stats_cache is None:
        print("FAIL: Glyph stats not cached")
        return False

    # Verify glyphs loaded
    stats = kernel._glyph_stats_cache
    if stats.get("total_glyphs") != 600:
        print(f"FAIL: Expected 600 glyphs, got {stats.get('total_glyphs')}")
        return False

    if not stats.get("loaded"):
        print("FAIL: Glyph registry not marked as loaded")
        return False

    print(f"PASS: Kernel warmed up with {stats['total_glyphs']} glyphs")
    return True


def test_kernel_execute_gx():
    """Test kernel GX execution."""
    kernel = CognitiveKernel(auto_load_glyphs=True)
    kernel.warmup()

    # Create test .gx file
    try:
        gx_path = _create_test_gx()
    except Exception as e:
        print(f"FAIL: Could not create test .gx: {e}")
        return False

    # Execute
    try:
        result = kernel.execute_gx(str(gx_path), mode="analyze")
    except Exception as e:
        print(f"FAIL: execute_gx raised exception: {e}")
        return False

    # Verify result structure
    if result is None:
        print("FAIL: execute_gx returned None")
        return False

    required_keys = ["fused_symbol", "diagnostics", "cognition_trace"]
    for key in required_keys:
        if key not in result:
            print(f"FAIL: Missing key in result: {key}")
            return False

    # Verify fused_symbol
    fused = result.get("fused_symbol", {})
    if not fused:
        print("FAIL: fused_symbol is empty")
        return False

    if "summary" not in fused:
        print("FAIL: fused_symbol missing 'summary'")
        return False

    # Verify diagnostics
    diags = result.get("diagnostics", {})
    if not diags:
        print("FAIL: diagnostics is empty")
        return False

    print("PASS: kernel.execute_gx() returns valid ExecutionResult")
    return True


def test_kernel_result_accessors():
    """Test result accessor methods."""
    kernel = CognitiveKernel(auto_load_glyphs=True)
    kernel.warmup()

    # Initially no result
    if kernel.get_last_result() is not None:
        print("FAIL: get_last_result should be None initially")
        return False

    if kernel.get_last_trace() is not None:
        print("FAIL: get_last_trace should be None initially")
        return False

    if kernel.get_last_fused_symbol() is not None:
        print("FAIL: get_last_fused_symbol should be None initially")
        return False

    if kernel.get_last_resonance() is not None:
        print("FAIL: get_last_resonance should be None initially")
        return False

    # Execute and verify accessors work
    try:
        gx_path = _create_test_gx()
    except Exception as e:
        print(f"FAIL: Could not create test .gx: {e}")
        return False

    kernel.execute_gx(str(gx_path))

    # Now check accessors
    last_result = kernel.get_last_result()
    if last_result is None:
        print("FAIL: get_last_result should not be None after execution")
        return False

    last_trace = kernel.get_last_trace()
    if last_trace is None:
        print("FAIL: get_last_trace should not be None after execution")
        return False

    if not isinstance(last_trace, list):
        print("FAIL: get_last_trace should return a list")
        return False

    last_symbol = kernel.get_last_fused_symbol()
    if last_symbol is None:
        print("FAIL: get_last_fused_symbol should not be None after execution")
        return False

    if "summary" not in last_symbol:
        print("FAIL: fused_symbol should have 'summary'")
        return False

    last_resonance = kernel.get_last_resonance()
    if last_resonance is None:
        print("FAIL: get_last_resonance should not be None after execution")
        return False

    print("PASS: All result accessors work correctly")
    return True


def test_kernel_glyph_stats():
    """Test glyph statistics retrieval."""
    kernel = CognitiveKernel(auto_load_glyphs=True)
    kernel.warmup()

    stats = kernel.get_glyph_stats()

    if stats is None:
        print("FAIL: get_glyph_stats returned None")
        return False

    required_keys = ["total_glyphs", "fields_present", "categories", "loaded"]
    for key in required_keys:
        if key not in stats:
            print(f"FAIL: Missing key in glyph_stats: {key}")
            return False

    if stats["total_glyphs"] != 600:
        print(f"FAIL: Expected 600 glyphs, got {stats['total_glyphs']}")
        return False

    if not isinstance(stats["categories"], list):
        print("FAIL: categories should be a list")
        return False

    if stats["loaded"] != True:
        print("FAIL: Registry should be marked as loaded")
        return False

    if "kernel_startup_time" not in stats:
        print("FAIL: kernel_startup_time not in stats")
        return False

    print(f"PASS: get_glyph_stats returns {stats['total_glyphs']} glyphs in {len(stats['categories'])} categories")
    return True


def test_get_kernel_singleton():
    """Test get_kernel() singleton behavior."""
    kernel1 = get_kernel()
    kernel2 = get_kernel()

    if kernel1 is None or kernel2 is None:
        print("FAIL: get_kernel returned None")
        return False

    if kernel1 is not kernel2:
        print("FAIL: get_kernel should return same instance")
        return False

    if not kernel1._warmed_up:
        print("FAIL: Kernel should be warmed up by get_kernel")
        return False

    print("PASS: get_kernel returns warmed-up singleton")
    return True


def test_run_gx_function():
    """Test run_gx convenience function."""
    try:
        gx_path = _create_test_gx()
    except Exception as e:
        print(f"FAIL: Could not create test .gx: {e}")
        return False

    try:
        result = run_gx(str(gx_path), mode="analyze")
    except Exception as e:
        print(f"FAIL: run_gx raised exception: {e}")
        return False

    if result is None:
        print("FAIL: run_gx returned None")
        return False

    if "fused_symbol" not in result:
        print("FAIL: Result missing fused_symbol")
        return False

    kernel = get_kernel()
    last_result = kernel.get_last_result()
    if last_result is not result:
        print("FAIL: run_gx should update kernel's last_result")
        return False

    print("PASS: run_gx convenience function works")
    return True


def test_kernel_status_function():
    """Test kernel_status() convenience function."""
    # Reset singleton to test initial state
    from glyphos import cognitive_kernel
    cognitive_kernel._GLOBAL_KERNEL = None

    status = kernel_status()

    if status is None:
        print("FAIL: kernel_status returned None")
        return False

    required_keys = [
        "glyph_stats",
        "last_run_present",
        "last_mode",
        "startup_time",
        "is_warmed_up"
    ]
    for key in required_keys:
        if key not in status:
            print(f"FAIL: Missing key in kernel_status: {key}")
            return False

    if not status["is_warmed_up"]:
        print("FAIL: Kernel should be warmed up by kernel_status")
        return False

    if status["last_run_present"]:
        print("FAIL: Should not have last_run_present on fresh kernel")
        return False

    if status["glyph_stats"]["total_glyphs"] != 600:
        print("FAIL: glyph_stats should have 600 glyphs")
        return False

    # Execute and verify status updates
    try:
        gx_path = _create_test_gx()
        run_gx(str(gx_path))
    except Exception as e:
        print(f"FAIL: Could not execute test: {e}")
        return False

    status = kernel_status()
    if not status["last_run_present"]:
        print("FAIL: Should have last_run_present after execution")
        return False

    if status["last_mode"] != "analyze":
        print("FAIL: last_mode should be 'analyze'")
        return False

    print("PASS: kernel_status correctly reflects kernel state")
    return True


def main_test():
    print("[TEST SUITE] test_cognitive_kernel.py")
    print()

    tests = [
        ("Kernel initialization", test_kernel_initialization),
        ("Kernel warmup", test_kernel_warmup),
        ("Execute GX", test_kernel_execute_gx),
        ("Result accessors", test_kernel_result_accessors),
        ("Glyph stats", test_kernel_glyph_stats),
        ("get_kernel singleton", test_get_kernel_singleton),
        ("run_gx function", test_run_gx_function),
        ("kernel_status function", test_kernel_status_function),
    ]

    passed = 0
    failed = 0

    for name, test_func in tests:
        print(f"Running: {name}...", end=" ")
        try:
            if test_func():
                passed += 1
            else:
                failed += 1
        except Exception as e:
            print(f"FAIL: {e}")
            failed += 1

    print()
    print(f"Results: {passed} passed, {failed} failed")

    return 0 if failed == 0 else 1


if __name__ == "__main__":
    sys.exit(main_test())