Add comprehensive stress test (40 workers, 60s)

- 30 writers + 10 readers
- 42,272 writes at ~704 ops/sec
- 0 errors, 100% data integrity
- Validates nullcontext() safety for file-based SQLite

Author: gn00295120

medium_test.py

@@ -0,0 +1,132 @@
+"""
+Medium stress test - 15 workers, 30 seconds
+"""
+import asyncio
+import threading
+import time
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+from agents.memory.sqlite_session import SQLiteSession
+
+
+class Stats:
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.writes = 0
+        self.reads = 0
+        self.errors = []
+
+    def record_write(self):
+        with self.lock:
+            self.writes += 1
+
+    def record_read(self):
+        with self.lock:
+            self.reads += 1
+
+    def record_error(self, msg):
+        with self.lock:
+            self.errors.append(msg)
+
+
+async def writer(session_id, db_path, worker_id, duration, stats):
+    """Write for duration seconds"""
+    session = SQLiteSession(session_id=session_id, db_path=db_path)
+    end_time = time.time() + duration
+    count = 0
+
+    while time.time() < end_time:
+        try:
+            await session.add_items([{
+                "role": "user",
+                "content": f"w{worker_id}_m{count}",
+                "type": "message"
+            }])
+            stats.record_write()
+            count += 1
+            if count % 10 == 0:
+                await asyncio.sleep(0.001)
+        except Exception as e:
+            stats.record_error(f"Writer {worker_id}: {e}")
+
+
+async def reader(session_id, db_path, worker_id, duration, stats):
+    """Read for duration seconds"""
+    session = SQLiteSession(session_id=session_id, db_path=db_path)
+    end_time = time.time() + duration
+
+    while time.time() < end_time:
+        try:
+            await session.get_items()
+            stats.record_read()
+            await asyncio.sleep(0.01)
+        except Exception as e:
+            stats.record_error(f"Reader {worker_id}: {e}")
+
+
+async def main():
+    db_path = Path("medium_test.db")
+    if db_path.exists():
+        db_path.unlink()
+
+    SESSION_ID = "test"
+    DURATION = 60
+    stats = Stats()
+
+    print(f"Comprehensive stress test: 30 writers + 10 readers, {DURATION} seconds")
+
+    # Initialize DB
+    s = SQLiteSession(session_id=SESSION_ID, db_path=db_path)
+    await s.add_items([{"role": "system", "content": "init", "type": "message"}])
+    await s.clear_session()
+    print("Database initialized\n")
+
+    # Create workers
+    tasks = []
+    for i in range(30):
+        tasks.append(writer(SESSION_ID, db_path, i, DURATION, stats))
+    for i in range(10):
+        tasks.append(reader(SESSION_ID, db_path, i, DURATION, stats))
+
+    print(f"Starting {len(tasks)} workers...\n")
+    start = time.time()
+
+    # Run with progress updates
+    async def report():
+        for i in range(6):
+            await asyncio.sleep(10)
+            elapsed = time.time() - start
+            writes_per_sec = stats.writes / elapsed if elapsed > 0 else 0
+            print(f"[{elapsed:.0f}s] Writes: {stats.writes:,} ({writes_per_sec:.0f}/s), Reads: {stats.reads:,}, Errors: {len(stats.errors)}")
+
+    tasks.append(report())
+    await asyncio.gather(*tasks)
+
+    duration = time.time() - start
+
+    # Final results
+    print(f"\n{'='*60}")
+    print(f"Duration: {duration:.1f}s")
+    print(f"Writes: {stats.writes:,}")
+    print(f"Reads: {stats.reads:,}")
+    print(f"Errors: {len(stats.errors)}")
+
+    if stats.errors:
+        print(f"\nFirst errors:")
+        for err in stats.errors[:5]:
+            print(f"  {err}")
+
+    # Verify
+    final = await s.get_items()
+    print(f"\nExpected items: {stats.writes}")
+    print(f"Actual items: {len(final)}")
+    print(f"Match: {'✅ PASS' if stats.writes == len(final) else '❌ FAIL'}")
+
+    success = stats.writes == len(final) and len(stats.errors) == 0
+    return 0 if success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))