workpeg 0.3.2__tar.gz → 0.4.0__tar.gz

{workpeg-0.3.2/src/workpeg.egg-info → workpeg-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.3.2
+Version: 0.4.0
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.3.2 → workpeg-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "workpeg"
-version = "0.3.2"
+version = "0.4.0"
 description = "Workpeg function runtime and SDK"
 readme = "README.md"
 requires-python = ">=3.10"

workpeg-0.4.0/src/workpeg/context.py

@@ -0,0 +1,134 @@
+import re
+
+
+UUID_REGEX = re.compile(
+    r"^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-"
+    r"[89ab][a-f0-9]{3}-[a-f0-9]{12}$",
+    re.IGNORECASE,
+)
+
+
+class BaseContext:
+    @staticmethod
+    def verify(data):
+        raise NotImplementedError("Context must implement verify().")
+
+
+class _TableContext(BaseContext):
+    REQUIRED_FIELDS = {
+        "uuid",
+        "name",
+        "owner_id",
+        "metadata",
+        "columns",
+        "namespace",
+        "peg",
+    }
+
+    @classmethod
+    def verify(cls, data):
+        if data is None:
+            return True
+
+        cls._verify_keys(data)
+        cls._verify_uuid_format(data["uuid"])
+        cls._verify_owner_id(data["owner_id"])
+        cls._verify_columns(data["columns"])
+        cls._verify_namespace(data["namespace"])
+        cls._verify_peg(data["peg"])
+
+        return True
+
+    @classmethod
+    def _verify_keys(cls, data):
+        if not isinstance(data, dict):
+            raise ValueError("Data must be a dictionary.")
+
+        missing = cls.REQUIRED_FIELDS - data.keys()
+        if missing:
+            raise ValueError(f"Missing required fields: {missing}")
+
+    @classmethod
+    def _verify_uuid_format(cls, uuid_str):
+        if not isinstance(uuid_str, str) or not UUID_REGEX.match(uuid_str):
+            raise ValueError("Invalid UUID format.")
+
+    @classmethod
+    def _verify_owner_id(cls, owner_id):
+        if owner_id is not None and (
+            not isinstance(owner_id, int) or owner_id <= 0
+        ):
+            raise ValueError("Owner ID must be a positive integer or None.")
+
+    @classmethod
+    def _verify_columns(cls, columns):
+        return True  # TODO
+
+    @classmethod
+    def _verify_namespace(cls, namespace):
+        if namespace is not None and not isinstance(namespace, str):
+            raise ValueError("Namespace must be a non-empty string.")
+
+    @classmethod
+    def _verify_peg(cls, peg):
+        return True  # TODO
+
+
+class _StaffContext(BaseContext):
+    @staticmethod
+    def verify(data):
+        if data is None:
+            return True
+
+        if not isinstance(data, dict):
+            raise ValueError("Staff context must be a dictionary.")
+
+        if "email" not in data:
+            raise ValueError("Missing required field: 'email'")
+
+        return True
+
+
+class _MetadataContext(BaseContext):
+    @staticmethod
+    def verify(data):
+        return True
+
+
+class ContextBuilder:
+    registry = {}
+
+    def __init__(self):
+        self.context = {}
+
+    @classmethod
+    def register(cls, key, handler_class):
+        cls.registry[key] = handler_class
+
+    def add(self, key, serialized_data):
+        handler = self.registry.get(key)
+
+        if handler is None:
+            raise ValueError(f"{key} rejected: no handler registered")
+
+        verify_method = getattr(handler, "verify", None)
+
+        if not callable(verify_method):
+            raise ValueError(f"{key} rejected: 'verify' not implemented")
+
+        try:
+            if not verify_method(serialized_data):
+                raise ValueError(f"{key} rejected: verification failed")
+        except Exception as e:
+            raise ValueError(f"{key} rejected: verification error - {str(e)}")
+
+        self.context[key] = serialized_data
+        return self
+
+    def build(self):
+        return self.context
+
+
+ContextBuilder.register("table", _TableContext)
+ContextBuilder.register("staff", _StaffContext)
+ContextBuilder.register("metadata", _MetadataContext)

{workpeg-0.3.2 → workpeg-0.4.0/src/workpeg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workpeg
-Version: 0.3.2
+Version: 0.4.0
 Summary: Workpeg function runtime and SDK
 Author-email: Workpeg <support@workpeg.com>
 License: MIT

{workpeg-0.3.2 → workpeg-0.4.0}/src/workpeg.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/workpeg/__init__.py
 src/workpeg/build.py
 src/workpeg/cli.py
 src/workpeg/config.py
+src/workpeg/context.py
 src/workpeg/create_new.py
 src/workpeg/run.py
 src/workpeg/runtime.py
@@ -25,6 +26,7 @@ src/workpeg/templates/functions/app/__init__.py
 src/workpeg/templates/functions/app/main.py
 tests/test_build.py
 tests/test_cli.py
+tests/test_context.py
 tests/test_create_new.py
 tests/test_run.py
 tests/test_runtime.py

workpeg-0.4.0/tests/test_context.py

@@ -0,0 +1,201 @@
+import pytest
+from unittest.mock import patch
+from uuid import uuid4
+
+from workpeg.context import (
+    ContextBuilder,
+    _TableContext, _StaffContext, _MetadataContext
+)
+
+
+@pytest.fixture
+def valid_table_data():
+    return {
+        "uuid": str(uuid4()),
+        "name": "Employees",
+        "owner_id": 1,
+        "metadata": {},
+        "columns": [],
+        "namespace": "workpeg.hr",
+        "peg": 10,
+    }
+
+
+class TestTableContext:
+
+    def test_verify_table_returns_true_for_valid_data(self, valid_table_data):
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_verify_table_returns_true_when_owner_id_is_none(
+        self,
+        valid_table_data,
+    ):
+        valid_table_data["owner_id"] = None
+
+        assert _TableContext.verify(valid_table_data) is True
+
+    def test_verify_table_raises_when_required_key_is_missing(
+        self,
+        valid_table_data,
+    ):
+        del valid_table_data["uuid"]
+
+        with pytest.raises(ValueError, match="Missing required fields"):
+            _TableContext.verify(valid_table_data)
+
+    def test_verify_table_raises_for_invalid_uuid(self, valid_table_data):
+        valid_table_data["uuid"] = "bad-uuid"
+
+        with pytest.raises(ValueError, match="Invalid UUID format."):
+            _TableContext.verify(valid_table_data)
+
+    def test_verify_table_raises_for_invalid_owner_id(self, valid_table_data):
+        valid_table_data["owner_id"] = 0
+
+        with pytest.raises(
+            ValueError,
+            match="Owner ID must be a positive integer or None.",
+        ):
+            _TableContext.verify(valid_table_data)
+
+    def test_verify_table_raises_for_invalid_namespace(self, valid_table_data):
+        valid_table_data["namespace"] = {}
+
+        with pytest.raises(
+            ValueError,
+            match="Namespace must be a non-empty string.",
+        ):
+            _TableContext.verify(valid_table_data)
+
+    def test_verify_keys_accepts_extra_fields(self, valid_table_data):
+        valid_table_data["extra"] = "allowed"
+
+        assert _TableContext._verify_keys(valid_table_data) is None
+
+    def test_verify_uuid_format_accepts_valid_uuid(self):
+        assert _TableContext._verify_uuid_format(str(uuid4())) is None
+
+    def test_verify_uuid_format_raises_for_invalid_uuid(self):
+        with pytest.raises(ValueError, match="Invalid UUID format."):
+            _TableContext._verify_uuid_format("123")
+
+
+class TestContextBuilder:
+
+    def test_adds_valid_table_context(self, valid_table_data):
+        builder = ContextBuilder()
+        builder.register("table", _TableContext)
+
+        context = builder.add("table", valid_table_data).build()
+
+        assert context["table"] == valid_table_data
+
+    def test_add_returns_self_for_chaining(self, valid_table_data):
+        builder = ContextBuilder()
+        builder.register("table", _TableContext)
+
+        result = builder.add("table", valid_table_data)
+
+        assert result is builder
+
+    def test_rejects_unregistered_context_key(self, valid_table_data):
+        builder = ContextBuilder()
+
+        with pytest.raises(
+            ValueError,
+            match="unknown rejected: no handler registered",
+        ):
+            builder.add("unknown", valid_table_data)
+
+    def test_rejects_handler_without_verify_method(self, valid_table_data):
+        class BadTableContext:
+            pass
+
+        builder = ContextBuilder()
+        builder.register("something", BadTableContext)
+
+        with pytest.raises(
+            ValueError,
+            match="something rejected: 'verify' not implemented",
+        ):
+            builder.add("something", valid_table_data)
+
+    def test_rejects_invalid_table_context_with_exact_reason(
+        self,
+        valid_table_data,
+    ):
+        builder = ContextBuilder()
+        builder.register("table", _TableContext)
+
+        valid_table_data["uuid"] = "bad-uuid"
+
+        with pytest.raises(
+            ValueError,
+            match="table rejected: verification error - Invalid UUID format.",
+        ):
+            builder.add("table", valid_table_data)
+
+    def test_uses_verify_table_method(self, valid_table_data):
+        builder = ContextBuilder()
+        builder.register("table", _TableContext)
+
+        with patch.object(_TableContext, "verify", return_value=True) as mock_verify:
+            builder.add("table", valid_table_data)
+
+        mock_verify.assert_called_once_with(valid_table_data)
+
+
+class TestStaffContext:
+
+    def test_verify_staff_allows_none(self):
+        assert _StaffContext.verify(None) is True
+
+    def test_verify_staff_accepts_valid_data(self):
+        data = {"email": "test@example.com"}
+
+        assert _StaffContext.verify(data) is True
+
+    def test_verify_staff_rejects_non_dict(self):
+        with pytest.raises(
+            ValueError,
+            match="Staff context must be a dictionary.",
+        ):
+            _StaffContext.verify("not-a-dict")
+
+    def test_verify_staff_rejects_missing_email(self):
+        with pytest.raises(
+            ValueError,
+            match="Missing required field: 'email'",
+        ):
+            _StaffContext.verify({})
+
+    def test_verify_staff_allows_extra_fields(self):
+        data = {
+            "email": "test@example.com",
+            "name": "John",
+            "role": "admin",
+        }
+
+        assert _StaffContext.verify(data) is True
+
+
+class TestMetadataContext:
+
+    def test_verify_extra_accepts_none(self):
+        assert _MetadataContext.verify(None) is True
+
+    def test_verify_metadata_accepts_dict(self):
+        assert _MetadataContext.verify({"foo": "bar"}) is True
+
+    def test_verify_metadata_accepts_any_type(self):
+        test_cases = [
+            "string",
+            123,
+            12.5,
+            [],
+            (),
+            object(),
+        ]
+
+        for case in test_cases:
+            assert _MetadataContext.verify(case) is True