Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /CIRISAI_CIRISAgent /tests /test_node_data_schemas.py
| """ | |
| Tests for node data schemas. | |
| """ | |
| from datetime import datetime, timezone | |
| import pytest | |
| from pydantic import ValidationError | |
| from ciris_engine.schemas.services.graph.node_data import ( | |
| AuditNodeData, | |
| BaseNodeData, | |
| ConfigNodeData, | |
| MemoryNodeData, | |
| TelemetryNodeData, | |
| ValidationRule, | |
| ) | |
| class TestValidationRule: | |
| """Test ValidationRule schema.""" | |
| def test_valid_validation_rule(self): | |
| """Test creating a valid validation rule.""" | |
| rule = ValidationRule( | |
| rule_type="range", parameters={"min": 0, "max": 100}, error_message="Value must be between 0 and 100" | |
| ) | |
| assert rule.rule_type == "range" | |
| assert rule.parameters["min"] == 0 | |
| assert rule.parameters["max"] == 100 | |
| assert rule.error_message == "Value must be between 0 and 100" | |
| def test_validation_rule_without_error_message(self): | |
| """Test validation rule without error message.""" | |
| rule = ValidationRule(rule_type="regex", parameters={"pattern": r"^\d+$"}) | |
| assert rule.rule_type == "regex" | |
| assert rule.error_message is None | |
| def test_validation_rule_forbids_extra_fields(self): | |
| """Test that extra fields are forbidden.""" | |
| with pytest.raises(ValidationError) as exc_info: | |
| ValidationRule(rule_type="enum", parameters={"values": ["a", "b", "c"]}, extra_field="not allowed") | |
| assert "Extra inputs are not permitted" in str(exc_info.value) | |
| class TestBaseNodeData: | |
| """Test BaseNodeData schema.""" | |
| def test_base_node_data_defaults(self): | |
| """Test BaseNodeData with default values.""" | |
| now = datetime.now(timezone.utc) | |
| data = BaseNodeData(created_at=now, updated_at=now) | |
| assert data.version == 1 | |
| assert data.created_at == now | |
| assert data.updated_at == now | |
| def test_datetime_serialization(self): | |
| """Test datetime fields are serialized to ISO format.""" | |
| now = datetime.now(timezone.utc) | |
| data = BaseNodeData(created_at=now, updated_at=now) | |
| serialized = data.model_dump() | |
| assert isinstance(serialized["created_at"], str) | |
| assert isinstance(serialized["updated_at"], str) | |
| assert serialized["created_at"] == now.isoformat() | |
| def test_base_node_data_forbids_extra(self): | |
| """Test that extra fields are forbidden.""" | |
| now = datetime.now(timezone.utc) | |
| with pytest.raises(ValidationError) as exc_info: | |
| BaseNodeData(created_at=now, updated_at=now, extra="not allowed") | |
| assert "Extra inputs are not permitted" in str(exc_info.value) | |
| class TestConfigNodeData: | |
| """Test ConfigNodeData schema.""" | |
| def test_config_node_with_string_value(self): | |
| """Test config node with string value.""" | |
| now = datetime.now(timezone.utc) | |
| config = ConfigNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| key="api.timeout", | |
| value="30", | |
| description="API timeout in seconds", | |
| category="operational", | |
| ) | |
| assert config.key == "api.timeout" | |
| assert config.value == "30" | |
| assert config.is_sensitive is False | |
| def test_config_node_with_list_value(self): | |
| """Test config node with list value.""" | |
| now = datetime.now(timezone.utc) | |
| config = ConfigNodeData( | |
| created_at=now, updated_at=now, key="allowed_hosts", value=["localhost", "127.0.0.1"], category="security" | |
| ) | |
| assert config.value == ["localhost", "127.0.0.1"] | |
| def test_config_node_with_dict_value(self): | |
| """Test config node with dict value.""" | |
| now = datetime.now(timezone.utc) | |
| config = ConfigNodeData( | |
| created_at=now, updated_at=now, key="features", value={"auth": "enabled", "logging": "debug"} | |
| ) | |
| assert config.value["auth"] == "enabled" | |
| def test_config_node_with_validation_rules(self): | |
| """Test config node with validation rules.""" | |
| now = datetime.now(timezone.utc) | |
| rule = ValidationRule(rule_type="range", parameters={"min": 1, "max": 3600}) | |
| config = ConfigNodeData(created_at=now, updated_at=now, key="timeout", value=30, validation_rules=[rule]) | |
| assert len(config.validation_rules) == 1 | |
| assert config.validation_rules[0].rule_type == "range" | |
| def test_sensitive_config(self): | |
| """Test sensitive configuration marking.""" | |
| now = datetime.now(timezone.utc) | |
| config = ConfigNodeData(created_at=now, updated_at=now, key="api_key", value="secret123", is_sensitive=True) | |
| assert config.is_sensitive is True | |
| class TestTelemetryNodeData: | |
| """Test TelemetryNodeData schema.""" | |
| def test_basic_telemetry_node(self): | |
| """Test basic telemetry node creation.""" | |
| now = datetime.now(timezone.utc) | |
| telemetry = TelemetryNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| metric_name="cpu_usage", | |
| metric_value=75.5, | |
| metric_type="gauge", | |
| unit="percent", | |
| ) | |
| assert telemetry.metric_name == "cpu_usage" | |
| assert telemetry.metric_value == 75.5 | |
| assert telemetry.metric_type == "gauge" | |
| assert telemetry.unit == "percent" | |
| def test_telemetry_with_labels(self): | |
| """Test telemetry with labels.""" | |
| now = datetime.now(timezone.utc) | |
| telemetry = TelemetryNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| metric_name="http_requests", | |
| metric_value=100, | |
| metric_type="counter", | |
| labels={"method": "GET", "status": "200"}, | |
| ) | |
| assert telemetry.labels["method"] == "GET" | |
| assert telemetry.labels["status"] == "200" | |
| def test_telemetry_time_series(self): | |
| """Test telemetry with time series data.""" | |
| now = datetime.now(timezone.utc) | |
| start = datetime(2025, 1, 1, 12, 0, 0, tzinfo=timezone.utc) | |
| end = datetime(2025, 1, 1, 13, 0, 0, tzinfo=timezone.utc) | |
| telemetry = TelemetryNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| metric_name="requests_per_hour", | |
| metric_value=1000, | |
| metric_type="histogram", | |
| start_time=start, | |
| end_time=end, | |
| sample_count=1000, | |
| aggregation_type="sum", | |
| ) | |
| assert telemetry.start_time == start | |
| assert telemetry.end_time == end | |
| assert telemetry.sample_count == 1000 | |
| assert telemetry.aggregation_type == "sum" | |
| def test_telemetry_defaults(self): | |
| """Test telemetry default values.""" | |
| now = datetime.now(timezone.utc) | |
| telemetry = TelemetryNodeData( | |
| created_at=now, updated_at=now, metric_name="test", metric_value=1.0, metric_type="gauge" | |
| ) | |
| assert telemetry.labels == {} | |
| assert telemetry.unit is None | |
| assert telemetry.aggregation_type is None | |
| class TestAuditNodeData: | |
| """Test AuditNodeData schema.""" | |
| def test_basic_audit_node(self): | |
| """Test basic audit event creation.""" | |
| now = datetime.now(timezone.utc) | |
| audit = AuditNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| event_type="login", | |
| event_category="security", | |
| actor="user123", | |
| action="authenticate", | |
| outcome="success", | |
| ) | |
| assert audit.event_type == "login" | |
| assert audit.event_category == "security" | |
| assert audit.actor == "user123" | |
| assert audit.outcome == "success" | |
| def test_audit_with_full_context(self): | |
| """Test audit with full context information.""" | |
| now = datetime.now(timezone.utc) | |
| audit = AuditNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| event_type="data_access", | |
| event_category="compliance", | |
| actor="service_account", | |
| target="user_profiles", | |
| action="read", | |
| outcome="success", | |
| ip_address="192.168.1.1", | |
| user_agent="CIRIS/1.0", | |
| correlation_id="abc-123", | |
| risk_score=0.2, | |
| evidence={"records_accessed": "50", "time_taken": "2.5s"}, | |
| ) | |
| assert audit.ip_address == "192.168.1.1" | |
| assert audit.correlation_id == "abc-123" | |
| assert audit.risk_score == 0.2 | |
| assert audit.evidence["records_accessed"] == "50" | |
| def test_audit_failure_with_error(self): | |
| """Test audit event for failure with error details.""" | |
| now = datetime.now(timezone.utc) | |
| audit = AuditNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| event_type="permission_check", | |
| event_category="security", | |
| actor="user456", | |
| target="admin_panel", | |
| action="access", | |
| outcome="failure", | |
| error_details="Insufficient permissions: requires ADMIN role", | |
| ) | |
| assert audit.outcome == "failure" | |
| assert "Insufficient permissions" in audit.error_details | |
| def test_audit_defaults(self): | |
| """Test audit default values.""" | |
| now = datetime.now(timezone.utc) | |
| audit = AuditNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| event_type="test", | |
| event_category="operational", | |
| actor="system", | |
| action="test", | |
| outcome="success", | |
| ) | |
| assert audit.evidence == {} | |
| assert audit.target is None | |
| assert audit.risk_score is None | |
| class TestMemoryNodeData: | |
| """Test MemoryNodeData schema.""" | |
| def test_basic_memory_node(self): | |
| """Test basic memory node creation.""" | |
| now = datetime.now(timezone.utc) | |
| memory = MemoryNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| content="User prefers dark mode", | |
| memory_type="fact", | |
| source="user_preferences", | |
| ) | |
| assert memory.content == "User prefers dark mode" | |
| assert memory.memory_type == "fact" | |
| assert memory.source == "user_preferences" | |
| def test_memory_with_relationships(self): | |
| """Test memory with related memories.""" | |
| now = datetime.now(timezone.utc) | |
| memory = MemoryNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| content="User is frustrated with slow response times", | |
| memory_type="experience", | |
| source="conversation", | |
| related_memories=["mem_123", "mem_456"], | |
| derived_from="mem_789", | |
| ) | |
| assert len(memory.related_memories) == 2 | |
| assert "mem_123" in memory.related_memories | |
| assert memory.derived_from == "mem_789" | |
| def test_memory_usage_tracking(self): | |
| """Test memory usage tracking fields.""" | |
| now = datetime.now(timezone.utc) | |
| last_access = datetime(2025, 1, 1, 10, 0, 0, tzinfo=timezone.utc) | |
| memory = MemoryNodeData( | |
| created_at=now, | |
| updated_at=now, | |
| content="Important insight", | |
| memory_type="insight", | |
| source="analysis", | |
| access_count=10, | |
| last_accessed=last_access, | |
| importance_score=0.9, | |
| ) | |
| assert memory.access_count == 10 | |
| assert memory.last_accessed == last_access | |
| assert memory.importance_score == 0.9 | |
| def test_memory_defaults(self): | |
| """Test memory default values.""" | |
| now = datetime.now(timezone.utc) | |
| memory = MemoryNodeData( | |
| created_at=now, updated_at=now, content="Test memory", memory_type="fact", source="test" | |
| ) | |
| assert memory.related_memories == [] | |
| assert memory.access_count == 0 | |
| assert memory.importance_score == 0.5 | |
| assert memory.last_accessed is None | |
| def test_memory_importance_bounds(self): | |
| """Test memory importance score validation.""" | |
| now = datetime.now(timezone.utc) | |
| # Should accept values between 0.0 and 1.0 | |
| memory = MemoryNodeData( | |
| created_at=now, updated_at=now, content="Test", memory_type="fact", source="test", importance_score=0.0 | |
| ) | |
| assert memory.importance_score == 0.0 | |
| memory2 = MemoryNodeData( | |
| created_at=now, updated_at=now, content="Test", memory_type="fact", source="test", importance_score=1.0 | |
| ) | |
| assert memory2.importance_score == 1.0 | |
Xet Storage Details
- Size:
- 12.4 kB
- Xet hash:
- 1fb497104ebbf595806e6f0caddc53cc91f8f884f039a4e6521461dde7769607
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.