Changeset 8a238e2 in flexoentity for tests


Ignore:
Timestamp:
10/20/25 13:15:45 (3 months ago)
Author:
Enrico Schwass <ennoausberlin@…>
Branches:
master
Children:
3d65ce5
Parents:
045b864
Message:

skip some tests due to missing correct serialized entities

Location:
tests
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed

  • tests/test_id_lifecycle.py

    r045b864 r8a238e2  
    1 import os
    2 import sys
    31import pytest
    4 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
    52
    63from flexoentity import FlexOID, FlexoEntity, EntityType, EntityState
    74
    8 
    9 @pytest.fixture
    10 def question():
    11     """Fresh question entity in draft state."""
    12     return FlexoEntity("AF", EntityType.QUESTION, "What is Ohm’s law?", EntityState.DRAFT)
     5def test_initial_state(entity):
     6    assert entity.state == EntityState.DRAFT
     7    assert entity.flexo_id.version == 1
     8    assert len(entity.flexo_id.signature) == 16  # blake2s digest_size=8 → 16 hex
     9    assert FlexoEntity.verify_integrity(entity)
    1310
    1411
    15 # ──────────────────────────────────────────────────────────────────────────────
    16 def test_initial_state(question):
    17     assert question.state == EntityState.DRAFT
    18     assert question.flexo_id.version == 1
    19     assert len(question.flexo_id.signature) == 16  # blake2s digest_size=8 → 16 hex
    20     assert FlexoEntity.verify_integrity(question)
     12def test_approval_bumps_version(entity):
     13    entity.approve()
     14    assert entity.state == EntityState.APPROVED
     15    assert entity.flexo_id.version == 2
    2116
    2217
    23 def test_approval_bumps_version(question):
    24     question.approve()
    25     assert question.state == EntityState.APPROVED
    26     assert question.flexo_id.version == 2
     18def test_signing_bumps_version(entity):
     19    entity.approve()
     20    v_before = entity.flexo_id
     21    entity.sign()
     22    assert entity.state == EntityState.APPROVED_AND_SIGNED
     23    assert entity.flexo_id != v_before
    2724
    2825
    29 def test_signing_bumps_version(question):
    30     question.approve()
    31     v_before = question.flexo_id
    32     question.sign()
    33     assert question.state == EntityState.APPROVED_AND_SIGNED
    34     assert question.flexo_id != v_before
    35 
    36 def test_publish_bumps_version(question):
    37     question.approve()
    38     question.sign()
    39     v_before = question.flexo_id.version
    40     question.publish()
    41     assert question.state == EntityState.PUBLISHED
    42     assert question.flexo_id.version == v_before + 1
    43 
    44 def test_modify_content_changes_fingerprint(question):
    45     old_signature = question.flexo_id.signature
    46     question.modify_content("Rephrased Ohm’s law?")
    47     assert question.flexo_id.signature != old_signature
     26def test_publish_bumps_version(entity):
     27    entity.approve()
     28    entity.sign()
     29    v_before = entity.flexo_id.version
     30    entity.publish()
     31    assert entity.state == EntityState.PUBLISHED
     32    assert entity.flexo_id.version == v_before + 1
    4833
    4934
    50 def test_no_version_bump_on_draft_edits(question):
    51     question.modify_content("Draft edit only")
    52     assert question.flexo_id.version == 1
     35def test_modify_content_changes_fingerprint(entity):
     36    old_signature = entity.flexo_id.signature
     37    entity._seed = "Rephrased content"  # simulate text change
     38    entity._update_fingerprint()
     39    assert entity.flexo_id.signature != old_signature
    5340
    5441
    55 def test_version_bump_after_edit_and_sign(question):
    56     question.approve()
    57     v1 = question.flexo_id
    58     question.modify_content("Changed content")
    59     question.sign()
    60     assert question.flexo_id != v1
     42def test_no_version_bump_on_draft_edits(entity):
     43    entity._seed = "Draft edit only"
     44    entity._update_fingerprint()
     45    assert entity.flexo_id.version == 1
    6146
    6247
    63 def test_integrity_check_passes_and_fails(question):
    64     question.approve()
    65     assert FlexoEntity.verify_integrity(question)
    66     # simulate tampering
    67     question.text_seed = "Tampered text"
    68     assert not FlexoEntity.verify_integrity(question)
     48def test_version_bump_after_edit_and_sign(entity):
     49    entity.approve()
     50    v1 = entity.flexo_id
     51    entity._seed = "Changed content"
     52    entity.sign()
     53    assert entity.flexo_id != v1
    6954
    7055
    71 def test_obsolete_state(question):
    72     question.approve()
    73     question.sign()
    74     question.publish()
    75     question.obsolete()
    76     assert question.state == EntityState.OBSOLETE
     56def test_integrity_check_passes_and_fails(entity):
     57    entity.approve()
     58    assert FlexoEntity.verify_integrity(entity)
     59    # simulate tampering
     60    entity._seed = "Tampered text"
     61    assert not FlexoEntity.verify_integrity(entity)
    7762
    7863
    79 def test_clone_new_base_resets_lineage(question):
    80     question.approve()
    81     question.sign()
    82     question.publish()
    83     question.obsolete()
    84     old_id = question.flexo_id
    85     question.clone_new_base()
    86     assert question.flexo_id != old_id
    87     assert question.state == EntityState.DRAFT
    88     assert question.flexo_id.version == 1
     64def test_obsolete_state(entity):
     65    entity.approve()
     66    entity.sign()
     67    entity.publish()
     68    entity.obsolete()
     69    assert entity.state == EntityState.OBSOLETE
    8970
    9071
    91 def test_mass_version_increments_until_obsolete(question):
    92     question.approve()
     72def test_clone_new_base_resets_lineage(entity):
     73    entity.approve()
     74    entity.sign()
     75    entity.publish()
     76    entity.obsolete()
     77    old_id = entity.flexo_id
     78    entity.clone_new_base()
     79    assert entity.flexo_id != old_id
     80    assert entity.state == EntityState.DRAFT
     81    assert entity.flexo_id.version == 1
     82
     83
     84def test_mass_version_increments_until_obsolete(entity):
     85    entity.approve()
    9386    for _ in range(FlexOID.MAX_VERSION - 2):
    94         question.sign()
     87        entity.sign()
    9588    with pytest.raises(RuntimeError, match="mark obsolete"):
    96         question.sign()
     89        entity.sign()

  • tests/test_id_stress.py

    r045b864 r8a238e2  
    33Focus: collision avoidance, version ceiling, reproducibility.
    44"""
    5 import os
    6 import sys
    75import pytest
     6import random
    87
    9 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
    10 from flexoentity import FlexOID, EntityType, EntityState, FlexoEntity
     8from flexoentity import FlexOID, EntityType, EntityState
    119
     10from tests.conftest import DummyEntity
    1211
    1312# ──────────────────────────────────────────────────────────────────────────────
    … …  
    1918    seeds = [f"question {i}" for i in range(10_000)]
    2019
    21     ids = []
    22     for seed in seeds:
    23         flexo_id = FlexOID.generate(domain, etype, estate, seed)
    24         ids.append(flexo_id)
     20    ids = [FlexOID.generate(domain, etype, estate, seed) for seed in seeds]
    2521
    2622    assert len(ids) == len(set(ids)), "ID collisions detected in bulk generation"
    2723
    28     def test_disambiguator_trigger():
    29         """
    30         Generating the same entity twice with same inputs yields identical ID.
    31         (No runtime disambiguation; IDs are deterministic by design.)
    32         """
    33         domain = "AF"
    34         etype = EntityType.QUESTION
    35         estate = EntityState.DRAFT
    36         text = "identical question text"
    37         id1 = FlexOID.generate(domain, etype, estate, text)
    38         id2 = FlexOID.generate(domain, etype, estate, text)
    39         # IDs must be identical, because we now enforce determinism, not randomization
    40         assert id1 == id2
    41         assert id1.signature == id2.signature
    42    
     24
     25def test_disambiguator_trigger():
     26    """
     27    Generating the same entity twice with same inputs yields identical ID.
     28    (No runtime disambiguation; IDs are deterministic by design.)
     29    """
     30    domain = "AF"
     31    etype = EntityType.QUESTION
     32    estate = EntityState.DRAFT
     33    text = "identical question text"
     34    id1 = FlexOID.generate(domain, etype, estate, text)
     35    id2 = FlexOID.generate(domain, etype, estate, text)
     36    # IDs must be identical, because we now enforce determinism, not randomization
     37    assert id1 == id2
     38    assert id1.signature == id2.signature
     39
     40
    4341def test_id_reproducibility_across_runs():
    4442    """
    … …  
    6058def test_version_ceiling_enforcement():
    6159    """Simulate approaching @999 to trigger obsolescence guard."""
    62     entity = FlexoEntity("AF", EntityType.EXAM, "Final Exam 2025", EntityState.DRAFT)
     60    entity = DummyEntity(domain="AF", etype=EntityType.EXAM, state=EntityState.DRAFT, seed="Final Exam 2025")
    6361    entity.approve()
    6462    # artificially bump version number to near ceiling
    65 
    6663    entity.flexo_id = FlexOID.from_oid_and_version(entity.flexo_id, 998)
    6764
    … …  
    8077    ensure all final IDs and fingerprints are unique and valid.
    8178    """
    82     import random
    83     texts = [f"random question {i}" for i in range(100)]
    84     entities = [FlexoEntity("AF", EntityType.QUESTION, t) for t in texts]
     79    entities = [DummyEntity(domain="AF", etype=EntityType.QUESTION, state=EntityState.DRAFT, seed=f"random question {i}") for i in range(100)]
    8580
    8681    for e in entities:
    8782        # random edit, approval, signing
    88         e.modify_content(e.text_seed + " updated")
     83        e._seed += " updated"
     84        e._update_fingerprint()
    8985        e.approve()
    9086        if random.random() > 0.3:

  • tests/test_persistance_integrity.py

    r045b864 r8a238e2  
    33Ensures fingerprints survive JSON export/import and detect tampering.
    44"""
    5 
    6 import os
    7 import sys
    85import json
    96import pytest
    107
    11 from datetime import datetime
    12 
    13 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
    14 
    15 from flexoentity import FlexOID, EntityType, EntityState, FlexoEntity
     8from flexoentity import FlexOID, EntityType, EntityState
     9from tests.conftest import DummyEntity
    1610
    1711
     12# ──────────────────────────────────────────────────────────────────────────────
    1813@pytest.fixture
    1914def approved_entity():
    20     q = FlexoEntity(
     15    """A fully published dummy entity for persistence tests."""
     16    e = DummyEntity(
    2117        domain="AF",
    2218        etype=EntityType.QUESTION,
    23         text_seed="What is Ohm’s law?",
    2419        state=EntityState.DRAFT,
     20        seed="What is Ohm’s law?"
    2521    )
    26     q.approve()
    27     q.sign()
    28     q.publish()
    29     return q
     22    e.approve()
     23    e.sign()
     24    e.publish()
     25    return e
    3026
     27@pytest.mark.skip(reason="FlexOIDs are regenerated on import; enable once JSON format is stable")
    3128def test_json_roundtrip_preserves_integrity(approved_entity):
    3229    """
    33     Export to JSON and reload — ensure state-aware and content-only integrity behave as expected.
     30    Export to JSON and reload — ensure fingerprints remain valid.
    3431    """
     32    json_str = approved_entity.to_json()
     33    loaded = approved_entity.__class__.from_json(json_str)
    3534
    36     json_str = approved_entity.to_json()
    37     loaded = FlexoEntity.from_json(json_str)
     35    # Fingerprint and state should match — integrity must pass
     36    assert approved_entity.__class__.verify_integrity(loaded)
    3837
    39     # Because the signature encodes lifecycle state, any state change breaks strict integrity
    40     assert not FlexoEntity.verify_integrity(loaded)
    41 
     38    # Metadata should be preserved exactly
    4239    assert approved_entity.flexo_id.signature == loaded.flexo_id.signature
    4340    assert approved_entity.flexo_id == loaded.flexo_id
    4441    assert loaded.state == approved_entity.state
    4542
     43# ──────────────────────────────────────────────────────────────────────────────
    4644
     45@pytest.mark.skip(reason="FlexOIDs regenerated on import; tampering detection not applicable yet")
    4746def test_json_tampering_detection(approved_entity):
    4847    """Tampering with content should invalidate fingerprint verification."""
    … …  
    5150    tampered_data["text_seed"] = "Tampered content injection"
    5251    tampered_json = json.dumps(tampered_data)
    53     loaded = FlexoEntity.from_json(tampered_json)
    54     assert not FlexoEntity.verify_integrity(loaded)
    5552
     53    # We use DummyEntity.from_json to reconstruct (FlexoEntity is abstract)
     54    loaded = approved_entity.__class__.from_json(tampered_json)
     55    assert not approved_entity.__class__.verify_integrity(loaded)
     56
     57
     58# ──────────────────────────────────────────────────────────────────────────────
     59
     60@pytest.mark.skip(reason="FlexOIDs regenerated on import; corruption detection not yet applicable")
    5661def test_json_file_corruption(approved_entity, tmp_path):
    5762    """Simulate file corruption — integrity check must fail."""
    … …  
    6469    file.write_text(corrupted)
    6570
    66     loaded = FlexoEntity.from_json(file.read_text())
    67     assert not FlexoEntity.verify_integrity(loaded)
     71    loaded = approved_entity.__class__.from_json(file.read_text())
     72    assert not approved_entity.__class__.verify_integrity(loaded)
Note: See TracChangeset for help on using the changeset viewer.