Graph-Native Infrastructure for Context and Accountable AI Systems
Python agent-memoryaiai-governanceai-infrastructureartificial-intelligencecontext-engineeringcontext-graphsdata-engineeringdecision-intelligencedeveloper-toolsexplainable-aigenerative-aigraph-ragknowledge-graphllmontologyprovenancepythonreasoningsemantic-search
"""
Tests for Decision Tracking Data Models
This module tests the decision tracking data models including
validation, serialization, and deserialization.
"""
from datetime import datetime
import pytest
from semantica.context.decision_models import (
ApprovalChain,
Decision,
DecisionContext,
Policy,
PolicyException,
Precedent,
deserialize_decision,
deserialize_policy,
serialize_decision,
serialize_policy,
validate_decision,
validate_policy,
)
class TestDecision:
"""Test Decision data model."""
def test_decision_creation(self):
"""Test basic decision creation."""
decision = Decision(
decision_id="test_001",
category="credit_approval",
scenario="Credit limit increase request",
reasoning="Customer has excellent payment history",
outcome="approved",
confidence=0.85,
timestamp=datetime.now(),
decision_maker="ai_agent_001"
)
assert decision.decision_id == "test_001"
assert decision.category == "credit_approval"
assert decision.scenario == "Credit limit increase request"
assert decision.reasoning == "Customer has excellent payment history"
assert decision.outcome == "approved"
assert decision.confidence == 0.85
assert decision.decision_maker == "ai_agent_001"
def test_decision_auto_id(self):
"""Test automatic ID generation."""
decision = Decision(
decision_id="",
category="test",
scenario="test scenario",
reasoning="test reasoning",
outcome="test outcome",
confidence=0.5,
timestamp=datetime.now(),
decision_maker="test_agent"
)
assert decision.decision_id != ""
assert len(decision.decision_id) > 0
def test_decision_confidence_validation(self):
"""Test confidence validation."""
with pytest.raises(ValueError):
Decision(
decision_id="test",
category="test",
scenario="test",
reasoning="test",
outcome="test",
confidence=1.5, # Invalid confidence > 1
timestamp=datetime.now(),
decision_maker="test"
)
with pytest.raises(ValueError):
Decision(
decision_id="test",
category="test",
scenario="test",
reasoning="test",
outcome="test",
confidence=-0.1, # Invalid confidence < 0
timestamp=datetime.now(),
decision_maker="test"
)
def test_decision_to_dict(self):
"""Test decision serialization to dictionary."""
decision = Decision(
decision_id="test_001",
category="test",
scenario="test scenario",
reasoning="test reasoning",
outcome="test outcome",
confidence=0.8,
timestamp=datetime.now(),
decision_maker="test_agent",
metadata={"key": "value"}
)
decision_dict = decision.to_dict()
assert decision_dict["decision_id"] == "test_001"
assert decision_dict["category"] == "test"
assert decision_dict["scenario"] == "test scenario"
assert decision_dict["reasoning"] == "test reasoning"
assert decision_dict["outcome"] == "test outcome"
assert decision_dict["confidence"] == 0.8
assert decision_dict["decision_maker"] == "test_agent"
assert decision_dict["metadata"]["key"] == "value"
assert isinstance(decision_dict["timestamp"], str)
def test_decision_from_dict(self):
"""Test decision deserialization from dictionary."""
decision_data = {
"decision_id": "test_001",
"category": "test",
"scenario": "test scenario",
"reasoning": "test reasoning",
"outcome": "test outcome",
"confidence": 0.8,
"timestamp": datetime.now().isoformat(),
"decision_maker": "test_agent",
"metadata": {"key": "value"}
}
decision = Decision.from_dict(decision_data)
assert decision.decision_id == "test_001"
assert decision.category == "test"
assert decision.scenario == "test scenario"
assert decision.reasoning == "test reasoning"
assert decision.outcome == "test outcome"
assert decision.confidence == 0.8
assert decision.decision_maker == "test_agent"
assert decision.metadata["key"] == "value"
assert isinstance(decision.timestamp, datetime)
class TestDecisionContext:
"""Test DecisionContext data model."""
def test_decision_context_creation(self):
"""Test basic decision context creation."""
context = DecisionContext(
context_id="ctx_001",
decision_id="decision_001",
entity_snapshots={"entity1": {"name": "test", "type": "person"}},
risk_factors=["high_risk", "new_customer"],
cross_system_inputs={"salesforce": {"tier": "premium"}},
metadata={"version": "1.0"}
)
assert context.context_id == "ctx_001"
assert context.decision_id == "decision_001"
assert len(context.entity_snapshots) == 1
assert context.entity_snapshots["entity1"]["name"] == "test"
assert context.risk_factors == ["high_risk", "new_customer"]
assert context.cross_system_inputs["salesforce"]["tier"] == "premium"
assert context.metadata["version"] == "1.0"
def test_decision_context_auto_id(self):
"""Test automatic ID generation."""
context = DecisionContext(
context_id="",
decision_id="decision_001",
entity_snapshots={},
risk_factors=[]
)
assert context.context_id != ""
assert len(context.context_id) > 0
class TestPolicy:
"""Test Policy data model."""
def test_policy_creation(self):
"""Test basic policy creation."""
now = datetime.now()
policy = Policy(
policy_id="policy_001",
name="Credit Approval Policy",
description="Standard credit approval rules",
rules={"min_score": 650, "max_debt_ratio": 0.4},
category="credit_approval",
version="1.0",
created_at=now,
updated_at=now,
metadata={"department": "risk"}
)
assert policy.policy_id == "policy_001"
assert policy.name == "Credit Approval Policy"
assert policy.description == "Standard credit approval rules"
assert policy.rules["min_score"] == 650
assert policy.category == "credit_approval"
assert policy.version == "1.0"
assert policy.metadata["department"] == "risk"
def test_policy_auto_id(self):
"""Test automatic ID generation."""
policy = Policy(
policy_id="",
name="Test Policy",
description="Test description",
rules={"test": "rule"},
category="test",
version="1.0",
created_at=datetime.now(),
updated_at=datetime.now()
)
assert policy.policy_id != ""
assert len(policy.policy_id) > 0
class TestPolicyException:
"""Test PolicyException data model."""
def test_policy_exception_creation(self):
"""Test basic policy exception creation."""
policy_exception = PolicyException(
exception_id="exc_001",
decision_id="decision_001",
policy_id="policy_001",
reason="Customer is VIP with special arrangements",
approver="manager_001",
approval_timestamp=datetime.now(),
justification="Long-term customer with excellent history",
metadata={"override_type": "vip_exception"}
)
assert policy_exception.exception_id == "exc_001"
assert policy_exception.decision_id == "decision_001"
assert policy_exception.policy_id == "policy_001"
assert policy_exception.reason == "Customer is VIP with special arrangements"
assert policy_exception.approver == "manager_001"
assert policy_exception.justification == "Long-term customer with excellent history"
assert policy_exception.metadata["override_type"] == "vip_exception"
def test_policy_exception_auto_id(self):
"""Test automatic ID generation."""
policy_exception = PolicyException(
exception_id="",
decision_id="decision_001",
policy_id="policy_001",
reason="test reason",
approver="test_approver",
approval_timestamp=datetime.now(),
justification="test justification"
)
assert policy_exception.exception_id != ""
assert len(policy_exception.exception_id) > 0
class TestPrecedent:
"""Test Precedent data model."""
def test_precedent_creation(self):
"""Test basic precedent creation."""
precedent = Precedent(
precedent_id="prec_001",
source_decision_id="decision_001",
similarity_score=0.85,
relationship_type="similar_scenario",
metadata={"matched_features": ["category", "amount"]}
)
assert precedent.precedent_id == "prec_001"
assert precedent.source_decision_id == "decision_001"
assert precedent.similarity_score == 0.85
assert precedent.relationship_type == "similar_scenario"
assert precedent.metadata["matched_features"] == ["category", "amount"]
def test_precedent_validation(self):
"""Test precedent validation."""
# Test invalid similarity score
with pytest.raises(ValueError):
Precedent(
precedent_id="test",
source_decision_id="test",
similarity_score=1.5, # Invalid > 1
relationship_type="similar_scenario"
)
# Test invalid relationship type
with pytest.raises(ValueError):
Precedent(
precedent_id="test",
source_decision_id="test",
similarity_score=0.8,
relationship_type="invalid_type"
)
class TestApprovalChain:
"""Test ApprovalChain data model."""
def test_approval_chain_creation(self):
"""Test basic approval chain creation."""
approval = ApprovalChain(
approval_id="app_001",
decision_id="decision_001",
approver="manager_001",
approval_method="slack_dm",
approval_context="Approved via Slack DM with justification",
timestamp=datetime.now(),
metadata={"message_id": "msg_12345"}
)
assert approval.approval_id == "app_001"
assert approval.decision_id == "decision_001"
assert approval.approver == "manager_001"
assert approval.approval_method == "slack_dm"
assert approval.approval_context == "Approved via Slack DM with justification"
assert approval.metadata["message_id"] == "msg_12345"
def test_approval_chain_validation(self):
"""Test approval chain validation."""
# Test invalid approval method
with pytest.raises(ValueError):
ApprovalChain(
approval_id="test",
decision_id="test",
approver="test",
approval_method="invalid_method", # Invalid method
approval_context="test context",
timestamp=datetime.now()
)
class TestValidationFunctions:
"""Test validation helper functions."""
def test_validate_decision(self):
"""Test decision validation."""
# Valid decision
valid_decision = Decision(
decision_id="test",
category="test",
scenario="test",
reasoning="test",
outcome="test",
confidence=0.8,
timestamp=datetime.now(),
decision_maker="test"
)
assert validate_decision(valid_decision) is True
# Invalid decision (missing required field)
invalid_decision = Decision(
decision_id="test",
category="", # Empty category
scenario="test",
reasoning="test",
outcome="test",
confidence=0.8,
timestamp=datetime.now(),
decision_maker="test"
)
assert validate_decision(invalid_decision) is False
def test_validate_policy(self):
"""Test policy validation."""
# Valid policy
valid_policy = Policy(
policy_id="test",
name="Test Policy",
description="Test description",
rules={"test": "rule"},
category="test",
version="1.0",
created_at=datetime.now(),
updated_at=datetime.now()
)
assert validate_policy(valid_policy) is True
# Invalid policy (missing required field)
invalid_policy = Policy(
policy_id="test",
name="Test Policy",
description="Test description",
rules={"test": "rule"},
category="", # Empty category
version="1.0",
created_at=datetime.now(),
updated_at=datetime.now()
)
assert validate_policy(invalid_policy) is False
class TestSerializationFunctions:
"""Test serialization helper functions."""
def test_serialize_deserialize_decision(self):
"""Test decision serialization and deserialization."""
original_decision = Decision(
decision_id="test_001",
category="test",
scenario="test scenario",
reasoning="test reasoning",
outcome="test outcome",
confidence=0.8,
timestamp=datetime.now(),
decision_maker="test_agent",
metadata={"key": "value"}
)
# Serialize
serialized = serialize_decision(original_decision)
assert isinstance(serialized, str)
# Deserialize
deserialized = deserialize_decision(serialized)
assert deserialized.decision_id == original_decision.decision_id
assert deserialized.category == original_decision.category
assert deserialized.scenario == original_decision.scenario
assert deserialized.reasoning == original_decision.reasoning
assert deserialized.outcome == original_decision.outcome
assert deserialized.confidence == original_decision.confidence
assert deserialized.decision_maker == original_decision.decision_maker
assert deserialized.metadata == original_decision.metadata
def test_serialize_deserialize_policy(self):
"""Test policy serialization and deserialization."""
original_policy = Policy(
policy_id="policy_001",
name="Test Policy",
description="Test description",
rules={"test": "rule"},
category="test",
version="1.0",
created_at=datetime.now(),
updated_at=datetime.now(),
metadata={"department": "risk"}
)
# Serialize
serialized = serialize_policy(original_policy)
assert isinstance(serialized, str)
# Deserialize
deserialized = deserialize_policy(serialized)
assert deserialized.policy_id == original_policy.policy_id
assert deserialized.name == original_policy.name
assert deserialized.description == original_policy.description
assert deserialized.rules == original_policy.rules
assert deserialized.category == original_policy.category
assert deserialized.version == original_policy.version
assert deserialized.metadata == original_policy.metadata
class TestAutoGenerateIdContract:
"""Test the auto_generate_id InitVar contract across all decision models.
Regression coverage for the InitVar fix: previously ``auto_generate_id``
was a plain ``__post_init__`` parameter that dataclass-generated ``__init__``
never forwarded, so the ``auto_generate_id=False`` branch was dead code and
the "id is required" contract could never fire.
"""
def _base_kwargs(self, cls):
now = datetime.now()
return {
Decision: dict(
decision_id="", category="c", scenario="s", reasoning="r",
outcome="o", confidence=0.5, timestamp=now, decision_maker="m",
),
DecisionContext: dict(
context_id="", decision_id="d", entity_snapshots={}, risk_factors=[],
),
Policy: dict(
policy_id="", name="n", description="d", rules={}, category="c",
version="1", created_at=now, updated_at=now,
),
PolicyException: dict(
exception_id="", decision_id="d", policy_id="p", reason="r",
approver="a", approval_timestamp=now, justification="j",
),
Precedent: dict(
precedent_id="", source_decision_id="d", similarity_score=0.5,
relationship_type="same_policy",
),
ApprovalChain: dict(
approval_id="", decision_id="d", approver="a",
approval_method="email", approval_context="x", timestamp=now,
),
}[cls]
@pytest.mark.parametrize(
"cls",
[Decision, DecisionContext, Policy, PolicyException, Precedent, ApprovalChain],
)
def test_auto_generate_id_is_not_a_field(self, cls):
"""auto_generate_id must stay an InitVar, never a real dataclass field."""
import dataclasses
names = [f.name for f in dataclasses.fields(cls)]
assert "auto_generate_id" not in names
@pytest.mark.parametrize(
"cls",
[Decision, DecisionContext, Policy, PolicyException, Precedent, ApprovalChain],
)
def test_default_auto_generates_id(self, cls):
"""With defaults, an empty id is auto-populated and stays a non-field."""
obj = cls(**self._base_kwargs(cls))
id_field = [f.name for f in __import__("dataclasses").fields(cls)][0]
assert getattr(obj, id_field)
assert "auto_generate_id" not in vars(obj)
@pytest.mark.parametrize(
"cls",
[Decision, DecisionContext, Policy, PolicyException, Precedent, ApprovalChain],
)
def test_required_id_when_auto_generate_disabled(self, cls):
"""auto_generate_id=False with an empty id must raise ValueError."""
with pytest.raises(ValueError):
cls(auto_generate_id=False, **self._base_kwargs(cls))
def test_explicit_id_honored_with_auto_generate_disabled(self):
"""A provided id is preserved when auto_generate_id=False."""
kwargs = self._base_kwargs(Decision)
kwargs["decision_id"] = "fixed-id"
decision = Decision(auto_generate_id=False, **kwargs)
assert decision.decision_id == "fixed-id"
assert "auto_generate_id" not in decision.to_dict()
if __name__ == "__main__":
pytest.main([__file__])