Changeset 8aa20c7 in flexoentity for tests/conftest.py

Timestamp:

11/01/25 15:51:10 (2 months ago)

Author:

Enrico Schwass <ennoausberlin@…>

Branches:

master

Children:

5c72356

Parents:

ca39274

Message:

full refactoring of FlexOID

File:

• tests/conftest.py (modified) (1 diff)

tests/conftest.py

@@ -1 @@
-# tests/conftest.py
-
+# tests/stubs/single_choice_question.py
 import pytest
-import json
+from datetime import datetime
+from dataclasses import dataclass, field
+from typing import List
 from flexoentity import FlexoEntity, EntityType, EntityState, Domain
 
-import pytest
-import json
-from flexoentity import EntityType, EntityState, Domain
-from builder.questions import RadioQuestion, AnswerOption  # adjust path if different
-from builder.media_items import NullMediaItem  # adjust import if needed
+@pytest.fixture
+def fixed_datetime(monkeypatch):
+    class FixedDate(datetime):
+        @classmethod
+        def now(cls, tz=None):
+            return datetime(2025, 11, 1, tzinfo=tz)
+    monkeypatch.setattr("flexoentity.id_factory.datetime", FixedDate)
+    return FixedDate
 
 
-@pytest.fixture(scope="session")
-def domain():
-    """Provide a reusable domain for all entity tests."""
-    return Domain(
-        domain="SIG",
-        etype=EntityType.DOMAIN,
-        state=EntityState.DRAFT,
-        fullname="Signal Corps",
-        description="Questions related to communications and signaling systems.",
-        classification="RESTRICTED",
-        owner="test-suite"
-    )
+@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)
+        )
 
 
-@pytest.fixture
-def radio_question(domain):
-    """Return a simple RadioQuestion entity for testing FlexoEntity logic."""
-    q = RadioQuestion(
-        domain=domain,
-        etype=EntityType.QUESTION,
-        state=EntityState.DRAFT,
-        text="Which frequency band is used for shortwave communication?",
-        options=[
-            AnswerOption(id="opt1", text="HF (3–30 MHz)", points=1),
-            AnswerOption(id="opt2", text="VHF (30–300 MHz)", points=0),
-            AnswerOption(id="opt3", text="UHF (300–3000 MHz)", points=0),
-        ]
-    )
-    return q
+@dataclass
+class SingleChoiceQuestion(FlexoEntity):
+    """A minimal stub to test FlexoEntity integration."""
+    text: str = ""
+    options: List[AnswerOption] = field(default_factory=list)
 
 
-@pytest.fixture
-def serialized_question(radio_question):
-    """Provide the serialized JSON form for roundtrip tests."""
-    return radio_question.to_json()
+    @classmethod
+    def default(cls):
+        return cls(domain=Domain(domain="GEN",
+                                 entity_type=EntityType.DOMAIN,
+                                 state=EntityState.DRAFT),
+                   state=EntityState.DRAFT, entity_type=EntityType.ITEM)
 
+    def to_dict(self):
+        base = super().to_dict()
+        base.update({
+            "text": self.text,
+            "options": [opt.to_dict() for opt in self.options],
+        })
+        return base
+
+    @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
+        obj.domain = data.get("domain")
+        obj.entity_type = EntityType[data.get("etype")] if "etype" in data else EntityType.ITEM
+        obj.state = EntityState[data.get("state")] if "state" in data else EntityState.DRAFT
+        if "flexo_id" in data:
+            from flexoentity import FlexOID
+            obj.flexo_id = FlexOID.parsed(data["flexo_id"])
+        return obj
 
 @pytest.fixture
-def deserialized_question(serialized_question):
-    """Recreate a question from JSON for consistency tests."""
-    return RadioQuestion.from_json(serialized_question)
-
+def domain():
+    return Domain.default()
 
 @pytest.fixture
-def null_media():
-    """Provide a default NullMediaItem instance for media tests."""
-    return NullMediaItem(
-        domain=domain,
-        etype=EntityType.MEDIA,
-        state=EntityState.DRAFT
-    )
+def sample_question():
+    return SingleChoiceQuestion(domain=Domain.default(),
+                               text="What is 2 + 2?",
+                               options=[],
+                               entity_type=EntityType.ITEM,
+                               state=EntityState.DRAFT)