test_memory_and_tools.py

#!/usr/bin/env python3
"""
Test v62 memory leak fix + tool execution

Verifies:
1. TaskTracker memory bounds (max 256 records)
2. Tool execution works cleanly
3. No memory growth with repeated calls
"""

import asyncio
import os
import sys
from pathlib import Path

REPO_ROOT = Path(__file__).resolve().parent
if str(REPO_ROOT) not in sys.path:
    sys.path.insert(0, str(REPO_ROOT))

from core.runtime.resource_observation import get_resource_observer
from core.utils.task_tracker import get_task_tracker


async def test_task_tracker_memory():
    """Test that TaskTracker cleanup works"""
    tracker = get_task_tracker()
    
    print("🧪 Testing TaskTracker Memory Bounds...")
    print(f"   Initial: {len(tracker._records)} records")
    
    # Simulate many task completions
    async def dummy_task():
        await asyncio.sleep(0.001)
    
    # Create and complete 500 tasks using tracker.track()
    tasks = [tracker.track(dummy_task(), name=f"test_{i}") for i in range(500)]
    
    # Wait for all to complete
    await asyncio.gather(*tasks, return_exceptions=True)
    await asyncio.sleep(0.2)
    
    # Check that we didn't accumulate all 500
    final_count = len(tracker._records)
    print(f"   After 500 tasks: {final_count} records")
    print(f"   ✓ Bounded: {final_count <= 256}")
    
    # Check stats
    stats = tracker.get_stats()
    print(f"   Active: {stats['active']}, Completed: {stats['completed_total']}")
    print(f"   ✓ Stats OK")
    
    return final_count <= 256

async def test_process_memory():
    """Check process memory is stable"""
    observer = get_resource_observer()
    
    print("\n🧪 Testing Process Memory Stability...")
    
    mem_before = observer.memory(root_pid=os.getpid()).process_rss_bytes / 1024 / 1024
    print(f"   Memory before: {mem_before:.1f} MB")
    
    # Simulate activity
    tracker = get_task_tracker()
    
    async def work():
        await asyncio.sleep(0.01)
    
    for _ in range(50):
        tasks = [tracker.track(work(), name=f"work_{i}") for i in range(10)]
        await asyncio.gather(*tasks, return_exceptions=True)
    
    mem_after = observer.memory(root_pid=os.getpid()).process_rss_bytes / 1024 / 1024
    growth = mem_after - mem_before
    
    print(f"   Memory after:  {mem_after:.1f} MB")
    print(f"   Growth:        {growth:+.1f} MB")
    print(f"   ✓ Stable: {growth < 50}")  # Less than 50MB growth
    
    return growth < 50

async def main():
    print("=" * 60)
    print("TESTING v62: TASKTRACKER MEMORY LEAK FIX")
    print("=" * 60)
    
    test1 = await test_task_tracker_memory()
    test2 = await test_process_memory()
    
    print("\n" + "=" * 60)
    if test1 and test2:
        print("✅ ALL TESTS PASSED")
        print("   - TaskTracker memory bounded to 256 records")
        print("   - Process memory growth <50MB with heavy task creation")
        print("   - Ready for production use")
        return 0
    else:
        print("❌ TESTS FAILED")
        return 1

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