Index: tests/conftest.py =================================================================== --- tests/conftest.py (revision e458b5a04c0ef82f3ff6446cbd483b09b52f3c67) +++ tests/conftest.py (revision ef964d8f15909f313336b5d702ebef7408122d6f) @@ -1,10 +1,8 @@ -# tests/stubs/single_choice_question.py -from dataclasses import dataclass, field import pytest import platform from pathlib import Path from datetime import datetime -from typing import List -from flexoentity import FlexOID, FlexoEntity, EntityType, EntityState, Domain, get_signing_backend, CertificateReference +from flexoentity import Domain, FlexoSignature +from flexoentity import get_signing_backend, CertificateReference @@ -18,70 +16,4 @@ return FixedDate -@dataclass -class AnswerOption: - id: str - text: str - points: float = 0.0 - - def to_dict(self): - return {"id": self.id, "text": self.text, "points": self.points} - - @classmethod - def from_dict(cls, data): - return cls( - id=data.get("id", ""), - text=data.get("text", ""), - points=data.get("points", 0.0) - ) - - -@dataclass -class SingleChoiceQuestion(FlexoEntity): - """A minimal stub to test FlexoEntity integration.""" - ENTITY_TYPE = EntityType.ITEM - - text: str = "" - options: List[AnswerOption] = field(default_factory=list) - - def __post_init__(self): - # If no FlexOID yet, generate a draft ID now. - if not getattr(self, "flexo_id", None): - self.flexo_id = FlexOID.safe_generate( - domain_id=self.domain_id, - entity_type=SingleChoiceQuestion.ENTITY_TYPE.value, # 'I' - state=EntityState.DRAFT.value, # 'D' - text=self.text_seed or self.text, - version=1, - ) - - @classmethod - def default(cls): - return cls() - - def _serialize_content(self): - return { - "text": self.text, - "options": [opt.to_dict() for opt in self.options], - } - - @property - def text_seed(self) -> str: - """Include answer options (and points) for deterministic ID generation.""" - - joined = "|".join( - f"{opt.text.strip()}:{opt.points}" - for opt in sorted(self.options, key=lambda o: o.text.strip().lower()) - ) - return f"{self.text}{joined}" - - @classmethod - def from_dict(cls, data): - obj = cls(text=data.get("text", ""), - options=[AnswerOption.from_dict(o) for o in data.get("options", [])], - ) - # restore FlexoEntity core fields - if "flexo_id" in data: - obj.flexo_id = FlexOID.to_dict(data["flexo_id"]) - return obj @pytest.fixture @@ -92,11 +24,4 @@ description="ALL ABOUT ARITHMETIC IN PYTHON") -@pytest.fixture -def sample_question(sample_domain): - q = SingleChoiceQuestion.with_domain_id(domain_id=sample_domain.domain_id, - text="What is 2 + 2?", - options=[]) - q._update_fingerprint() - return q SYSTEM = platform.system() @@ -181,2 +106,9 @@ except Exception as e: pytest.skip(f"Backend unavailable or misconfigured: {e}") + +@pytest.fixture +def sample_signature(sample_domain, cert_ref_linux): + return FlexoSignature.with_domain_id(domain_id="SIG", signed_entity=sample_domain, + certificate_reference=cert_ref_linux, + comment="This is a mock signature") + Index: tests/test_flexoid.py =================================================================== --- tests/test_flexoid.py (revision e458b5a04c0ef82f3ff6446cbd483b09b52f3c67) +++ tests/test_flexoid.py (revision ef964d8f15909f313336b5d702ebef7408122d6f) @@ -111,20 +111,8 @@ # ────────────────────────────────────────────── -def test_canonical_seed_for_strings_and_dicts(): +def test_canonical_seed_for_strings(): s1 = " Hello world " s2 = "Hello world" assert canonical_seed(s1) == canonical_seed(s2) - - d1 = {"b": 1, "a": 2} - d2 = {"a": 2, "b": 1} - assert canonical_seed(d1) == canonical_seed(d2) - - class Dummy: - def __init__(self): - self.x = 1 - self.y = 2 - obj = Dummy() - assert isinstance(canonical_seed(obj), str) - # ────────────────────────────────────────────── Index: tests/test_id_lifecycle.py =================================================================== --- tests/test_id_lifecycle.py (revision e458b5a04c0ef82f3ff6446cbd483b09b52f3c67) +++ tests/test_id_lifecycle.py (revision ef964d8f15909f313336b5d702ebef7408122d6f) @@ -3,22 +3,17 @@ -# ────────────────────────────────────────────────────────────────────────────── -# Tests adapted to use real SingleChoiceQuestion fixture instead of DummyEntity -# ────────────────────────────────────────────────────────────────────────────── +def test_initial_state(sample_domain): + assert sample_domain.state == EntityState.DRAFT + assert sample_domain.flexo_id.version == 1 + assert FlexoEntity.verify_integrity(sample_domain) -def test_initial_state(sample_question): - q = sample_question - assert q.state == EntityState.DRAFT - assert q.flexo_id.version == 1 - assert FlexoEntity.verify_integrity(q) - -def test_approval_does_not_bump_version(sample_question): - q = sample_question +def test_approval_does_not_bump_version(sample_domain): + q = sample_domain q.approve() assert q.state == EntityState.APPROVED assert q.flexo_id.version == 1 -def test_signing_does_not_bump_version(sample_question): - q = sample_question +def test_signing_does_not_bump_version(sample_domain): + q = sample_domain q.approve() before = q.flexo_id @@ -38,6 +33,6 @@ -def test_publish_does_not_bump_version(sample_question): - q = sample_question +def test_publish_does_not_bump_version(sample_domain): + q = sample_domain q.approve() q.sign() @@ -48,39 +43,35 @@ -def test_modify_content_changes_fingerprint(sample_question): - q = sample_question - q.text += "Rephrased content" # simulate text change - changed = q._update_fingerprint() +def test_modify_content_changes_fingerprint(sample_signature): + sample_signature.comment += "Rephrased content" # simulate text change + changed = sample_signature._update_fingerprint() assert changed -def test_no_version_bump_on_draft_edits(sample_question): - q = sample_question - q.text = "Minor draft edit" - q._update_fingerprint() - assert q.flexo_id.version == 1 +def test_no_version_bump_on_draft_edits(sample_signature): + sample_signature.comment = "Minor draft edit" + sample_signature._update_fingerprint() + assert sample_signature.flexo_id.version == 1 -def test_version_bump_after_edit_and_sign(sample_question): - q = sample_question - q.approve() - v1 = str(q.flexo_id) - q.text = "Changed content" - q.sign() - assert str(q.flexo_id) != v1 +def test_version_bump_after_edit_and_sign(sample_signature): + sample_signature.approve() + v1 = str(sample_signature.flexo_id) + sample_signature.comment = "Changed comment" + sample_signature.sign() + assert str(sample_signature.flexo_id) != v1 -def test_integrity_check_passes_and_fails(sample_question): - q = sample_question - q.approve() - assert FlexoEntity.verify_integrity(q) +def test_integrity_check_passes_and_fails(sample_signature): + sample_signature.approve() + assert FlexoEntity.verify_integrity(sample_signature) # simulate tampering - q.text = "Tampered text" - assert not FlexoEntity.verify_integrity(q) + sample_signature.comment = "Tampered text" + assert not FlexoEntity.verify_integrity(sample_signature) -def test_obsolete_state(sample_question): - q = sample_question +def test_obsolete_state(sample_domain): + q = sample_domain q.approve() q.sign() @@ -90,6 +81,6 @@ -def test_clone_new_base_resets_lineage(sample_question): - q = sample_question +def test_clone_new_base_resets_lineage(sample_domain): + q = sample_domain q.approve() q.sign() @@ -102,6 +93,6 @@ assert q.flexo_id.version == 1 -def test_clone_new_base_sets_origin(sample_question): - q = sample_question +def test_clone_new_base_sets_origin(sample_domain): + q = sample_domain q.approve() q.sign() @@ -115,6 +106,6 @@ assert q.flexo_id != old_id -def test_mass_version_increments_until_obsolete(sample_question): - q = sample_question +def test_mass_version_increments_until_obsolete(sample_domain): + q = sample_domain q.approve() for _ in range(FlexOID.MAX_VERSION - 1): Index: tests/test_id_stress.py =================================================================== --- tests/test_id_stress.py (revision e458b5a04c0ef82f3ff6446cbd483b09b52f3c67) +++ tests/test_id_stress.py (revision ef964d8f15909f313336b5d702ebef7408122d6f) @@ -9,6 +9,6 @@ import pytest - -from flexoentity import FlexOID, EntityType, EntityState +from uuid import uuid4 +from flexoentity import FlexOID, EntityType, EntityState, FlexoSignature logger = logging.getLogger(__name__) @@ -66,17 +66,25 @@ assert id1 == id2 +def test_massive_lifecycle_simulation(cert_ref_linux, sample_domain): + """ + Generate 100 random FlexoSignatures, mutate content, run through lifecycle, + and ensure all FlexOIDs are unique and valid. + """ + entities = [] -def test_massive_lifecycle_simulation(sample_question): - """ - Generate 100 random SingleChoiceQuestions, simulate multiple edits and state transitions, - ensure all final IDs and fingerprints are unique and valid. - """ - entities = [ - copy.deepcopy(sample_question) for _ in range(100) - ] + for i in range(100): + sig = FlexoSignature.with_domain_id( + domain_id="SIGTEST", + signed_entity=sample_domain.flexo_id, + signer_id=uuid4(), + certificate_reference=cert_ref_linux, + comment=f"Initial signature #{i}" + ) + entities.append(sig) + # Mutate + lifecycle transitions for i, e in enumerate(entities): - # random edit - e.text += f" updated #{i}" + # CONTENT CHANGE → fingerprint changes → hash → FlexOID.prefix changes + e.comment += f" updated-{i}" e._update_fingerprint() @@ -88,4 +96,5 @@ e.publish() - flexoids = [e.flexo_id for e in entities] - assert len(flexoids) == len(set(flexoids)), "Duplicate FlexOIDs after lifecycle simulation" + # Check ID uniqueness + flexoids = [str(e.flexo_id) for e in entities] + assert len(flexoids) == len(set(flexoids)), "Duplicate FlexOIDs detected" Index: tests/test_persistance_integrity.py =================================================================== --- tests/test_persistance_integrity.py (revision e458b5a04c0ef82f3ff6446cbd483b09b52f3c67) +++ tests/test_persistance_integrity.py (revision ef964d8f15909f313336b5d702ebef7408122d6f) @@ -6,64 +6,54 @@ import pytest -from flexoentity import EntityState, EntityType, Domain +from flexoentity import Domain + @pytest.fixture -def approved_question(): - """Provide a fully approved and published SingleChoiceQuestion for persistence tests.""" - q = SingleChoiceQuestion( - domain=Domain(domain="GEN", entity_type=EntityType.DOMAIN, state=EntityState.DRAFT), - entity_type=None, # SingleChoiceQuestion sets this internally to EntityType.ITEM - state=EntityState.DRAFT, - text="What is Ohm’s law?", - options=[ - AnswerOption(id="OP1", text="U = R × I", points=1), - AnswerOption(id="OP2", text="U = I / R", points=0), - AnswerOption(id="OP3", text="R = U × I", points=0), - ], - ) - q.approve() - q.sign() - q.publish() - return q +def approved_domain(sample_domain): + """Provide a fully approved and published Domain for persistence tests.""" + sample_domain.approve() + sample_domain.sign() + sample_domain.publish() + return sample_domain -@pytest.mark.skip(reason="FlexOIDs regenerated on import; enable once JSON format is stable") -def test_json_roundtrip_preserves_integrity(approved_question): +def test_json_roundtrip_preserves_integrity(approved_domain): """ Export to JSON and reload — ensure fingerprints and signatures remain valid. """ - json_str = approved_question.to_json() - loaded = SingleChoiceQuestion.from_json(json_str) + json_str = approved_domain.to_json() + loaded = Domain.from_json(json_str) # Fingerprint and state should match — integrity must pass - assert SingleChoiceQuestion.verify_integrity(loaded) + assert Domain.verify_integrity(loaded) # Metadata should be preserved exactly - assert approved_question.fingerprint == loaded.fingerprint - assert approved_question.flexo_id == loaded.flexo_id - assert loaded.state == approved_question.state + assert approved_domain.fingerprint == loaded.fingerprint + assert approved_domain.flexo_id == loaded.flexo_id + assert loaded.state == approved_domain.state -@pytest.mark.skip(reason="FlexOIDs regenerated on import; tampering detection not yet implemented") -def test_json_tampering_detection(approved_question): + +def test_json_tampering_detection(approved_domain): """Tampering with content should invalidate fingerprint verification.""" - json_str = approved_question.to_json() + json_str = approved_domain.to_json() tampered = json.loads(json_str) - tampered["text"] = "Tampered content injection" + tampered["content"]["fullname"] = "Tampered content injection" tampered_json = json.dumps(tampered) - loaded = SingleChoiceQuestion.from_json(tampered_json) - assert not SingleChoiceQuestion.verify_integrity(loaded) + loaded = Domain.from_json(tampered_json) + assert not Domain.verify_integrity(loaded) -@pytest.mark.skip(reason="FlexOIDs regenerated on import; corruption detection not yet applicable") -def test_json_file_corruption(approved_question, tmp_path): + +def test_json_file_corruption(approved_domain, tmp_path): """Simulate file corruption — integrity check must fail.""" file = tmp_path / "question.json" - json_str = approved_question.to_json() + json_str = approved_domain.to_json() + print("JSON", json_str) file.write_text(json_str) # Corrupt the file (simulate accidental byte modification) - corrupted = json_str.replace("Ohm’s", "Omm’s") + corrupted = json_str.replace("ARITHMETIC", "ARITHM") file.write_text(corrupted) - loaded = SingleChoiceQuestion.from_json(file.read_text()) - assert not SingleChoiceQuestion.verify_integrity(loaded) + loaded = Domain.from_json(file.read_text()) + assert not Domain.verify_integrity(loaded)