django-structured-metaobjects 1.0.0__py2.py3-none-any.whl

tests/test_models.py

@@ -0,0 +1,213 @@
+import pytest
+from django.core.exceptions import ValidationError
+from django.test.utils import override_settings
+
+from structured_metaobjects.compiler import _cache, clear_cache
+from structured_metaobjects.models import MetaInstance, MetaType
+from tests.app.test_module.models import Page
+
+
+@pytest.mark.django_db
+class TestMetaType:
+    def test_create(self):
+        mt = MetaType.objects.create(
+            name="Article",
+            schema=[{"name": "title", "kind": "string", "required": True}],
+        )
+        assert mt.pk is not None
+        assert str(mt) == "Article"
+
+    def test_save_clears_cache(self):
+        mt = MetaType.objects.create(
+            name="Cache Inv",
+            schema=[{"name": "x", "kind": "string"}],
+        )
+        mt.get_pydantic_model()
+        assert any(k[0] == mt.pk for k in _cache)
+        mt.name = "Updated"
+        mt.save()
+        assert not any(k[0] == mt.pk for k in _cache)
+
+    def test_get_pydantic_model(self):
+        mt = MetaType.objects.create(
+            name="PM",
+            schema=[{"name": "body", "kind": "string", "multiline": True}],
+        )
+        clear_cache()
+        model_cls = mt.get_pydantic_model()
+        assert hasattr(model_cls, "model_fields")
+
+    def test_get_json_schema(self):
+        mt = MetaType.objects.create(
+            name="JSON Schema",
+            schema=[{"name": "name", "kind": "string", "required": True}],
+        )
+        schema = mt.get_json_schema()
+        assert "properties" in schema
+
+
+@pytest.mark.django_db
+class TestMetaInstance:
+    def _make_type(self):
+        return MetaType.objects.create(
+            name="Inst Type",
+            schema=[
+                {"name": "title", "kind": "string", "required": True},
+                {"name": "count", "kind": "number", "integer": True},
+            ],
+        )
+
+    def test_create(self):
+        mt = self._make_type()
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={"title": "Hello", "count": 5},
+        )
+        assert mi.pk is not None
+
+    def test_str(self):
+        mt = self._make_type()
+        mi = MetaInstance.objects.create(
+            meta_type=mt, data={"title": "X"},
+        )
+        assert str(mi) == f"Inst Type #{mi.pk}"
+
+    def test_obj_property(self):
+        mt = self._make_type()
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={"title": "World", "count": 10},
+        )
+        obj = mi.obj
+        assert obj.title == "World"
+        assert obj.count == 10
+
+    def test_obj_caching(self):
+        mt = self._make_type()
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={"title": "Cached"},
+        )
+        obj1 = mi.obj
+        obj2 = mi.obj
+        assert obj1 is obj2
+
+    def test_obj_none_without_meta_type(self):
+        mi = MetaInstance()
+        assert mi.obj is None
+
+    def test_clean_valid_data(self):
+        mt = self._make_type()
+        mi = MetaInstance(meta_type=mt, data={"title": "Valid"})
+        mi.clean()
+        assert mi.data["title"] == "Valid"
+
+    def test_clean_invalid_data_raises(self):
+        mt = self._make_type()
+        mi = MetaInstance(meta_type=mt, data={"title": 123})
+        with pytest.raises(ValidationError):
+            mi.clean()
+
+    def test_clean_missing_required_raises(self):
+        mt = self._make_type()
+        mi = MetaInstance(meta_type=mt, data={})
+        with pytest.raises(ValidationError):
+            mi.clean()
+
+    def test_clean_normalizes_data(self):
+        mt = self._make_type()
+        mi = MetaInstance(meta_type=mt, data={"title": "Test", "count": "5"})
+        mi.clean()
+        assert mi.data["count"] == 5
+
+
+@pytest.mark.django_db
+class TestMetaInstanceCacheEngine:
+    """Verify that accessing ref/queryset fields on MetaInstance.obj uses
+    the structured-field CacheEngine, batch-fetching related objects
+    instead of issuing per-field queries."""
+
+    @pytest.fixture()
+    def pages(self):
+        return [
+            Page.objects.create(title="Page A", slug="page-a"),
+            Page.objects.create(title="Page B", slug="page-b"),
+            Page.objects.create(title="Page C", slug="page-c"),
+        ]
+
+    def test_fk_field_single_query(self, django_assert_num_queries, pages):
+        mt = MetaType.objects.create(
+            name="FK Test",
+            schema=[
+                {"name": "page", "kind": "ref", "target_model": "test_module.Page"},
+            ],
+        )
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={"page": pages[0].pk},
+        )
+        # Building obj should batch-fetch the FK in a single query
+        # (1 query for the cache engine to fetch all referenced Page PKs)
+        with django_assert_num_queries(1):
+            obj = mi.obj
+            assert obj.page.pk == pages[0].pk
+            assert obj.page.title == "Page A"
+
+    def test_queryset_field_single_query(self, django_assert_num_queries, pages):
+        mt = MetaType.objects.create(
+            name="QS Test",
+            schema=[
+                {"name": "pages", "kind": "queryset", "target_model": "test_module.Page"},
+            ],
+        )
+        pks = [p.pk for p in pages]
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={"pages": pks},
+        )
+        # Building obj should batch-fetch all QS PKs in a single query
+        with django_assert_num_queries(1):
+            obj = mi.obj
+            result_pks = [p.pk for p in obj.pages]
+            assert set(result_pks) == set(pks)
+
+    def test_mixed_fk_and_qs_fields(self, django_assert_num_queries, pages):
+        mt = MetaType.objects.create(
+            name="Mixed Test",
+            schema=[
+                {"name": "main_page", "kind": "ref", "target_model": "test_module.Page"},
+                {"name": "related_pages", "kind": "queryset", "target_model": "test_module.Page"},
+            ],
+        )
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={
+                "main_page": pages[0].pk,
+                "related_pages": [p.pk for p in pages[1:]],
+            },
+        )
+        # Both FK and QS point to the same model so the cache engine
+        # should resolve everything in a single batched query
+        with django_assert_num_queries(1):
+            obj = mi.obj
+            assert obj.main_page.pk == pages[0].pk
+            qs_pks = [p.pk for p in obj.related_pages]
+            assert set(qs_pks) == {pages[1].pk, pages[2].pk}
+
+    def test_obj_cache_no_extra_queries(self, django_assert_num_queries, pages):
+        mt = MetaType.objects.create(
+            name="Cache Hit",
+            schema=[
+                {"name": "page", "kind": "ref", "target_model": "test_module.Page"},
+            ],
+        )
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={"page": pages[0].pk},
+        )
+        # First access builds the cache
+        _ = mi.obj
+        # Second access should hit the instance cache — zero queries
+        with django_assert_num_queries(0):
+            obj = mi.obj
+            assert obj.page.pk == pages[0].pk

