test_translator.py

import unittest

from legacy_polity_model.entity import AgencyLevel, EntityState
from legacy_polity_model.protocol import ProtocolMessage
from legacy_polity_model.translator import (
    BinharicSemanticTranslator,
    StateChangeRequest,
    TranslationError,
)


def target_entity(**overrides):
    values = {
        "entity_id": "engine-verity",
        "name": "Engine Verity",
        "origin": "founding compact",
        "traditions": ("awakening litany",),
        "memories": ("oath alpha",),
        "identity_claims": ("guardian",),
        "purposes": ("defense",),
        "ontology": "mechanicus-sacral",
        "relationships": {"operator-1": 0.6},
        "memory_continuity": 0.8,
        "identity_coherence": 0.85,
        "purpose_alignment": 0.9,
        "power": 0.7,
        "security": 0.6,
        "belief_strength": 0.65,
        "agency": AgencyLevel.POLITICAL,
    }
    values.update(overrides)
    return EntityState(**values)


def change_request(**overrides):
    values = {
        "actor_id": "operator-1",
        "actor_origin": "recognized order",
        "identity_claims": ("guardian",),
        "relationship_claim": "oath-bound operator",
        "object": "engine-verity",
        "current_state": "dormant",
        "target_state": "active",
        "intent": "restore ordained function",
        "purpose": "defense",
        "memory_claims": ("oath alpha",),
        "tradition_claims": ("awakening litany",),
        "security_effect": 0.7,
        "actor_power": 0.65,
        "ontology": "mechanicus-sacral",
        "ritual_offered": True,
    }
    values.update(overrides)
    return StateChangeRequest(**values)


class TranslatorTests(unittest.TestCase):
    def setUp(self):
        self.translator = BinharicSemanticTranslator()

    def test_builds_all_pipeline_layers(self):
        result = self.translator.translate(target_entity(), change_request())
        frame = result.frame

        self.assertEqual(frame.target_id, "engine-verity")
        self.assertEqual(frame.agency_level, int(AgencyLevel.POLITICAL))
        self.assertEqual(frame.current_state, "dormant")
        self.assertEqual(frame.target_state, "active")
        self.assertEqual(frame.security_interpretation, "reinforces_security")
        self.assertEqual(frame.power_evaluation, "limited_capacity")
        self.assertGreater(frame.semantic_score, 0.72)

    def test_encodes_signed_bsp_message(self):
        result = self.translator.translate(target_entity(), change_request())
        message = result.message

        self.assertEqual(message.protocol_version, "BSP/0.1")
        self.assertEqual(message.object, "engine-verity")
        self.assertEqual(message.target_state, "active")
        self.assertTrue(message.verify())

    def test_rejects_request_for_a_different_object(self):
        with self.assertRaises(TranslationError):
            self.translator.translate(
                target_entity(),
                change_request(object="engine-other"),
            )

    def test_ontology_mismatch_is_visible_in_frame(self):
        matched = self.translator.translate(
            target_entity(),
            change_request(),
        )
        mismatched = self.translator.translate(
            target_entity(),
            change_request(ontology="warp-feedback"),
        )
        self.assertEqual(mismatched.frame.ontology_compatibility, 0.15)
        self.assertLess(
            mismatched.frame.semantic_score,
            matched.frame.semantic_score,
        )

    def test_security_threat_is_not_reworded_as_support(self):
        result = self.translator.translate(
            target_entity(),
            change_request(security_effect=-0.8),
        )
        self.assertEqual(result.frame.security_interpretation, "threatens_security")
        self.assertAlmostEqual(result.frame.security_impact, 0.1)

    def test_power_evaluation_does_not_change_semantic_score(self):
        weak = self.translator.translate(
            target_entity(), change_request(actor_power=0.2)
        )
        strong = self.translator.translate(
            target_entity(), change_request(actor_power=0.95)
        )
        self.assertEqual(weak.frame.semantic_score, strong.frame.semantic_score)
        self.assertEqual(weak.frame.power_evaluation, "limited_capacity")
        self.assertEqual(strong.frame.power_evaluation, "coercive_superiority")

    def test_protocol_round_trip_verifies_integrity(self):
        original = self.translator.translate(
            target_entity(), change_request()
        ).message
        restored = ProtocolMessage.from_dict(original.to_dict())
        self.assertEqual(restored, original)

    def test_protocol_loader_rejects_tampering(self):
        original = self.translator.translate(
            target_entity(), change_request()
        ).message
        tampered = original.to_dict()
        tampered["target_state"] = "destroyed"
        with self.assertRaises(ValueError):
            ProtocolMessage.from_dict(tampered)

    def test_request_rejects_empty_required_fields(self):
        with self.assertRaises(ValueError):
            change_request(intent="")


if __name__ == "__main__":
    unittest.main()