Testing Agents

123456789101112
# agent_testing/framework.py
import pytest
import boto3
from dataclasses import dataclass
from typing import Callable, List, Optional
from enum import Enum
import json
import hashlib

class TestMode(Enum):
    UNIT = "unit"           # Mocked LLM, fast
    INTEGRATION = "integration"  # Recorded responses

123456789101112
# tests/test_tools/test_database_tool.py
import pytest
from hypothesis import given, strategies as st
from unittest.mock import Mock, patch
from agent.tools.database import DatabaseQueryTool
from agent.tools.schemas import QueryInput, QueryOutput
import asyncio

class TestDatabaseQueryTool:
    @pytest.fixture
    def tool(self):
        return DatabaseQueryTool(

123456789101112
# tests/snapshot_testing.py
import json
import hashlib
import boto3
from datetime import datetime
from typing import Optional
from deepdiff import DeepDiff

class AgentSnapshotTester:
    def __init__(self, agent_name: str, version: str):
        self.agent_name = agent_name
        self.version = version

123456789101112
import boto3
import numpy as np
from typing import List, Tuple
import json

class SemanticAssertions:
    def __init__(self, similarity_threshold: float = 0.85):
        self.bedrock = boto3.client('bedrock-runtime', region_name='us-east-1')
        self.threshold = similarity_threshold
        self._embedding_cache = {}
    
    def _get_embedding(self, text: str) -> List[float]:

123456789101112
import boto3
import random
from dataclasses import dataclass
from typing import List, Dict, Generator
import uuid
from datetime import datetime, timedelta

@dataclass
class SimulatedUser:
    id: str
    name: str
    role: str  # 'engineer', 'pm', 'customer'

123456789101112
import pytest
import asyncio
from unittest.mock import AsyncMock, patch
from dataclasses import dataclass
from typing import List, Dict, Any
import json
import hashlib

# Agent under test
@dataclass
class AgentResponse:
    message: str

123456789101112
import random
import asyncio
from functools import wraps
from typing import Callable, Any
import os

class ChaosConfig:
    """Configuration for chaos injection."""
    def __init__(self):
        self.enabled = os.getenv("CHAOS_ENABLED", "false").lower() == "true"
        self.timeout_rate = float(os.getenv("CHAOS_TIMEOUT_RATE", "0.10"))
        self.error_rate = float(os.getenv("CHAOS_ERROR_RATE", "0.05"))

123456789101112
import json
import hashlib
from dataclasses import dataclass
from typing import List, Dict, Optional
from sentence_transformers import SentenceTransformer
import numpy as np
import boto3
from datetime import datetime, timedelta

@dataclass
class ConversationTurn:
    role: str  # 'user' or 'agent'