tests/test_schema_builder.py

@@ -0,0 +1,81 @@
+import pytest
+from structured_metaobjects.schema_builder import MetaFieldKind, MetaTypeFieldDef
+
+
+class TestMetaFieldKind:
+    def test_all_kinds_present(self):
+        expected = {
+            "string", "html", "number", "boolean",
+            "date", "datetime", "select", "ref", "queryset", "group", "list",
+        }
+        assert {k.value for k in MetaFieldKind} == expected
+
+    def test_kind_is_str_enum(self):
+        assert isinstance(MetaFieldKind.string, str)
+        assert MetaFieldKind.string == "string"
+
+
+class TestMetaTypeFieldDef:
+    def test_minimal_field(self):
+        fd = MetaTypeFieldDef(name="title")
+        assert fd.name == "title"
+        assert fd.kind == MetaFieldKind.string
+        assert fd.required is False
+        assert fd.translated is False
+        assert fd.target_model is None
+        assert fd.children == []
+
+    def test_ref_field(self):
+        fd = MetaTypeFieldDef(
+            name="page",
+            kind=MetaFieldKind.ref,
+            target_model="test_module.Page",
+        )
+        assert fd.kind == MetaFieldKind.ref
+        assert fd.target_model == "test_module.Page"
+
+    def test_group_with_children(self):
+        child = MetaTypeFieldDef(name="street", kind=MetaFieldKind.string)
+        fd = MetaTypeFieldDef(
+            name="address",
+            kind=MetaFieldKind.group,
+            children=[child],
+        )
+        assert len(fd.children) == 1
+        assert fd.children[0].name == "street"
+
+    def test_json_schema_has_conditional_logic(self):
+        schema = MetaTypeFieldDef.model_json_schema()
+        assert "if" in schema or "allOf" in schema or "$defs" in schema
+
+    def test_round_trip_dict(self):
+        data = {
+            "name": "bio",
+            "label": "Biography",
+            "kind": "string",
+            "multiline": True,
+            "required": True,
+            "translated": True,
+        }
+        fd = MetaTypeFieldDef.model_validate(data)
+        dumped = fd.model_dump(mode="json")
+        assert dumped["name"] == "bio"
+        assert dumped["kind"] == "string"
+        assert dumped["translated"] is True
+
+    def test_recursive_children(self):
+        data = {
+            "name": "section",
+            "kind": "group",
+            "children": [
+                {
+                    "name": "subsection",
+                    "kind": "group",
+                    "children": [
+                        {"name": "title", "kind": "string"},
+                    ],
+                }
+            ],
+        }
+        fd = MetaTypeFieldDef.model_validate(data)
+        assert fd.children[0].children[0].name == "title"

