production_tests.py

#!/usr/bin/env python3
"""
Production-grade tests for the enhanced template engine.
Tests error handling, missing variables, security, and edge cases.
"""

import sys
import logging
from template_engine import (
    TemplateEngine, 
    MissingVariableError, 
    InvalidVariableError, 
    LoopRenderError, 
    TemplateRenderError
)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')

def test_missing_variables_strict_mode():
    """Test that missing variables raise errors in strict mode."""
    print("=== Testing Missing Variables (Strict Mode) ===")
    
    engine = TemplateEngine(strict_mode=True)
    
    # Test missing simple variable
    template = "Hello $name, welcome to $site!"
    context = {'name': 'Alice'}  # Missing 'site'
    
    try:
        result = engine.render(template, context)
        print("❌ FAIL: Should have raised MissingVariableError")
        return False
    except MissingVariableError as e:
        print(f"✅ PASS: Correctly caught missing variable: {e}")
    
    # Test missing loop variable
    loop_template = """
Welcome $name!
{% for item in items %}
- $item.title: $item.description
{% endfor %}
"""
    loop_context = {'name': 'Bob'}  # Missing 'items'
    
    try:
        result = engine.render(loop_template, loop_context)
        print("❌ FAIL: Should have raised LoopRenderError")
        return False
    except LoopRenderError as e:
        print(f"✅ PASS: Correctly caught missing loop variable: {e}")
    
    # Test missing nested variable in loop
    nested_template = """
{% for user in users %}
- $user.name ($user.missing_field)
{% endfor %}
"""
    nested_context = {
        'users': [
            {'name': 'Alice', 'age': 30},
            {'name': 'Bob', 'age': 25}
        ]
    }
    
    try:
        result = engine.render(nested_template, nested_context)
        print("❌ FAIL: Should have raised MissingVariableError")
        return False
    except (MissingVariableError, LoopRenderError) as e:
        print(f"✅ PASS: Correctly caught missing nested variable: {e}")
    
    return True

def test_missing_variables_lenient_mode():
    """Test that missing variables are preserved as placeholders in lenient mode."""
    print("\n=== Testing Missing Variables (Lenient Mode) ===")
    
    engine = TemplateEngine(strict_mode=False)
    
    # Test missing simple variable
    template = "Hello $name, welcome to $site!"
    context = {'name': 'Alice'}  # Missing 'site'
    
    result = engine.render(template, context)
    expected = "Hello Alice, welcome to ${site}!"
    
    if result == expected:
        print("✅ PASS: Missing variable preserved as placeholder")
    else:
        print(f"❌ FAIL: Expected '{expected}', got '{result}'")
        return False
    
    missing_vars = engine.get_missing_variables()
    if 'site' in missing_vars:
        print("✅ PASS: Missing variables tracked correctly")
    else:
        print(f"❌ FAIL: Missing variables not tracked: {missing_vars}")
        return False
    
    return True

def test_invalid_variable_names():
    """Test that invalid/dangerous variable names are rejected."""
    print("\n=== Testing Invalid Variable Names ===")
    
    # Use lenient mode to see filtering behavior
    engine = TemplateEngine(strict_mode=False)
    
    # Test dangerous context variables
    dangerous_context = {
        '__import__': 'dangerous',
        'eval': 'also dangerous',
        '__class__': 'very dangerous',
        'safe_var': 'this is ok'
    }
    
    template = "$safe_var $__import__ $eval $__class__"
    
    result = engine.render(template, dangerous_context)
    
    # Should only render safe_var, others should be missing/ignored
    if 'this is ok' in result and 'dangerous' not in result:
        print("✅ PASS: Dangerous variables filtered out")
    else:
        print(f"❌ FAIL: Dangerous variables not filtered: {result}")
        return False
    
    return True

def test_template_syntax_validation():
    """Test template syntax validation."""
    print("\n=== Testing Template Syntax Validation ===")
    
    engine = TemplateEngine(strict_mode=True)
    
    # Test unmatched loop tags
    bad_template = """
{% for item in items %}
    $item.name
<!-- Missing endfor -->
"""
    
    try:
        result = engine.render(bad_template, {'items': []})
        print("❌ FAIL: Should have caught unmatched loop tags")
        return False
    except TemplateRenderError as e:
        print(f"✅ PASS: Correctly caught syntax error: {e}")
    
    return True

def test_xss_protection():
    """Test XSS protection through HTML escaping."""
    print("\n=== Testing XSS Protection ===")
    
    engine = TemplateEngine(auto_escape=True)
    
    malicious_context = {
        'user_input': '<script>alert("XSS")</script>',
        'title': 'Safe & Sound',
        'description': '<b>Bold</b> text'
    }
    
    template = """
<h1>$title</h1>
<p>User said: $user_input</p>
<div>$description</div>
"""
    
    result = engine.render(template, malicious_context)
    
    # Check that dangerous content is escaped
    if '&lt;script&gt;' in result and '&amp;' in result:
        print("✅ PASS: XSS content properly escaped")
    else:
        print(f"❌ FAIL: XSS content not escaped properly: {result}")
        return False
    
    return True

