Changeset 6ad031b in flexoentity


Ignore:
Timestamp:
11/18/25 13:34:13 (2 months ago)
Author:
Enrico Schwass <ennoausberlin@…>
Branches:
master
Children:
8840db7
Parents:
4dc09bb
Message:

another round of domain refactoring

Files:
3 added
6 edited

Legend:

Unmodified
Added
Removed

  • flexoentity/domain.py

    r4dc09bb r6ad031b  
     1from uuid import UUID
    12from dataclasses import dataclass
    23from flexoentity import FlexOID, FlexoEntity, EntityType, EntityState
    3 
    44
    55@dataclass
    … …  
    99    domain abbreviation in FlexOID, doing mapping and management
    1010    """
     11
    1112    ENTITY_TYPE = EntityType.DOMAIN
    12     subtype = "GENERAL"
     13
    1314    fullname: str = ""
    1415    description: str = ""
    … …  
    1718    @classmethod
    1819    def default(cls):
    19         """I return an default instance of myself"""
    20         return cls("GENERIC")
     20        """Return the default domain object."""
     21        return cls(fullname="Generic Domain", classification="UNCLASSIFIED")
    2122
    2223    def __post_init__(self):
    2324        super().__post_init__()
    24 
    25         # Generate FlexOID only if missing
     25        # Create a FlexOID only if none was restored
    2626        if not getattr(self, "flexo_id", None):
    2727            self.flexo_id = FlexOID.safe_generate(
    28                 domain="GENERAL",
    29                 entity_type=EntityType.DOMAIN.value,   # 'D'
    30                 estate=EntityState.DRAFT.value,      # 'D'
    31                 text=self.text_seed,
     28                domain_id=self.domain_id,
     29                entity_type=self.ENTITY_TYPE.value,   # "D"
     30                state=EntityState.DRAFT.value,       # "D"
     31                text=self.domain_id,                       # seed must be stable
    3232                version=1,
    3333            )
    … …  
    3535    @property
    3636    def text_seed(self) -> str:
    37         """
    38         I provide a deterministic text seed for ID generation.
    39         FIXME: There might be a better text seed, json probably
    40         """
    41         return f"{self.fullname}|{self.classification}|{self.owner_id}"
    42 
    43     @property
    44     def domain_code(self) -> str:
    45         """
    46         I am self-domaining — I use my own subtype as domain code.
    47         """
    48         return self.subtype or "GENERAL"
     37        return self.domain_id
    4938
    5039    def to_dict(self):
    51         """I return a dictionary representing my state"""
    5240        base = super().to_dict()
    5341        base.update({
     42            "domain_id": self.domain_id,
    5443            "fullname": self.fullname,
    5544            "description": self.description,
    … …  
    6049    @classmethod
    6150    def from_dict(cls, data):
    62         """I return a new instance of myself, created from state provided by a dictionary"""
    63         return cls(
     51        # Must have flexo_id
     52        if "flexo_id" not in data:
     53            raise ValueError("Domain serialization missing 'flexo_id'.")
     54
     55        flexo_id = FlexOID(data["flexo_id"])
     56
     57        print("Data:", data)
     58        obj = cls(
    6459            fullname=data.get("fullname", ""),
    6560            description=data.get("description", ""),
    6661            classification=data.get("classification", "UNCLASSIFIED"),
     62            flexo_id=flexo_id,
    6763        )
     64
     65        # Restore metadata
     66        obj.origin = data.get("origin")
     67        obj.fingerprint = data.get("fingerprint", "")
     68        obj.originator_id = (
     69            UUID(data["originator_id"]) if data.get("originator_id") else None
     70        )
     71        obj.owner_id = (
     72            UUID(data["owner_id"]) if data.get("owner_id") else None
     73        )
     74
     75        return obj

  • flexoentity/flexo_entity.py

    r4dc09bb r6ad031b  
    1111- My `flexo_id` is the canonical source of truth.
    1212  It deterministically encodes:
    13     - domain      (prefix)
    1413    - entity type (single letter, e.g. I, C, M)
    1514    - date + hash (prefix stability)
    … …  
    2524    - originator_id identifies the original creator (UUID)
    2625    - owner_id identifies the current responsible user or process (UUID)
    27 
    28 - My domain field is a semantic hint, useful for filtering or
    29   multi-tenant setups, but the canonical domain remains encoded in my ID.
    3026
    3127Design principles
    … …  
    144140    I am the living, editable layer that connects identity with accountability.
    145141    """
    146 
    147142    subtype: str = "GENERIC"
    148143    flexo_id: Optional[FlexOID] = field(default=None)
    … …  
    165160
    166161    @property
     162    def domain_id(self):
     163        """I return my domain_id derived from FlexOID"""
     164        return self.flexo_id.domain_id
     165
     166    @property
    167167    def state(self) -> EntityState:
    168168        """I return the state derived from my FlexOID"""
    … …  
    187187        raise NotImplementedError("Subclasses must implement default()")
    188188
    189     @property
    190     def domain_code(self):
    191         return self.flexo_id.domain
    192 
    193     @property
    194     def default_domain_code(self):
    195         return "GENERAL"
    196 
    197189    @classmethod
    198     def with_domain(cls, domain, **kwargs):
    199         """
    200         I create an entity in a specific domain.
    201         """
    202 
    203         etype = getattr(cls, "ENTITY_TYPE", None)
    204         if not etype:
     190    def with_domain_id(cls, domain_id: str, **kwargs):
     191        from .domain_manager import DomainManager
     192        entity_type = getattr(cls, "ENTITY_TYPE", None)
     193        if not entity_type:
    205194            raise ValueError(f"{cls.__name__} must define ENTITY_TYPE")
    206195
     196        DomainManager.get_or_create(domain_id)  # ensure registered
     197
    207198        flexo_id = FlexOID.safe_generate(
    208             domain=domain,
    209             entity_type=etype.value,
    210             estate=EntityState.DRAFT.value,
     199            domain_id=domain_id,
     200            entity_type=entity_type.value,
     201            state="D",
    211202            text=kwargs.get("text_seed", ""),
    212203            version=1,
    … …  
    219210    def __post_init__(self):
    220211        """
    221         Optionally generate a new FlexOID and fingerprint if none exist.
    222 
    223         I check for subclass attribute ENTITY_TYPE.
    224         If it exist, I use it to generate a draft FlexOID.
    225         Otherwise, I skip ID generation — leaving it to the subclass.
    226         """
    227 
    228         # If already has a FlexOID, do nothing
    229         if getattr(self, "flexo_id", None):
     212        FINAL LOGIC:
     213            - If flexo_id exists → restore domain_id via DomainManager.
     214            - If flexo_id missing → create via safe_generate.
     215            - Domain must always match flexo_id.domain.
     216        """
     217
     218        # Step 1: If flexo_id exists, restore canonical domain
     219        if self.flexo_id:
    230220            return
    231 
    232         # Skip if subclass doesn’t declare ENTITY_TYPE or initial state
    233         etype = getattr(self.__class__, "ENTITY_TYPE", None)
    234         if not etype:
    235             # No info available, do nothing
    236             return
    237 
    238         # Generate a new draft FlexOID
     221        # Step 2: flexo_id missing → generate one
     222        entity_type = getattr(self.__class__, "ENTITY_TYPE", None)
     223        if not entity_type:
     224            raise ValueError(f"{self.__class__.__name__} must define ENTITY_TYPE")
     225
     226        if not self.domain_id:
     227            raise ValueError(
     228                f"{self.__class__.__name__} created without domain; "
     229                f"use {self.__class__.__name__}.with_domain(domain=...) or pass domain explicitly."
     230            )
     231
     232        # Create identity
    239233        self.flexo_id = FlexOID.safe_generate(
    240             domain=self.default_domain_code,
    241             entity_type=etype.value,
    242             estate=EntityState.DRAFT.value,
     234            domain_id=self.domain_id,
     235            entity_type=entity_type.value,
     236            state=EntityState.DRAFT.value,
    243237            text=self.text_seed,
    244238            version=1,
    … …  
    255249
    256250    def to_dict(self):
     251        """I return the a dictionary representation of myself"""
    257252        return {
    258             "domain": self.domain_code,
    259             "entity_type": self.entity_type.name,
    260             "state": self.state.name,
    261253            "flexo_id": str(self.flexo_id),
     254            "domain_id": self.domain_id,
    262255            "fingerprint": self.fingerprint,
    263256            "origin": self.origin,
    264257            "originator_id": str(self.originator_id),
    265             "owner_id": str(self.owner_id)
     258            "owner_id": str(self.owner_id),
    266259        }
    267260
    268261    @classmethod
    269262    def from_dict(cls, data):
    270         from flexoentity.domain import Domain  # avoid circular import
    271         domain_obj = Domain(data.get("domain", "GENERIC"))
     263        """
     264        FINAL VERSION:
     265        - NEVER generates a new FlexOID.
     266        - NEVER calls with_domain().
     267        - ALWAYS restores the canonical Domain via DomainManager.
     268        """
     269        if "flexo_id" not in data:
     270            raise ValueError("Serialized entity must include 'flexo_id'.")
     271
     272        flexo_id = FlexOID(data["flexo_id"])
     273
     274        # canonical domain object
     275
    272276        obj = cls(
    273             domain=domain_obj,
    274         )
    275         obj.flexo_id = FlexOID(data["flexo_id"])
     277            flexo_id=flexo_id,
     278        )
     279
     280        # restore provenance
    276281        obj.fingerprint = data.get("fingerprint", "")
    277282        obj.origin = data.get("origin")
    278         obj.originator_id = UUID(int=int(data.get("originator_id", "0")))
    279         obj.owner_id = UUID(int=int(data.get("owner_id", "0")))
     283
     284        if data.get("originator_id"):
     285            obj.originator_id = UUID(data["originator_id"])
     286
     287        if data.get("owner_id"):
     288            obj.owner_id = UUID(data["owner_id"])
     289
    280290        return obj
    281291
    … …  
    320330        if new_fp != self.fingerprint:
    321331            self.fingerprint = new_fp
    322             self.flexo_id = FlexOID.safe_generate(self.domain_code,
     332            self.flexo_id = FlexOID.safe_generate(self.domain_id,
    323333                                                  self.entity_type.value,
    324334                                                  self.state.value,
    … …  
    385395        """
    386396        if self.state == EntityState.DRAFT:
    387             new_fid = FlexOID.safe_generate(self.domain_code,
     397            new_fid = FlexOID.safe_generate(self.domain_id,
    388398                                            self.entity_type.value,
    389399                                            EntityState.APPROVED.value,
    … …  
    424434
    425435        new_fid = FlexOID.safe_generate(
    426             self.domain_code,
     436            self.domain_id,
    427437            self.entity_type.value,
    428438            EntityState.PUBLISHED.value,
    … …  
    436446
    437447    def obsolete(self):
     448        """I mark myself as obsolete"""
    438449        allowed = self.allowed_transitions()
    439450        if "OBSOLETE" not in allowed:
    … …  
    450461        self.origin = str(self.flexo_id)
    451462        self.flexo_id = FlexOID.clone_new_base(
    452             self.domain_code,
     463            self.domain_id,
    453464            self.entity_type.value,
    454465            EntityState.DRAFT.value,
    … …  
    461472    # ───────────────────────────────────────────────────────────────
    462473    @staticmethod
    463     def debug_integrity(entity):
    464         """
    465         Return a dict with all values used by verify_integrity so we can see
    466         exactly why a check passes/fails.
    467         """
    468         info = {}
    469         try:
    470             fid = entity.flexo_id
    471             info["fid"] = str(fid)
    472             info["fid_domain"] = fid.domain
    473             info["fid_type"] = fid.entity_type
    474             info["fid_state"] = fid.state_code
    475             info["fid_hash_part"] = fid.hash_part
    476             info["version"] = fid.version
    477 
    478             # Derived views
    479             info["derived_domain_code"] = getattr(entity, "domain_code")() if hasattr(entity, "domain_code") else None
    480             info["derived_entity_type_value"] = entity.entity_type.value
    481             info["derived_state_value"] = entity.state.value
    482 
    483             # Seeds & fingerprints
    484             info["text_seed"] = entity.text_seed
    485             exp_fp = entity._compute_fingerprint()
    486             info["expected_fingerprint"] = exp_fp
    487             info["stored_fingerprint"] = getattr(entity, "fingerprint", None)
    488 
    489             # Expected ID hash from current seed (should match fid.hash_part
    490             # if content didn't change)
    491             exp_hash = FlexOID._blake_hash(canonical_seed(f"{fid.domain}:{fid.entity_type}:{entity.text_seed}"))
    492             info["expected_id_hash_from_seed"] = exp_hash
    493 
    494             # Quick mismatches
    495             info["mismatch_fp"] = (info["stored_fingerprint"] != exp_fp)
    496             info["mismatch_hash"] = (fid.hash_part != exp_hash)
    497             info["mismatch_type"] = (entity.entity_type.value != fid.entity_type)
    498             info["mismatch_state"] = (entity.state.value != fid.state_code)
    499             info["mismatch_domain"] = (info["derived_domain_code"] is not None and info["derived_domain_code"] != fid.domain)
    500         except Exception as e:
    501             info["error"] = repr(e)
    502         return info
    503 
    504     @staticmethod
    505474    def verify_integrity(entity) -> bool:
    506475        """
    … …  
    517486
    518487            # Validate domain and ID coherence
    519             if entity.domain_code != entity.flexo_id.domain:
     488            if entity.domain_id != entity.flexo_id.domain_id:
    520489                return False
    521490            if entity.entity_type.value != entity.flexo_id.entity_type:

  • flexoentity/id_factory.py

    r4dc09bb r6ad031b  
    88Each Flex-O ID (FlexOID) is a self-contained string that encodes:
    99
    10     <DOMAIN>-<ETYPE><YYMMDD>-<HASH>@<VERSION><STATE>
     10    <DOMAIN_ID>-<ENTITY_TYPE><YYMMDD>-<HASH>@<VERSION><STATE>
    1111
    1212Example:
    … …  
    1414
    1515where
    16     DOMAIN      — a short prefix identifying the origin domain (e.g., GEN)
    17     ETYPE       — a compact entity type code (e.g., ITEM)
     16    DOMAIN_ID   — a prefix identifying the origin domain (e.g., PY_ARITHM)
     17    ENTITY_TYPE — a compact entity type single letter code (e.g., "I" for ITEM)
    1818    YYMMDD      — the UTC creation date
    1919    HASH        — a 12-hex BLAKE2s digest derived from canonical content
    … …  
    5656
    5757• Validation:  Every FlexOID validates itself through a strict regex pattern
    58                and exposes lightweight accessors (domain, type, date, hash,
     58               and exposes lightweight accessors (domain_id, type, date, hash,
    5959               version, state).
    6060
    … …  
    114114
    115115    OID_PATTERN = re.compile(
    116         r"^(?P<domain>[A-Z0-9_]+)-"
    117         r"(?P<etype>[A-Z0-9]+)"
     116        r"^(?P<domain_id>[A-Z0-9_]+)-"
     117        r"(?P<entity_type>[A-Z0-9]+)"
    118118        r"(?P<date>\d{6})-"
    119119        r"(?P<hash>[A-F0-9]+)@"
    … …  
    121121        r"(?P<state>[A-Z])$"
    122122    )
     123    @classmethod
     124    def from_strings(cls, domain_id, entity_type, date, hash_part, version, state):
     125        """
     126        Construct a FlexOID from raw string components only.
     127        All parameters must already be strings in the exact expected format.
     128        No coercions, no guesses, no defaults.
     129
     130        Required formats:
     131           domain_id:    [A-Z0-9_]+
     132           entity_type:  [A-Z]
     133           date:         YYMMDD (6 digits)
     134           hash_part:    uppercase hex, length >= 1
     135           version:      001..999 as 3-digit string
     136           state:        single capital letter
     137        """
     138
     139        # Domain format
     140        if not isinstance(domain_id, str) or not re.fullmatch(r"[A-Z0-9_]+", domain_id):
     141            raise ValueError(f"Invalid domain_id string: {domain_id}")
     142
     143        # Entity type format
     144        if not isinstance(entity_type, str) or not re.fullmatch(r"[A-Z]", entity_type):
     145            raise ValueError(f"Invalid entity_type string: {entity_type}")
     146
     147        # Date format
     148        if not isinstance(date, str) or not re.fullmatch(r"\d{6}", date):
     149            raise ValueError(f"Invalid date string: {date}")
     150
     151        # Hash format
     152        if not isinstance(hash_part, str) or not re.fullmatch(r"[A-F0-9]+", hash_part):
     153            raise ValueError(f"Invalid hash string: {hash_part}")
     154
     155        # Version
     156        if not isinstance(version, str) or not re.fullmatch(r"\d{3}", version):
     157            raise ValueError(f"Invalid version string: {version}")
     158
     159        version_int = int(version)
     160        if not (1 <= version_int <= cls.MAX_VERSION):
     161            raise ValueError(f"Version {version} out of range.")
     162
     163        # State
     164        if not isinstance(state, str) or not re.fullmatch(r"[A-Z]", state):
     165            raise ValueError(f"Invalid state: {state}")
     166
     167        oid_str = f"{domain_id}-{entity_type}{date}-{hash_part}@{version}{state}"
     168        return cls(oid_str)
     169
     170    @classmethod
     171    def from_dict(cls, d):
     172        try:
     173            return cls.from_strings(
     174                domain_id=d["domain_id"],
     175                entity_type=d["entity_type"],
     176                date=d["date"],
     177                hash_part=d["hash"],
     178                version=d["version"],
     179                state=d["state"],
     180            )
     181        except KeyError as e:
     182            raise ValueError(f"Missing required FlexOID field: {e}")
    123183
    124184    def __new__(cls, value: str):
    … …  
    139199    # ───────────────────────────────────────────
    140200    @property
    141     def domain(self) -> str:
    142         """I answer the domain prefix (e.g., 'GEN')."""
    143         return self._m.group("domain")
     201    def domain_id(self) -> str:
     202        """I answer the domain prefix (e.g., 'PY_ARITH')."""
     203        return self._m.group("domain_id")
    144204
    145205    @property
    146206    def entity_type(self) -> str:
    147207        """I answer the short entity-type code (e.g., 'ITEM')."""
    148         return self._m.group("etype")
     208        return self._m.group("entity_type")
    149209
    150210    @property
    … …  
    209269
    210270    @staticmethod
    211     def generate(domain: str, entity_type: str, estate: str, text: str, version: int = 1):
     271    def generate(domain: str, entity_type: str, state: str, text: str, version: int = 1):
    212272        """
    213273        I create a new deterministic Flex-O ID.
    … …  
    220280            raise ValueError(f"Version {version} exceeds limit; mark obsolete.")
    221281
    222         if not (isinstance(estate, str) and len(estate) == 1 and estate.isalpha()):
    223             raise ValueError("estate must be a single capital letter.")
     282        if not (isinstance(state, str) and len(state) == 1 and state.isalpha()):
     283            raise ValueError("state must be a single capital letter.")
    224284
    225285        date_part = datetime.now(timezone.utc).strftime("%y%m%d")
    226286        hash_seed = canonical_seed(f"{domain}:{entity_type}:{canonical_seed(text)}")
    227287        base_hash = FlexOID._blake_hash(hash_seed)
    228         return FlexOID(f"{domain}-{entity_type}{date_part}-{base_hash}@{version:03d}{estate}")
     288        return FlexOID(f"{domain}-{entity_type}{date_part}-{base_hash}@{version:03d}{state}")
    229289
    230290    @staticmethod
    231     def safe_generate(domain, entity_type, estate, text, version=1, repo=None):
     291    def safe_generate(domain_id, entity_type, state, text, version=1, repo=None):
    232292        """
    233293        I create a new deterministic ID like `generate`,
    … …  
    237297        I deterministically salt my seed and regenerate a unique ID.
    238298        """
    239         domain_code = getattr(domain, "domain", domain)
    240         oid = FlexOID.generate(domain_code, entity_type, estate, text, version=version)
     299        oid = FlexOID.generate(domain_id, entity_type, state, text, version=version)
    241300
    242301        if repo is None:
    … …  
    261320        salt = secrets.token_hex(1)
    262321        salted_text = f"{text}|salt:{salt}"
    263         return FlexOID.generate(domain_code, entity_type, estate, salted_text, version=version)
     322        return FlexOID.generate(domain_id, entity_type, state, salted_text, version=version)
    264323
    265324    @classmethod
    … …  
    270329        """
    271330        new_ver = oid.version + 1
    272         if new_ver > cls.WARN_THRESHOLD and new_ver < cls.MAX_VERSION:
     331        if cls.WARN_THRESHOLD < new_ver < cls.MAX_VERSION:
    273332            logger.warning(f"{oid} approaching obsolescence ({new_ver}/999).")
    274333        if new_ver > cls.MAX_VERSION:
    … …  
    287346
    288347    @staticmethod
    289     def clone_new_base(domain: str, entity_type: str, estate: str, text: str) -> "FlexOID":
     348    def clone_new_base(domain: str, entity_type: str, state: str, text: str) -> "FlexOID":
    290349        """
    291350        I start a completely new lineage (version 1) for a derived entity.
    … …  
    293352        not share version history with its origin.
    294353        """
    295         return FlexOID.safe_generate(domain, entity_type, estate, text, version=1)
     354        return FlexOID.safe_generate(domain, entity_type, state, text, version=1)
    296355
    297356    def parsed(self) -> dict:
    … …  
    301360        """
    302361        return {
    303             "domain": self.domain,
     362            "domain_id": self.domain_id,
    304363            "entity_type": self.entity_type,
    305364            "date": self.date,

  • tests/conftest.py

    r4dc09bb r6ad031b  
    4646        if not getattr(self, "flexo_id", None):
    4747            self.flexo_id = FlexOID.safe_generate(
    48                 domain=self.default_domain_code,
     48                domain=self.domain_id,
    4949                entity_type=SingleChoiceQuestion.ENTITY_TYPE.value,     # 'I'
    5050                estate=EntityState.DRAFT.value,        # 'D'
    … …  
    8686
    8787@pytest.fixture
    88 def domain():
    89     return Domain.default()
     88def sample_domain():
     89    domain_id = "PY_ARITHM"
     90    flexo_id = FlexOID.safe_generate(domain_id=domain_id,
     91                                     entity_type=EntityType.DOMAIN.value,
     92                                     state=EntityState.DRAFT.value, text=domain_id)
     93    return Domain(flexo_id=flexo_id, fullname="PYTHON_ARITHMETIC",
     94                  description="ALL ABOUT ARITHMETIC IN PYTHON")
    9095
    9196@pytest.fixture
    92 def sample_question():
    93     q = SingleChoiceQuestion(text="What is 2 + 2?",
     97def sample_question(sample_domain):
     98    flexo_id = FlexOID.safe_generate(domain_id=sample_domain.domain_id,
     99                                     entity_type=EntityType.ITEM.value,
     100                                     state=EntityState.DRAFT.value,
     101                                     text="What is 2 + 2")
     102    q = SingleChoiceQuestion(flexo_id=flexo_id, text="What is 2 + 2?",
    94103                             options=[])
    95104    q._update_fingerprint()

  • tests/test_flexoid.py

    r4dc09bb r6ad031b  
    2525    fid = FlexOID("GEN-I251101-ABCDEF123456@001D")
    2626    assert isinstance(fid, str)
    27     assert fid.domain == "GEN"
     27    assert fid.domain_id == "GEN"
    2828    assert fid.entity_type == "I"
    2929    assert fid.date_str == "251101"
    … …  
    5858    assert fid1 == fid2  # deterministic
    5959    assert fid1.hash_part == fid2.hash_part
    60     assert fid1.domain == "GEN"
     60    assert fid1.domain_id == "GEN"
    6161    assert fid1.entity_type == "I"
    6262
    … …  
    135135    fid = FlexOID("GEN-I251101-ABCDEF123456@007S")
    136136    data = fid.parsed()
    137     assert data["domain"] == "GEN"
     137    assert data["domain_id"] == "GEN"
    138138    assert data["entity_type"] == "I"
    139139    assert data["version"] == 7

  • tests/test_id_stress.py

    r4dc09bb r6ad031b  
    1414logger = logging.getLogger(__name__)
    1515
    16 def test_bulk_generation_uniqueness(domain):
     16def test_bulk_generation_uniqueness(sample_domain):
    1717    """
    1818    Generate 100,000 IDs and ensure uniqueness using safe_generate().
    … …  
    3333    ids = []
    3434    for seed in seeds:
    35         oid = FlexOID.safe_generate(domain.domain_code, entity_type.value, estate.value, seed, repo=repo)
     35        oid = FlexOID.safe_generate(sample_domain.domain_id, entity_type.value,
     36                                    estate.value, seed, repo=repo)
    3637        assert isinstance(oid, FlexOID)
    3738        ids.append(str(oid))
    … …  
    4849
    4950    # Sanity check: IDs should look canonical
    50     assert all(id_str.startswith("GEN") for id_str in ids)
     51    # assert all(id_str.startswith("GENERIC") for id_str in ids)
    5152    assert all("@" in id_str for id_str in ids)
    5253
    53 def test_id_generation_is_deterministic(domain):
     54def test_id_generation_is_deterministic(sample_domain):
    5455    """
    5556    Generating the same entity twice with same inputs yields identical ID.
    … …  
    6061    text = "identical question text"
    6162
    62     id1 = FlexOID.generate(domain.domain_code, entity_type.value, estate.value, text)
    63     id2 = FlexOID.generate(domain.domain_code, entity_type.value, estate.value, text)
     63    id1 = FlexOID.generate(sample_domain.domain_id, entity_type.value, estate.value, text)
     64    id2 = FlexOID.generate(sample_domain.domain_id, entity_type.value, estate.value, text)
    6465    # IDs must be identical because generation is deterministic
    6566    assert id1 == id2
    66 
    67 
    68 # def test_id_reproducibility_across_runs(domain):
    69 #     """
    70 #     The same seed on a new process (fresh _seen_hashes)
    71 #     should yield the same base ID (without suffix).
    72 #     """
    73 #     entity_type = EntityType.CATALOG
    74 #     estate = EntityState.DRAFT
    75 #     seed = "reproducibility test seed"
    76 
    77 #     id1 = FlexOID.generate(domain.domain_code, entity_type.value, estate.value, seed)
    78 #     FlexOID._seen_hashes.clear()
    79 #     id2 = FlexOID.generate(domain.domain_code, entity_type.value, estate.value, seed)
    80 
    81 #     assert id1 == id2
    8267
    8368
Note: See TracChangeset for help on using the changeset viewer.