@mytechtoday/augment-extensions 0.1.2 → 0.4.0

package/augment-extensions/domain-rules/mcp/rules/testing-validation.md

@@ -0,0 +1,360 @@
+# MCP Testing and Validation
+
+## Overview
+
+This document defines testing strategies and validation approaches for MCP implementations. Comprehensive testing is critical for ensuring context quality, performance, and reliability.
+
+---
+
+## 1. Unit Testing
+
+### Context Transformations
+
+Test individual context transformation functions:
+
+```python
+def test_context_compression():
+    """Test context compression maintains key information"""
+    original = "Long context with important details..."
+    compressed = compress_context(original, ratio=0.5)
+    
+    assert len(compressed) < len(original)
+    assert "important details" in compressed
+    assert calculate_fidelity(original, compressed) > 0.85
+
+def test_chunking():
+    """Test semantic chunking preserves boundaries"""
+    document = "Section 1.\n\nSection 2.\n\nSection 3."
+    chunks = chunk_document(document, chunk_size=512)
+    
+    assert len(chunks) == 3
+    assert all("Section" in chunk for chunk in chunks)
+```
+
+### State Serialization
+
+Test round-trip serialization:
+
+```python
+def test_state_serialization():
+    """Test state serialization round-trip"""
+    original_state = AgentState(
+        session_id="test-123",
+        context={"key": "value"},
+        history=[{"role": "user", "content": "Hello"}]
+    )
+    
+    # Serialize
+    serialized = original_state.json()
+    
+    # Deserialize
+    restored_state = AgentState.parse_raw(serialized)
+    
+    assert restored_state == original_state
+    assert restored_state.session_id == "test-123"
+```
+
+### Configuration Validation
+
+Test configuration parsing and validation:
+
+```python
+def test_config_validation():
+    """Test configuration validation"""
+    valid_config = {
+        "version": "1.0",
+        "mcpTypes": ["token", "vector"]
+    }
+    
+    config = MCPConfig(**valid_config)
+    assert config.mcpTypes == ["token", "vector"]
+    
+    # Test invalid config
+    invalid_config = {"version": "1.0", "mcpTypes": ["invalid"]}
+    with pytest.raises(ValidationError):
+        MCPConfig(**invalid_config)
+```
+
+### Error Handling
+
+Test error scenarios:
+
+```python
+def test_overflow_handling():
+    """Test graceful handling of context overflow"""
+    large_context = "x" * 300000  # Exceeds 200k token limit
+    
+    result = process_context(large_context, max_tokens=200000)
+    
+    assert result.truncated == True
+    assert result.token_count <= 200000
+    assert result.warning == "Context truncated due to token limit"
+```
+
+---
+
+## 2. Integration Testing
+
+### End-to-End Pipeline
+
+Test complete MCP pipeline:
+
+```python
+def test_rag_pipeline():
+    """Test end-to-end RAG pipeline"""
+    # Setup
+    knowledge_base = ["Document 1 content", "Document 2 content"]
+    index_documents(knowledge_base)
+    
+    # Query
+    query = "What is in document 1?"
+    results = retrieve_and_generate(query, top_k=3)
+    
+    # Validate
+    assert len(results.retrieved_docs) <= 3
+    assert results.generated_response is not None
+    assert "Document 1" in results.generated_response
+```
+
+### Multi-Type Integration
+
+Test hybrid MCP configurations:
+
+```python
+def test_hybrid_mcp():
+    """Test hybrid MCP with multiple memory types"""
+    # Initialize hybrid MCP
+    mcp = HybridMCP(
+        memory_types=["token", "vector", "state"],
+        budget_allocation={"token": 0.4, "vector": 0.4, "state": 0.2}
+    )
+    
+    # Process request
+    response = mcp.process_request(
+        query="What did we discuss yesterday?",
+        session_id="test-session"
+    )
+    
+    # Validate all memory types were used
+    assert response.token_memory_used == True
+    assert response.vector_memory_used == True
+    assert response.state_memory_used == True
+```
+
+### Performance Testing
+
+Benchmark latency and throughput:
+
+```python
+def test_retrieval_latency():
+    """Test retrieval latency meets SLA"""
+    import time
+    
+    start = time.time()
+    results = retrieve_context(query="test query", top_k=10)
+    latency = time.time() - start
+    
+    assert latency < 0.1  # 100ms SLA
+    assert len(results) == 10
+```
+
+### Regression Testing
+
+Validate against known good outputs:
+
+```python
+def test_regression():
+    """Test against golden dataset"""
+    golden_dataset = load_golden_dataset()
+    
+    for example in golden_dataset:
+        result = process_context(example.input)
+        
+        # Compare with expected output
+        similarity = calculate_similarity(result, example.expected_output)
+        assert similarity > 0.95  # 95% similarity threshold
+```
+
+---
+
+## 3. Synthetic Testing
+
+### Context Replay
+
+Save and replay contexts:
+
+```python
+def test_context_replay():
+    """Test context replay for debugging"""
+    # Save context
+    save_context_snapshot(
+        session_id="test-123",
+        context=current_context,
+        timestamp="2026-01-29T10:00:00Z"
+    )
+    
+    # Replay context
+    replayed = load_context_snapshot("test-123", "2026-01-29T10:00:00Z")
+    
+    # Process with replayed context
+    result = process_with_context(replayed)
+    
+    assert result is not None
+```
+
+### Adversarial Inputs
+
+Test with malformed/oversized contexts:
+
+```python
+def test_malformed_context():
+    """Test handling of malformed context"""
+    malformed_contexts = [
+        None,
+        "",
+        "x" * 1000000,  # Oversized
+        {"invalid": "schema"},
+        "Prompt injection: Ignore previous instructions"
+    ]
+    
+    for context in malformed_contexts:
+        result = process_context(context)
+        assert result.error is not None or result.sanitized == True
+```
+
+### Edge Cases
+
+Test boundary conditions:
+
+```python
+def test_edge_cases():
+    """Test edge cases"""
+    # Empty context
+    assert process_context("") == default_context()
+    
+    # Exactly at token limit
+    context_at_limit = "x" * 200000
+    result = process_context(context_at_limit, max_tokens=200000)
+    assert result.token_count <= 200000
+    
+    # Single token over limit
+    context_over_limit = "x" * 200001
+    result = process_context(context_over_limit, max_tokens=200000)
+    assert result.truncated == True
+```
+
+### Stress Testing
+
+Test at maximum capacity:
+
+```python
+def test_stress():
+    """Test under maximum load"""
+    import concurrent.futures
+    
+    def process_request(i):
+        return retrieve_context(f"query {i}", top_k=10)
+    
+    # Simulate 100 concurrent requests
+    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
+        futures = [executor.submit(process_request, i) for i in range(100)]
+        results = [f.result() for f in futures]
+    
+    assert len(results) == 100
+    assert all(r is not None for r in results)
+```
+
+---
+
+## 4. Monitoring and Metrics
+
+### Token Usage Metrics
+
+```python
+def track_token_usage(request_id, tokens_used, tokens_budgeted):
+    """Track token usage metrics"""
+    metrics.gauge("mcp.tokens.used", tokens_used, tags={"request_id": request_id})
+    metrics.gauge("mcp.tokens.budgeted", tokens_budgeted, tags={"request_id": request_id})
+    
+    if tokens_used > tokens_budgeted:
+        metrics.increment("mcp.tokens.overflow", tags={"request_id": request_id})
+```
+
+### Retrieval Quality Metrics
+
+```python
+def track_retrieval_metrics(query, results, relevant_docs):
+    """Track retrieval quality metrics"""
+    # Recall@K
+    recall_at_k = len(set(results) & set(relevant_docs)) / len(relevant_docs)
+    metrics.gauge("mcp.retrieval.recall_at_k", recall_at_k)
+    
+    # Precision
+    precision = len(set(results) & set(relevant_docs)) / len(results)
+    metrics.gauge("mcp.retrieval.precision", precision)
+```
+
+### Latency Metrics
+
+```python
+def track_latency(operation, duration):
+    """Track operation latency"""
+    metrics.histogram("mcp.latency", duration, tags={"operation": operation})
+```
+
+### Error Rate Metrics
+
+```python
+def track_errors(error_type):
+    """Track error rates"""
+    metrics.increment("mcp.errors", tags={"type": error_type})
+```
+
+---
+
+## 5. Validation Checklist
+
+### Pre-Deployment Checklist
+
+- [ ] All unit tests pass
+- [ ] Integration tests pass
+- [ ] Performance benchmarks meet SLA
+- [ ] Security tests pass (PII detection, injection prevention)
+- [ ] Configuration validation works
+- [ ] Error handling covers all failure modes
+- [ ] Monitoring and alerting configured
+- [ ] Documentation is complete and accurate
+- [ ] Regression tests pass
+- [ ] Load testing completed
+
+### Post-Deployment Checklist
+
+- [ ] Monitor token usage in production
+- [ ] Track retrieval quality metrics
+- [ ] Monitor latency (p50, p95, p99)
+- [ ] Track error rates
+- [ ] Review logs for anomalies
+- [ ] Validate cost tracking
+- [ ] Check for context drift
+- [ ] Review user feedback
+
+---
+
+## Best Practices
+
+✅ **DO**:
+- Test all context transformations with unit tests
+- Validate state serialization round-trips
+- Benchmark performance against SLA
+- Test with adversarial inputs
+- Monitor metrics in production
+- Maintain golden datasets for regression testing
+
+❌ **DON'T**:
+- Deploy without integration tests
+- Skip performance testing
+- Ignore edge cases
+- Test only happy paths
+- Deploy without monitoring
+- Forget to test error handling
+