def test_loop_error_handling():
    """Test comprehensive loop error handling."""
    print("\n=== Testing Loop Error Handling ===")
    
    engine = TemplateEngine(strict_mode=True)
    
    # Test loop with non-list variable
    template1 = """
{% for item in not_a_list %}
    $item.name
{% endfor %}
"""
    context1 = {'not_a_list': 'just a string'}
    
    try:
        result = engine.render(template1, context1)
        print("❌ FAIL: Should have caught non-list error")
        return False
    except LoopRenderError as e:
        print(f"✅ PASS: Correctly caught non-list error: {e}")
    
    # Test loop with invalid variable names
    template2 = """
{% for __dangerous__ in items %}
    $__dangerous__.name
{% endfor %}
"""
    context2 = {'items': [{'name': 'test'}]}
    
    try:
        result = engine.render(template2, context2)
        print("❌ FAIL: Should have caught invalid loop variable")
        return False
    except (LoopRenderError, InvalidVariableError) as e:
        print(f"✅ PASS: Correctly caught invalid loop variable: {e}")
    
    return True

def test_performance_and_memory():
    """Test performance with large datasets."""
    print("\n=== Testing Performance & Memory ===")
    
    engine = TemplateEngine(strict_mode=False)
    
    # Create large dataset
    large_context = {
        'title': 'Performance Test',
        'items': [
            {
                'id': i, 
                'name': f'Item {i}', 
                'description': f'Description for item {i}',
                'value': i * 1.5
            } 
            for i in range(5000)
        ]
    }
    
    template = """
<h1>$title</h1>
<div>Total Items: ${len(items)}</div>
<ul>
{% for item in items %}
    <li>ID: $item.id | Name: $item.name | Value: $item.value</li>
{% endfor %}
</ul>
"""
    
    import time
    start_time = time.time()
    
    try:
        result = engine.render(template, large_context)
        end_time = time.time()
        
        render_time = end_time - start_time
        result_lines = result.count('\n')
        
        print(f"✅ PASS: Rendered {result_lines} lines in {render_time:.3f} seconds")
        
        # Check performance threshold (should be reasonable)
        if render_time < 5.0:  # 5 seconds threshold
            print("✅ PASS: Performance within acceptable limits")
        else:
            print(f"⚠️  WARNING: Performance slow: {render_time:.3f}s")
        
        return True
        
    except Exception as e:
        print(f"❌ FAIL: Performance test failed: {e}")
        return False

def test_production_edge_cases():
    """Test various edge cases that might occur in production."""
    print("\n=== Testing Production Edge Cases ===")
    
    engine = TemplateEngine(strict_mode=False)
    
    # Test empty templates
    result = engine.render("", {})
    if result == "":
        print("✅ PASS: Empty template handled")
    else:
        print(f"❌ FAIL: Empty template not handled: '{result}'")
        return False
    
    # Test empty context
    result = engine.render("Hello World!", {})
    if result == "Hello World!":
        print("✅ PASS: Empty context handled")
    else:
        print(f"❌ FAIL: Empty context not handled: '{result}'")
        return False
    
    # Test None values
    context = {'name': None, 'age': 0, 'active': False}
    template = "$name|$age|$active"
    result = engine.render(template, context)
    if "|0|False" in result:  # None becomes empty string
        print("✅ PASS: None values handled correctly")
    else:
        print(f"❌ FAIL: None values not handled: '{result}'")
        return False
    
    # Test Unicode content
    unicode_context = {'message': 'Hello 世界! 🌍'}
    unicode_template = "Message: $message"
    result = engine.render(unicode_template, unicode_context)
    if '世界' in result and '🌍' in result:
        print("✅ PASS: Unicode content handled")
    else:
        print(f"❌ FAIL: Unicode content not handled: '{result}'")
        return False
    
    return True

def run_all_tests():
    """Run all production tests."""
    print("🚀 Starting Production-Grade Template Engine Tests")
    print("=" * 60)
    
    tests = [
        test_missing_variables_strict_mode,
        test_missing_variables_lenient_mode,
        test_invalid_variable_names,
        test_template_syntax_validation,
        test_xss_protection,
        test_loop_error_handling,
        test_performance_and_memory,
        test_production_edge_cases
    ]
    
    passed = 0
    failed = 0
    
    for test_func in tests:
        try:
            if test_func():
                passed += 1
            else:
                failed += 1
        except Exception as e:
            print(f"❌ FAIL: {test_func.__name__} threw unexpected error: {e}")
            failed += 1
    
    print("\n" + "=" * 60)
    print(f"📊 Test Results: {passed} passed, {failed} failed")
    
    if failed == 0:
        print("🎉 ALL TESTS PASSED! Template engine is production-ready.")
        return True
    else:
        print("⚠️  Some tests failed. Please review the issues above.")
        return False

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