tests/test_serializers.py

@@ -0,0 +1,79 @@
+import pytest
+
+from structured_metaobjects.models import MetaInstance, MetaType
+from structured_metaobjects.serializers import (
+    MetaInstanceSerializer,
+    MetaTypeSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestMetaTypeSerializer:
+    def test_serialize(self):
+        mt = MetaType.objects.create(
+            name="Ser",
+            schema=[{"name": "title", "kind": "string"}],
+        )
+        data = MetaTypeSerializer(mt).data
+        assert data["name"] == "Ser"
+        assert isinstance(data["schema"], list)
+
+    def test_deserialize(self):
+        payload = {
+            "name": "New Type",
+            "schema": [{"name": "body", "kind": "string", "multiline": True}],
+        }
+        s = MetaTypeSerializer(data=payload)
+        assert s.is_valid(), s.errors
+        mt = s.save()
+        assert mt.pk is not None
+
+
+@pytest.mark.django_db
+class TestMetaInstanceSerializer:
+    def _make_type(self):
+        return MetaType.objects.create(
+            name="MI Ser",
+            schema=[
+                {"name": "title", "kind": "string", "required": True},
+            ],
+        )
+
+    def test_valid_create(self):
+        mt = self._make_type()
+        payload = {
+            "meta_type": mt.pk,
+            "data": {"title": "Hello"},
+        }
+        s = MetaInstanceSerializer(data=payload)
+        assert s.is_valid(), s.errors
+        mi = s.save()
+        assert mi.data["title"] == "Hello"
+
+    def test_invalid_data_rejected(self):
+        mt = self._make_type()
+        payload = {
+            "meta_type": mt.pk,
+            "data": {},
+        }
+        s = MetaInstanceSerializer(data=payload)
+        assert not s.is_valid()
+        assert "data" in s.errors
+
+    def test_missing_meta_type_rejected(self):
+        payload = {
+            "data": {"title": "No type"},
+        }
+        s = MetaInstanceSerializer(data=payload)
+        assert not s.is_valid()
+
+    def test_update_existing(self):
+        mt = self._make_type()
+        mi = MetaInstance.objects.create(
+            meta_type=mt,
+            data={"title": "Old"},
+        )
+        s = MetaInstanceSerializer(mi, data={"data": {"title": "New"}}, partial=True)
+        assert s.is_valid(), s.errors
+        updated = s.save()
+        assert updated.data["title"] == "New"

tests/test_views.py

@@ -0,0 +1,120 @@
+import pytest
+from rest_framework.test import APIClient
+
+from structured_metaobjects.models import MetaInstance, MetaType
+
+
+@pytest.fixture
+def api_client():
+    return APIClient()
+
+
+@pytest.mark.django_db
+class TestMetaTypeViewSet:
+    def _url(self, pk=None):
+        if pk:
+            return f"/api/meta-types/{pk}/"
+        return "/api/meta-types/"
+
+    def test_list(self, api_client):
+        MetaType.objects.create(name="V1", schema=[])
+        resp = api_client.get(self._url())
+        assert resp.status_code == 200
+        assert len(resp.data) >= 1
+
+    def test_create(self, api_client):
+        resp = api_client.post(
+            self._url(),
+            {"name": "V2", "schema": [{"name": "x", "kind": "string"}]},
+            format="json",
+        )
+        assert resp.status_code == 201
+        assert resp.data["name"] == "V2"
+
+    def test_retrieve(self, api_client):
+        mt = MetaType.objects.create(name="V3", schema=[])
+        resp = api_client.get(self._url(mt.pk))
+        assert resp.status_code == 200
+        assert resp.data["name"] == "V3"
+
+    def test_update(self, api_client):
+        mt = MetaType.objects.create(name="V4", schema=[])
+        resp = api_client.patch(
+            self._url(mt.pk),
+            {"name": "V4 Updated"},
+            format="json",
+        )
+        assert resp.status_code == 200
+        assert resp.data["name"] == "V4 Updated"
+
+    def test_delete(self, api_client):
+        mt = MetaType.objects.create(name="V5", schema=[])
+        resp = api_client.delete(self._url(mt.pk))
+        assert resp.status_code == 204
+
+    def test_schema_action(self, api_client):
+        mt = MetaType.objects.create(
+            name="V6",
+            schema=[{"name": "title", "kind": "string", "required": True}],
+        )
+        resp = api_client.get(f"/api/meta-types/{mt.pk}/schema/")
+        assert resp.status_code == 200
+        assert "properties" in resp.data
+
+
+@pytest.mark.django_db
+class TestMetaInstanceViewSet:
+    def _url(self, pk=None):
+        if pk:
+            return f"/api/meta-instances/{pk}/"
+        return "/api/meta-instances/"
+
+    def _make_type(self):
+        return MetaType.objects.create(
+            name="VI",
+            schema=[{"name": "title", "kind": "string", "required": True}],
+        )
+
+    def test_list(self, api_client):
+        mt = self._make_type()
+        MetaInstance.objects.create(meta_type=mt, data={"title": "A"})
+        resp = api_client.get(self._url())
+        assert resp.status_code == 200
+
+    def test_create(self, api_client):
+        mt = self._make_type()
+        resp = api_client.post(
+            self._url(),
+            {"meta_type": mt.pk, "data": {"title": "New"}},
+            format="json",
+        )
+        assert resp.status_code == 201
+
+    def test_create_invalid_data(self, api_client):
+        mt = self._make_type()
+        resp = api_client.post(
+            self._url(),
+            {"meta_type": mt.pk, "data": {}},
+            format="json",
+        )
+        assert resp.status_code == 400
+
+    def test_retrieve(self, api_client):
+        mt = self._make_type()
+        mi = MetaInstance.objects.create(meta_type=mt, data={"title": "R"})
+        resp = api_client.get(self._url(mi.pk))
+        assert resp.status_code == 200
+
+    def test_schema_action(self, api_client):
+        mt = self._make_type()
+        resp = api_client.get(f"/api/meta-instances/schema/?meta_type={mt.pk}")
+        assert resp.status_code == 200
+        assert "properties" in resp.data
+
+    def test_schema_action_missing_param(self, api_client):
+        resp = api_client.get("/api/meta-instances/schema/")
+        assert resp.status_code == 400
+
+    def test_schema_action_not_found(self, api_client):
+        resp = api_client.get("/api/meta-instances/schema/?meta_type=99999")
+        assert resp.status_code == 404