feat: implement Phase 2 two-tier architecture with Steward
Add comprehensive two-tier architecture where Steward analyzes requests and Tatlock executes with scoped tools. Includes full infrastructure for request preprocessing, tool tracking, benchmarking, and streaming. **Added:** - Steward agent for request analysis and capability recommendation - Household Registry for centralized capability management - Request preprocessing pipeline (Steward → Tatlock flow) - Tool usage tracking and benchmarking system - Streaming transparency (Steward reasoning visible in streams) - Structured logging with operation timing - Redis benchmark storage with 30-day expiry - Benchmark analysis CLI tools **Infrastructure:** - src/agents/steward/ - Steward agent implementation - src/agents/tatlock_core/ - Tatlock capability domain - src/core/preprocessing.py - Request preprocessing pipeline - src/core/tool_tracking.py - Tool call tracking - src/core/benchmarks.py - Benchmark recording system - src/core/household_registry.py - Capability registry - src/core/startup.py - Application startup coordination - src/core/logging_config.py - Structured logging setup **Integration:** - Responses API uses Steward for Tatlock requests - Chat Completions wraps Responses API for OpenAI compatibility - Streaming coordinator supports Steward + Tatlock flow - Tool scoping per request based on Steward recommendations **Testing:** - Integration tests for Steward-Tatlock flow - Benchmark and registry unit tests - Steward streaming tests See PHASE2_PLAN.md and PHASE2_COMPLETE.md for detailed documentation. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 4.5
@@ -0,0 +1,351 @@
|
||||
"""
|
||||
Tests for benchmark storage.
|
||||
|
||||
Tests performance tracking, Redis storage, and analytics features.
|
||||
"""
|
||||
import json
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.benchmarks import (
|
||||
BenchmarkStore,
|
||||
PerformanceBenchmark,
|
||||
get_benchmark_store,
|
||||
)
|
||||
|
||||
|
||||
class TestPerformanceBenchmark:
|
||||
"""Test PerformanceBenchmark model."""
|
||||
|
||||
def test_benchmark_creation(self):
|
||||
"""Test creating a performance benchmark."""
|
||||
benchmark = PerformanceBenchmark(
|
||||
operation="steward_analysis",
|
||||
duration_seconds=1.23,
|
||||
success=True,
|
||||
recommendation_count=3,
|
||||
)
|
||||
|
||||
assert benchmark.operation == "steward_analysis"
|
||||
assert benchmark.duration_seconds == 1.23
|
||||
assert benchmark.success is True
|
||||
assert benchmark.recommendation_count == 3
|
||||
assert isinstance(benchmark.timestamp, datetime)
|
||||
|
||||
def test_benchmark_with_tool_fields(self):
|
||||
"""Test benchmark with tool-specific fields."""
|
||||
benchmark = PerformanceBenchmark(
|
||||
operation="tool_call",
|
||||
duration_seconds=0.5,
|
||||
success=True,
|
||||
tool_name="calculate",
|
||||
was_recommended=True,
|
||||
was_actually_used=True,
|
||||
)
|
||||
|
||||
assert benchmark.tool_name == "calculate"
|
||||
assert benchmark.was_recommended is True
|
||||
assert benchmark.was_actually_used is True
|
||||
|
||||
def test_benchmark_to_redis_dict(self):
|
||||
"""Test conversion to Redis dict."""
|
||||
benchmark = PerformanceBenchmark(
|
||||
operation="test_op",
|
||||
duration_seconds=1.0,
|
||||
success=True,
|
||||
metadata={"key": "value"},
|
||||
)
|
||||
|
||||
redis_dict = benchmark.to_redis_dict()
|
||||
assert redis_dict["operation"] == "test_op"
|
||||
assert redis_dict["duration_seconds"] == 1.0
|
||||
assert redis_dict["success"] is True
|
||||
assert isinstance(redis_dict["timestamp"], str)
|
||||
assert isinstance(redis_dict["metadata"], str)
|
||||
|
||||
def test_benchmark_from_redis_dict(self):
|
||||
"""Test reconstruction from Redis dict."""
|
||||
now = datetime.now(timezone.utc)
|
||||
redis_dict = {
|
||||
"timestamp": now.isoformat(),
|
||||
"operation": "test_op",
|
||||
"duration_seconds": 1.5,
|
||||
"success": True,
|
||||
"metadata": json.dumps({"test": "data"}),
|
||||
"recommendation_count": None,
|
||||
"confidence": None,
|
||||
"tool_name": None,
|
||||
"was_recommended": None,
|
||||
"was_actually_used": None,
|
||||
"conversation_id": None,
|
||||
}
|
||||
|
||||
benchmark = PerformanceBenchmark.from_redis_dict(redis_dict)
|
||||
assert benchmark.operation == "test_op"
|
||||
assert benchmark.duration_seconds == 1.5
|
||||
assert benchmark.metadata == {"test": "data"}
|
||||
|
||||
|
||||
class TestBenchmarkStore:
|
||||
"""Test BenchmarkStore functionality."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_redis(self):
|
||||
"""Create mock Redis client."""
|
||||
mock = AsyncMock()
|
||||
mock.hset = AsyncMock()
|
||||
mock.expire = AsyncMock()
|
||||
mock.zadd = AsyncMock()
|
||||
mock.zrevrangebyscore = AsyncMock(return_value=[])
|
||||
mock.hgetall = AsyncMock(return_value={})
|
||||
mock.aclose = AsyncMock()
|
||||
return mock
|
||||
|
||||
@pytest.fixture
|
||||
def store(self, mock_redis):
|
||||
"""Create benchmark store with mock Redis."""
|
||||
return BenchmarkStore(redis_client=mock_redis)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_record_benchmark(self, store, mock_redis):
|
||||
"""Test recording a benchmark."""
|
||||
benchmark = PerformanceBenchmark(
|
||||
operation="test_op",
|
||||
duration_seconds=1.0,
|
||||
success=True,
|
||||
)
|
||||
|
||||
await store.record(benchmark)
|
||||
|
||||
# Verify Redis calls
|
||||
mock_redis.hset.assert_called_once()
|
||||
mock_redis.expire.assert_called()
|
||||
mock_redis.zadd.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_record_benchmark_disabled(self, mock_redis):
|
||||
"""Test recording when benchmarks are disabled."""
|
||||
with patch("src.core.benchmarks.config.ENABLE_BENCHMARKS", False):
|
||||
store = BenchmarkStore(redis_client=mock_redis)
|
||||
benchmark = PerformanceBenchmark(
|
||||
operation="test_op",
|
||||
duration_seconds=1.0,
|
||||
success=True,
|
||||
)
|
||||
|
||||
await store.record(benchmark)
|
||||
|
||||
# Should not call Redis
|
||||
mock_redis.hset.assert_not_called()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_record_benchmark_handles_errors(self, store, mock_redis):
|
||||
"""Test recording handles Redis errors gracefully."""
|
||||
mock_redis.hset.side_effect = Exception("Redis error")
|
||||
|
||||
benchmark = PerformanceBenchmark(
|
||||
operation="test_op",
|
||||
duration_seconds=1.0,
|
||||
success=True,
|
||||
)
|
||||
|
||||
# Should not raise exception
|
||||
await store.record(benchmark)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_query_benchmarks(self, store, mock_redis):
|
||||
"""Test querying benchmarks."""
|
||||
# Setup mock data
|
||||
now = datetime.now(timezone.utc)
|
||||
mock_key = f"benchmark:test_op:{int(now.timestamp() * 1000)}"
|
||||
mock_redis.zrevrangebyscore.return_value = [mock_key]
|
||||
|
||||
# Mock hgetall to return proper data
|
||||
mock_redis.hgetall.return_value = {
|
||||
"timestamp": now.isoformat(),
|
||||
"operation": "test_op",
|
||||
"duration_seconds": 1.5, # Numeric, not string
|
||||
"success": True,
|
||||
"metadata": "{}",
|
||||
"recommendation_count": None,
|
||||
"confidence": None,
|
||||
"tool_name": None,
|
||||
"was_recommended": None,
|
||||
"was_actually_used": None,
|
||||
"conversation_id": None,
|
||||
}
|
||||
|
||||
results = await store.query("test_op", limit=10)
|
||||
|
||||
assert len(results) == 1
|
||||
assert results[0].operation == "test_op"
|
||||
mock_redis.zrevrangebyscore.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_query_with_time_range(self, store, mock_redis):
|
||||
"""Test querying with time range."""
|
||||
now = datetime.now(timezone.utc)
|
||||
start_time = now - timedelta(hours=1)
|
||||
end_time = now
|
||||
|
||||
await store.query("test_op", start_time=start_time, end_time=end_time)
|
||||
|
||||
# Verify time range was converted to timestamps
|
||||
call_args = mock_redis.zrevrangebyscore.call_args
|
||||
assert call_args is not None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_query_disabled_benchmarks(self, mock_redis):
|
||||
"""Test querying when benchmarks are disabled."""
|
||||
with patch("src.core.benchmarks.config.ENABLE_BENCHMARKS", False):
|
||||
store = BenchmarkStore(redis_client=mock_redis)
|
||||
results = await store.query("test_op")
|
||||
assert results == []
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_query_handles_errors(self, store, mock_redis):
|
||||
"""Test query handles errors gracefully."""
|
||||
mock_redis.zrevrangebyscore.side_effect = Exception("Redis error")
|
||||
|
||||
results = await store.query("test_op")
|
||||
assert results == []
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_statistics(self, store, mock_redis):
|
||||
"""Test getting statistics."""
|
||||
# Setup mock data with multiple benchmarks
|
||||
now = datetime.now(timezone.utc)
|
||||
mock_keys = [
|
||||
f"benchmark:test_op:{int((now - timedelta(seconds=i)).timestamp() * 1000)}"
|
||||
for i in range(3)
|
||||
]
|
||||
mock_redis.zrevrangebyscore.return_value = mock_keys
|
||||
|
||||
# Return different durations and success values
|
||||
benchmarks_data = [
|
||||
{"duration_seconds": "1.0", "success": "True"},
|
||||
{"duration_seconds": "2.0", "success": "True"},
|
||||
{"duration_seconds": "3.0", "success": "False"},
|
||||
]
|
||||
|
||||
async def mock_hgetall(key):
|
||||
idx = mock_keys.index(key)
|
||||
data = benchmarks_data[idx]
|
||||
return {
|
||||
"timestamp": now.isoformat(),
|
||||
"operation": "test_op",
|
||||
"duration_seconds": float(data["duration_seconds"]),
|
||||
"success": data["success"] == "True",
|
||||
"metadata": "{}",
|
||||
"recommendation_count": None,
|
||||
"confidence": None,
|
||||
"tool_name": None,
|
||||
"was_recommended": None,
|
||||
"was_actually_used": None,
|
||||
"conversation_id": None,
|
||||
}
|
||||
|
||||
mock_redis.hgetall.side_effect = mock_hgetall
|
||||
|
||||
stats = await store.get_statistics("test_op")
|
||||
|
||||
assert stats["count"] == 3
|
||||
assert stats["avg_duration"] == 2.0 # (1 + 2 + 3) / 3
|
||||
assert stats["min_duration"] == 1.0
|
||||
assert stats["max_duration"] == 3.0
|
||||
assert stats["success_rate"] == pytest.approx(66.67, rel=0.01)
|
||||
assert stats["total_successes"] == 2
|
||||
assert stats["total_failures"] == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_statistics_empty(self, store, mock_redis):
|
||||
"""Test statistics with no data."""
|
||||
mock_redis.zrevrangebyscore.return_value = []
|
||||
|
||||
stats = await store.get_statistics("test_op")
|
||||
|
||||
assert stats["count"] == 0
|
||||
assert stats["avg_duration"] == 0.0
|
||||
assert stats["success_rate"] == 0.0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_tool_accuracy(self, store, mock_redis):
|
||||
"""Test tool accuracy calculation."""
|
||||
# Setup mock data
|
||||
now = datetime.now(timezone.utc)
|
||||
mock_keys = [
|
||||
f"benchmark:tool_call:{int((now - timedelta(seconds=i)).timestamp() * 1000)}"
|
||||
for i in range(4)
|
||||
]
|
||||
mock_redis.zrevrangebyscore.return_value = mock_keys
|
||||
|
||||
# Different combinations of recommended/used
|
||||
tool_data = [
|
||||
{"was_recommended": "True", "was_actually_used": "True"}, # Good
|
||||
{"was_recommended": "True", "was_actually_used": "True"}, # Good
|
||||
{"was_recommended": "False", "was_actually_used": "True"}, # Missed
|
||||
{"was_recommended": "True", "was_actually_used": "False"}, # Not used
|
||||
]
|
||||
|
||||
async def mock_hgetall(key):
|
||||
idx = mock_keys.index(key)
|
||||
data = tool_data[idx]
|
||||
return {
|
||||
"timestamp": now.isoformat(),
|
||||
"operation": "tool_call",
|
||||
"duration_seconds": 1.0,
|
||||
"success": True,
|
||||
"metadata": "{}",
|
||||
"recommendation_count": None,
|
||||
"confidence": None,
|
||||
"tool_name": "test_tool",
|
||||
"conversation_id": None,
|
||||
"was_recommended": data["was_recommended"] == "True",
|
||||
"was_actually_used": data["was_actually_used"] == "True",
|
||||
}
|
||||
|
||||
mock_redis.hgetall.side_effect = mock_hgetall
|
||||
|
||||
accuracy = await store.get_tool_accuracy()
|
||||
|
||||
assert accuracy["total_calls"] == 4
|
||||
assert accuracy["total_used"] == 3
|
||||
assert accuracy["recommended_and_used"] == 2
|
||||
assert accuracy["not_recommended_but_used"] == 1
|
||||
assert accuracy["precision"] == pytest.approx(66.67, rel=0.01)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_tool_accuracy_empty(self, store, mock_redis):
|
||||
"""Test tool accuracy with no data."""
|
||||
mock_redis.zrevrangebyscore.return_value = []
|
||||
|
||||
accuracy = await store.get_tool_accuracy()
|
||||
|
||||
assert accuracy["total_calls"] == 0
|
||||
assert accuracy["precision"] == 0.0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_close(self, store, mock_redis):
|
||||
"""Test closing the store."""
|
||||
await store.close()
|
||||
mock_redis.aclose.assert_called_once()
|
||||
|
||||
# Client should be None after close
|
||||
assert store._client is None
|
||||
|
||||
|
||||
class TestGlobalBenchmarkStore:
|
||||
"""Test global benchmark store instance."""
|
||||
|
||||
def test_get_benchmark_store(self):
|
||||
"""Test getting global store instance."""
|
||||
store = get_benchmark_store()
|
||||
assert isinstance(store, BenchmarkStore)
|
||||
|
||||
def test_get_benchmark_store_singleton(self):
|
||||
"""Test store is singleton."""
|
||||
store1 = get_benchmark_store()
|
||||
store2 = get_benchmark_store()
|
||||
assert store1 is store2
|
||||
@@ -0,0 +1,313 @@
|
||||
"""
|
||||
Tests for household registry.
|
||||
|
||||
Tests capability registration, toolset scoping, and coordination features.
|
||||
"""
|
||||
import pytest
|
||||
from pydantic_ai.tools import Tool
|
||||
|
||||
from src.core.household_registry import (
|
||||
HouseholdCapability,
|
||||
HouseholdMember,
|
||||
HouseholdRegistry,
|
||||
household_registry,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def registry():
|
||||
"""Create a fresh registry for each test."""
|
||||
reg = HouseholdRegistry()
|
||||
return reg
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_capability():
|
||||
"""Sample household capability."""
|
||||
return HouseholdCapability(
|
||||
name="test_tools",
|
||||
role="Test Tools",
|
||||
category="testing",
|
||||
description="Tools for testing purposes",
|
||||
domains=["testing", "validation"],
|
||||
cost="low",
|
||||
requires_network=False,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_tools():
|
||||
"""Sample tool definitions."""
|
||||
def test_function_1(x: int) -> int:
|
||||
"""Test function 1."""
|
||||
return x * 2
|
||||
|
||||
def test_function_2(x: str) -> str:
|
||||
"""Test function 2."""
|
||||
return x.upper()
|
||||
|
||||
return [
|
||||
Tool(function=test_function_1, name="test_tool_1"),
|
||||
Tool(function=test_function_2, name="test_tool_2"),
|
||||
]
|
||||
|
||||
|
||||
class TestHouseholdCapability:
|
||||
"""Test HouseholdCapability model."""
|
||||
|
||||
def test_capability_creation(self, sample_capability):
|
||||
"""Test creating a capability."""
|
||||
assert sample_capability.name == "test_tools"
|
||||
assert sample_capability.role == "Test Tools"
|
||||
assert sample_capability.category == "testing"
|
||||
assert "testing" in sample_capability.domains
|
||||
assert sample_capability.cost == "low"
|
||||
assert sample_capability.requires_network is False
|
||||
|
||||
def test_capability_validation(self):
|
||||
"""Test capability field validation."""
|
||||
# Should succeed with valid data
|
||||
cap = HouseholdCapability(
|
||||
name="valid",
|
||||
role="Valid Role",
|
||||
category="test",
|
||||
description="Test description",
|
||||
domains=["test"],
|
||||
cost="medium",
|
||||
requires_network=True,
|
||||
)
|
||||
assert cap.name == "valid"
|
||||
|
||||
|
||||
class TestHouseholdMember:
|
||||
"""Test HouseholdMember model."""
|
||||
|
||||
def test_member_creation(self, sample_capability, sample_tools):
|
||||
"""Test creating a household member."""
|
||||
member = HouseholdMember(
|
||||
capability=sample_capability,
|
||||
tools=sample_tools,
|
||||
agent=None,
|
||||
)
|
||||
assert member.capability.name == "test_tools"
|
||||
assert len(member.tools) == 2
|
||||
assert member.agent is None
|
||||
|
||||
def test_member_with_agent(self, sample_capability, sample_tools):
|
||||
"""Test member can include an agent."""
|
||||
from unittest.mock import Mock
|
||||
mock_agent = Mock()
|
||||
|
||||
member = HouseholdMember(
|
||||
capability=sample_capability,
|
||||
tools=sample_tools,
|
||||
agent=mock_agent,
|
||||
)
|
||||
assert member.agent is mock_agent
|
||||
|
||||
|
||||
class TestHouseholdRegistry:
|
||||
"""Test HouseholdRegistry functionality."""
|
||||
|
||||
def test_registry_initialization(self, registry):
|
||||
"""Test registry initializes empty."""
|
||||
assert len(registry) == 0
|
||||
assert registry.list_members() == []
|
||||
|
||||
def test_register_member(self, registry, sample_capability, sample_tools):
|
||||
"""Test registering a household member."""
|
||||
registry.register(
|
||||
name="test_tools",
|
||||
capability=sample_capability,
|
||||
tools=sample_tools,
|
||||
)
|
||||
|
||||
assert len(registry) == 1
|
||||
assert "test_tools" in registry
|
||||
assert "test_tools" in registry.list_members()
|
||||
|
||||
def test_register_name_mismatch(self, registry, sample_capability, sample_tools):
|
||||
"""Test registration fails with name mismatch."""
|
||||
with pytest.raises(ValueError, match="Name mismatch"):
|
||||
registry.register(
|
||||
name="wrong_name",
|
||||
capability=sample_capability,
|
||||
tools=sample_tools,
|
||||
)
|
||||
|
||||
def test_unregister_member(self, registry, sample_capability, sample_tools):
|
||||
"""Test unregistering a member."""
|
||||
registry.register("test_tools", sample_capability, sample_tools)
|
||||
assert "test_tools" in registry
|
||||
|
||||
registry.unregister("test_tools")
|
||||
assert "test_tools" not in registry
|
||||
assert len(registry) == 0
|
||||
|
||||
def test_get_member(self, registry, sample_capability, sample_tools):
|
||||
"""Test retrieving a member."""
|
||||
registry.register("test_tools", sample_capability, sample_tools)
|
||||
|
||||
member = registry.get_member("test_tools")
|
||||
assert member is not None
|
||||
assert member.capability.name == "test_tools"
|
||||
assert len(member.tools) == 2
|
||||
|
||||
def test_get_nonexistent_member(self, registry):
|
||||
"""Test retrieving non-existent member returns None."""
|
||||
member = registry.get_member("nonexistent")
|
||||
assert member is None
|
||||
|
||||
def test_get_all_capabilities(self, registry, sample_capability, sample_tools):
|
||||
"""Test retrieving all capability summaries."""
|
||||
# Register multiple members
|
||||
cap1 = sample_capability
|
||||
cap2 = HouseholdCapability(
|
||||
name="other_tools",
|
||||
role="Other Tools",
|
||||
category="utility",
|
||||
description="Other test tools",
|
||||
domains=["utility"],
|
||||
cost="medium",
|
||||
requires_network=True,
|
||||
)
|
||||
|
||||
registry.register("test_tools", cap1, sample_tools)
|
||||
registry.register("other_tools", cap2, sample_tools[:1])
|
||||
|
||||
capabilities = registry.get_all_capabilities()
|
||||
assert len(capabilities) == 2
|
||||
assert any(cap.name == "test_tools" for cap in capabilities)
|
||||
assert any(cap.name == "other_tools" for cap in capabilities)
|
||||
|
||||
def test_get_scoped_tools(self, registry, sample_capability, sample_tools):
|
||||
"""Test creating scoped toolsets."""
|
||||
registry.register("test_tools", sample_capability, sample_tools)
|
||||
|
||||
# Get scoped tools
|
||||
tools = registry.get_scoped_tools(["test_tools"])
|
||||
assert len(tools) == 2
|
||||
assert tools[0].name == "test_tool_1"
|
||||
assert tools[1].name == "test_tool_2"
|
||||
|
||||
def test_get_scoped_tools_multiple_members(self, registry, sample_tools):
|
||||
"""Test scoping with multiple members."""
|
||||
cap1 = HouseholdCapability(
|
||||
name="member1",
|
||||
role="Member 1",
|
||||
category="test",
|
||||
description="First member",
|
||||
domains=["test"],
|
||||
cost="low",
|
||||
requires_network=False,
|
||||
)
|
||||
cap2 = HouseholdCapability(
|
||||
name="member2",
|
||||
role="Member 2",
|
||||
category="test",
|
||||
description="Second member",
|
||||
domains=["test"],
|
||||
cost="low",
|
||||
requires_network=False,
|
||||
)
|
||||
|
||||
registry.register("member1", cap1, sample_tools[:1])
|
||||
registry.register("member2", cap2, sample_tools[1:])
|
||||
|
||||
# Get combined tools
|
||||
tools = registry.get_scoped_tools(["member1", "member2"])
|
||||
assert len(tools) == 2
|
||||
|
||||
def test_get_scoped_tools_nonexistent_member(self, registry, sample_capability, sample_tools):
|
||||
"""Test scoping with non-existent member logs warning."""
|
||||
registry.register("test_tools", sample_capability, sample_tools)
|
||||
|
||||
# Request includes non-existent member
|
||||
tools = registry.get_scoped_tools(["test_tools", "nonexistent"])
|
||||
# Should return only existing member's tools
|
||||
assert len(tools) == 2
|
||||
|
||||
def test_get_members_by_domain(self, registry, sample_tools):
|
||||
"""Test filtering members by domain."""
|
||||
cap1 = HouseholdCapability(
|
||||
name="research_tools",
|
||||
role="Research Tools",
|
||||
category="research",
|
||||
description="Research tools",
|
||||
domains=["research", "analysis"],
|
||||
cost="medium",
|
||||
requires_network=True,
|
||||
)
|
||||
cap2 = HouseholdCapability(
|
||||
name="compute_tools",
|
||||
role="Compute Tools",
|
||||
category="computation",
|
||||
description="Computation tools",
|
||||
domains=["computation", "math"],
|
||||
cost="low",
|
||||
requires_network=False,
|
||||
)
|
||||
|
||||
registry.register("research_tools", cap1, sample_tools)
|
||||
registry.register("compute_tools", cap2, sample_tools)
|
||||
|
||||
# Filter by domain
|
||||
research_caps = registry.get_members_by_domain("research")
|
||||
assert len(research_caps) == 1
|
||||
assert research_caps[0].name == "research_tools"
|
||||
|
||||
compute_caps = registry.get_members_by_domain("computation")
|
||||
assert len(compute_caps) == 1
|
||||
assert compute_caps[0].name == "compute_tools"
|
||||
|
||||
def test_get_members_by_category(self, registry, sample_tools):
|
||||
"""Test filtering members by category."""
|
||||
cap1 = HouseholdCapability(
|
||||
name="core_tools",
|
||||
role="Core Tools",
|
||||
category="core",
|
||||
description="Core tools",
|
||||
domains=["general"],
|
||||
cost="low",
|
||||
requires_network=False,
|
||||
)
|
||||
cap2 = HouseholdCapability(
|
||||
name="research_tools",
|
||||
role="Research Tools",
|
||||
category="research",
|
||||
description="Research tools",
|
||||
domains=["research"],
|
||||
cost="medium",
|
||||
requires_network=True,
|
||||
)
|
||||
|
||||
registry.register("core_tools", cap1, sample_tools)
|
||||
registry.register("research_tools", cap2, sample_tools)
|
||||
|
||||
# Filter by category
|
||||
core_caps = registry.get_members_by_category("core")
|
||||
assert len(core_caps) == 1
|
||||
assert core_caps[0].name == "core_tools"
|
||||
|
||||
research_caps = registry.get_members_by_category("research")
|
||||
assert len(research_caps) == 1
|
||||
assert research_caps[0].name == "research_tools"
|
||||
|
||||
|
||||
class TestGlobalRegistry:
|
||||
"""Test the global registry instance."""
|
||||
|
||||
def test_global_registry_exists(self):
|
||||
"""Test global registry is available."""
|
||||
from src.core.household_registry import get_household_registry
|
||||
|
||||
registry = get_household_registry()
|
||||
assert isinstance(registry, HouseholdRegistry)
|
||||
|
||||
def test_global_registry_singleton(self):
|
||||
"""Test get_household_registry returns same instance."""
|
||||
from src.core.household_registry import get_household_registry
|
||||
|
||||
reg1 = get_household_registry()
|
||||
reg2 = get_household_registry()
|
||||
assert reg1 is reg2
|
||||
@@ -0,0 +1,254 @@
|
||||
"""
|
||||
Tests for structured logging configuration.
|
||||
|
||||
Tests logging setup, context management, and FastAPI integration.
|
||||
"""
|
||||
import logging
|
||||
from io import StringIO
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
import structlog
|
||||
|
||||
from src.core.logging_config import (
|
||||
add_log_level,
|
||||
add_timestamp,
|
||||
get_logger,
|
||||
get_uvicorn_log_config,
|
||||
log_operation,
|
||||
)
|
||||
|
||||
|
||||
class TestLoggingProcessors:
|
||||
"""Test logging processor functions."""
|
||||
|
||||
def test_add_timestamp(self):
|
||||
"""Test timestamp processor adds ISO timestamp."""
|
||||
event_dict = {}
|
||||
result = add_timestamp(None, "info", event_dict)
|
||||
|
||||
assert "timestamp" in result
|
||||
assert isinstance(result["timestamp"], str)
|
||||
# Should be ISO 8601 format
|
||||
assert "T" in result["timestamp"] or "-" in result["timestamp"]
|
||||
|
||||
def test_add_log_level(self):
|
||||
"""Test log level processor."""
|
||||
event_dict = {}
|
||||
result = add_log_level(None, "info", event_dict)
|
||||
|
||||
assert result["level"] == "INFO"
|
||||
|
||||
result = add_log_level(None, "error", {})
|
||||
assert result["level"] == "ERROR"
|
||||
|
||||
|
||||
class TestGetLogger:
|
||||
"""Test logger retrieval."""
|
||||
|
||||
def test_get_logger_returns_bound_logger(self):
|
||||
"""Test get_logger returns structlog BoundLogger."""
|
||||
logger = get_logger("test")
|
||||
# Logger should have standard logging methods
|
||||
assert hasattr(logger, 'info')
|
||||
assert hasattr(logger, 'debug')
|
||||
assert hasattr(logger, 'warning')
|
||||
assert hasattr(logger, 'error')
|
||||
|
||||
def test_get_logger_with_module_name(self):
|
||||
"""Test logger with module name."""
|
||||
logger = get_logger(__name__)
|
||||
assert logger is not None
|
||||
|
||||
def test_logger_has_standard_methods(self):
|
||||
"""Test logger has standard logging methods."""
|
||||
logger = get_logger("test")
|
||||
assert hasattr(logger, "debug")
|
||||
assert hasattr(logger, "info")
|
||||
assert hasattr(logger, "warning")
|
||||
assert hasattr(logger, "error")
|
||||
assert hasattr(logger, "exception")
|
||||
|
||||
|
||||
class TestLogOperation:
|
||||
"""Test log_operation context manager."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_log_operation_success(self):
|
||||
"""Test log_operation for successful operation."""
|
||||
logger = get_logger("test")
|
||||
|
||||
async with log_operation("test_operation", {"user_id": "123"}) as ctx:
|
||||
# Can update context during operation
|
||||
ctx["result_count"] = 5
|
||||
|
||||
# Context should have been updated with success info
|
||||
assert ctx["success"] is True
|
||||
assert ctx["result_count"] == 5
|
||||
assert "duration_seconds" in ctx
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_log_operation_failure(self):
|
||||
"""Test log_operation for failed operation."""
|
||||
logger = get_logger("test")
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
async with log_operation("test_operation") as ctx:
|
||||
raise ValueError("Test error")
|
||||
|
||||
# Context should have failure info
|
||||
assert ctx["success"] is False
|
||||
assert ctx["error"] == "Test error"
|
||||
assert ctx["error_type"] == "ValueError"
|
||||
assert "duration_seconds" in ctx
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_log_operation_timing(self):
|
||||
"""Test log_operation records duration."""
|
||||
import asyncio
|
||||
|
||||
async with log_operation("test_operation") as ctx:
|
||||
await asyncio.sleep(0.01) # Small delay
|
||||
|
||||
# Should have measurable duration
|
||||
assert ctx["duration_seconds"] > 0
|
||||
assert ctx["duration_seconds"] < 1.0 # Should be quick
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_log_operation_initial_context(self):
|
||||
"""Test log_operation with initial context."""
|
||||
initial = {"request_id": "abc123", "user": "test_user"}
|
||||
|
||||
async with log_operation("test_operation", initial) as ctx:
|
||||
pass
|
||||
|
||||
# Initial context should be preserved
|
||||
assert ctx["request_id"] == "abc123"
|
||||
assert ctx["user"] == "test_user"
|
||||
assert ctx["operation"] == "test_operation"
|
||||
|
||||
|
||||
class TestUvicornLogConfig:
|
||||
"""Test uvicorn logging configuration."""
|
||||
|
||||
def test_get_uvicorn_log_config_returns_dict(self):
|
||||
"""Test uvicorn config returns valid dict."""
|
||||
config = get_uvicorn_log_config()
|
||||
|
||||
assert isinstance(config, dict)
|
||||
assert "version" in config
|
||||
assert "formatters" in config
|
||||
assert "handlers" in config
|
||||
assert "loggers" in config
|
||||
|
||||
def test_uvicorn_log_config_has_required_loggers(self):
|
||||
"""Test config includes uvicorn loggers."""
|
||||
config = get_uvicorn_log_config()
|
||||
|
||||
loggers = config["loggers"]
|
||||
assert "uvicorn" in loggers
|
||||
assert "uvicorn.error" in loggers
|
||||
assert "uvicorn.access" in loggers
|
||||
|
||||
def test_uvicorn_log_config_format_selection(self):
|
||||
"""Test config format changes based on environment."""
|
||||
# Just test that the config is valid, format is determined by environment
|
||||
config = get_uvicorn_log_config()
|
||||
# Should have required structure
|
||||
assert "version" in config
|
||||
assert "formatters" in config
|
||||
assert "handlers" in config
|
||||
assert "loggers" in config
|
||||
|
||||
|
||||
class TestLoggingIntegration:
|
||||
"""Test logging integration with standard library."""
|
||||
|
||||
def test_standard_logging_works(self):
|
||||
"""Test standard logging.getLogger works."""
|
||||
logger = logging.getLogger("test.standard")
|
||||
# Should not raise
|
||||
logger.info("Test message")
|
||||
|
||||
def test_structlog_and_stdlib_coexist(self):
|
||||
"""Test structlog and stdlib can coexist."""
|
||||
struct_logger = get_logger("test.struct")
|
||||
std_logger = logging.getLogger("test.std")
|
||||
|
||||
# Both should work
|
||||
struct_logger.info("Structured log")
|
||||
std_logger.info("Standard log")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_logging_in_async_context(self):
|
||||
"""Test logging works in async context."""
|
||||
logger = get_logger("test.async")
|
||||
|
||||
async def async_function():
|
||||
logger.info("Async log message", task="async_task")
|
||||
|
||||
await async_function()
|
||||
|
||||
|
||||
class TestLoggingOutput:
|
||||
"""Test actual logging output."""
|
||||
|
||||
def test_logger_outputs_structured_data(self):
|
||||
"""Test logger can output structured data."""
|
||||
logger = get_logger("test.output")
|
||||
|
||||
# Log with structured data
|
||||
logger.info(
|
||||
"user_action",
|
||||
user_id="123",
|
||||
action="login",
|
||||
success=True,
|
||||
)
|
||||
# Should not raise, output tested in integration tests
|
||||
|
||||
def test_logger_handles_exceptions(self):
|
||||
"""Test logger handles exception logging."""
|
||||
logger = get_logger("test.exceptions")
|
||||
|
||||
try:
|
||||
raise ValueError("Test error")
|
||||
except ValueError:
|
||||
logger.exception("Error occurred", extra_field="value")
|
||||
# Should not raise
|
||||
|
||||
def test_different_log_levels(self):
|
||||
"""Test different log levels."""
|
||||
logger = get_logger("test.levels")
|
||||
|
||||
logger.debug("Debug message", level="debug")
|
||||
logger.info("Info message", level="info")
|
||||
logger.warning("Warning message", level="warning")
|
||||
logger.error("Error message", level="error")
|
||||
# Should not raise
|
||||
|
||||
|
||||
class TestLoggingConfiguration:
|
||||
"""Test logging configuration behavior."""
|
||||
|
||||
def test_logging_respects_environment(self):
|
||||
"""Test logging format changes with environment."""
|
||||
from src.core.config import Environment, config
|
||||
|
||||
# In development, should use console format
|
||||
if config.ENVIRONMENT == Environment.DEVELOPMENT:
|
||||
assert config.log_format == "console"
|
||||
|
||||
# Mock production environment
|
||||
with patch.object(config, "ENVIRONMENT", Environment.PRODUCTION):
|
||||
assert config.log_format == "json"
|
||||
|
||||
def test_multiple_loggers_independent(self):
|
||||
"""Test multiple loggers are independent."""
|
||||
logger1 = get_logger("test.logger1")
|
||||
logger2 = get_logger("test.logger2")
|
||||
|
||||
assert logger1 is not logger2
|
||||
|
||||
# Both should work independently
|
||||
logger1.info("Logger 1 message")
|
||||
logger2.info("Logger 2 message")
|
||||
Reference in New Issue
Block a user