test_inference.py

"""
Inference Test Script
======================

This script tests that trained models can be loaded and used for inference
WITHOUT running any training code. This validates the strict separation
between training and inference.

Usage:
    python test_inference.py
"""

import os
import sys

# Add package to path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))


def test_sorting_inference():
    """Test sorting model inference."""
    print("=" * 60)
    print("TESTING SORTING INFERENCE")
    print("=" * 60)

    from sorting.recommender import SortingRecommender

    # Load model (NO training code runs)
    recommender = SortingRecommender()
    recommender.load_model()  # Uses default models directory

    # Test cases
    test_cases = [
        ([5, 2, 8, 1, 9, 3, 7], "Small random"),
        (list(range(100)), "Already sorted"),
        (list(range(100, 0, -1)), "Reverse sorted"),
        ([x for x in range(1000)], "Large sorted"),
        ([float(x % 10) for x in range(500)], "Many duplicates"),
    ]

    print("\nInference results:")
    for arr, description in test_cases:
        result = recommender.recommend(arr)
        print(f"  {description:20s} → {result['algorithm']}")

    # Execute recommendation
    arr = [10, 5, 8, 3, 1]
    sorted_arr, algo, explanation = recommender.execute_recommendation(arr)
    print(f"\nExecuted sorting:")
    print(f"  Input:  {arr}")
    print(f"  Output: {sorted_arr}")
    print(f"  Algorithm: {algo}")

    return True


def test_array_search_inference():
    """Test array search model inference."""
    print("\n" + "=" * 60)
    print("TESTING ARRAY SEARCH INFERENCE")
    print("=" * 60)

    from searching.array_search.recommender import ArraySearchRecommender

    # Load model
    recommender = ArraySearchRecommender()
    recommender.load_model()

    # Test cases
    test_cases = [
        ([1, 2, 3, 4, 5], "Sorted uniform"),
        ([5, 2, 8, 1, 9], "Unsorted"),
        (list(range(0, 1000, 10)), "Large sorted uniform"),
    ]

    print("\nInference results:")
    for arr, description in test_cases:
        result = recommender.recommend(arr)
        print(f"  {description:20s} → {result['algorithm']} (valid: {result['valid_algorithms']})")

    # Verify correctness constraint
    unsorted = [5, 2, 8, 1, 9]
    result = recommender.recommend(unsorted)
    if result['algorithm'] != 'linear_search':
        print(f"\n  ✗ ERROR: Unsorted array got {result['algorithm']} instead of linear_search!")
        return False
    else:
        print(f"\n  ✓ Correctness constraint verified: unsorted → linear_search only")

    return True


def test_graph_search_inference():
    """Test graph search model inference."""
    print("\n" + "=" * 60)
    print("TESTING GRAPH SEARCH INFERENCE")
    print("=" * 60)

    from searching.graph_search.recommender import GraphSearchRecommender

    # Load model
    recommender = GraphSearchRecommender()
    recommender.load_model()

    # Test cases
    test_cases = [
        # Unweighted graph
        ({0: [(1, 1.0), (2, 1.0)], 1: [(3, 1.0)], 2: [(3, 1.0)], 3: []}, False, "Unweighted"),
        # Weighted non-negative
        ({0: [(1, 5.0), (2, 3.0)], 1: [(2, 2.0)], 2: []}, False, "Weighted+"),
        # Weighted with negative
        ({0: [(1, 5.0)], 1: [(2, -3.0)], 2: []}, False, "Negative weight"),
    ]

    print("\nInference results:")
    for graph, has_heur, description in test_cases:
        result = recommender.recommend(graph, has_heuristic=has_heur)
        print(f"  {description:20s} → {result['algorithm']} (valid: {result['valid_algorithms']})")

    # Verify correctness constraint for negative weights
    neg_graph = {0: [(1, 5.0)], 1: [(2, -3.0)], 2: []}
    result = recommender.recommend(neg_graph)
    if result['algorithm'] != 'bellman_ford':
        print(f"\n  ✗ ERROR: Negative weight graph got {result['algorithm']}!")
        return False
    else:
        print(f"\n  ✓ Correctness constraint verified: negative weights → bellman_ford")

    return True


def main():
    """Run all inference tests."""
    print("=" * 60)
    print("INFERENCE TEST - STRICT TRAINING/INFERENCE SEPARATION")
    print("=" * 60)
    print("\nThis test verifies that:")
    print("  1. Models can be loaded from .pkl files")
    print("  2. Inference works without running training code")
    print("  3. Correctness constraints are enforced")

    try:
        sorting_ok = test_sorting_inference()
        array_ok = test_array_search_inference()
        graph_ok = test_graph_search_inference()

        print("\n" + "=" * 60)
        print("INFERENCE TEST SUMMARY")
        print("=" * 60)
        print(f"  Sorting:      {'✓ PASS' if sorting_ok else '✗ FAIL'}")
        print(f"  Array Search: {'✓ PASS' if array_ok else '✗ FAIL'}")
        print(f"  Graph Search: {'✓ PASS' if graph_ok else '✗ FAIL'}")

        if sorting_ok and array_ok and graph_ok:
            print("\n✅ ALL INFERENCE TESTS PASSED")
            print("   Training and inference are properly separated.")
            return 0
        else:
            print("\n❌ SOME TESTS FAILED")
            return 1

    except Exception as e:
        print(f"\n❌ ERROR: {e}")
        import traceback
        traceback.print_exc()
        return 1


if __name__ == '__main__':
    sys.exit(main())