CodeRabbit Generated Unit Tests: Add unit tests for DependentString, NodeTemplate, RegisteredNode

Author: coderabbitai[bot]

state-manager/tests/_notes/FRAMEWORK.md

@@ -0,0 +1,5 @@
+# Notes
+
+- Tests authored with pytest, matching repository conventions discovered via search.
+- Models use Pydantic v2 (field_validator), so assertions expect pydantic.ValidationError wrapping ValueError messages from validators.
+- No new dependencies introduced.

state-manager/tests/unit/models/test_dependent_string.py

@@ -0,0 +1,130 @@
+import pytest
+
+# Attempt multiple import paths to accommodate common layouts
+try:
+    # e.g., src/state_manager/models/dependent_string.py
+    from state_manager.models.dependent_string import DependentString, Dependent
+except Exception:
+    try:
+        # e.g., state_manager/dependent_string.py
+        from state_manager.dependent_string import DependentString, Dependent
+    except Exception:
+        try:
+            # e.g., state-manager/state_manager/models/dependent_string.py accessible as package
+            from models.dependent_string import DependentString, Dependent
+        except Exception:
+            # Fallback: relative import if tests live alongside source
+            from dependent_string import DependentString, Dependent  # type: ignore
+
+
+class TestCreateDependentString:
+    def test_no_placeholders_returns_head_only_and_empty_dependents(self):
+        s = "plain string without placeholders"
+        ds = DependentString.create_dependent_string(s)
+        assert isinstance(ds, DependentString)
+        assert ds.head == s
+        assert ds.dependents == {}
+        # get_identifier_field should be empty for no dependents
+        assert ds.get_identifier_field() == []
+
+    def test_single_placeholder_happy_path(self):
+        template = "Hello ${{ step.outputs.foo }} world"
+        ds = DependentString.create_dependent_string(template)
+        # Head is the prefix before the first placeholder
+        assert ds.head == "Hello "
+        # One dependent keyed by order 0
+        assert list(ds.dependents.keys()) == [0]
+        dep = ds.dependents[0]
+        assert isinstance(dep, Dependent)
+        assert dep.identifier == "step"
+        assert dep.field == "foo"
+        assert dep.tail == " world"
+        # Not set yet -> generate_string should raise
+        with pytest.raises(ValueError) as exc:
+            ds.generate_string()
+        assert "Dependent value is not set" in str(exc.value)
+        # After setting, generation should succeed
+        ds.set_value("step", "foo", "BAR")
+        assert ds.generate_string() == "Hello BAR world"
+
+    def test_placeholder_at_end_results_in_empty_tail(self):
+        template = "Hi ${{ a.outputs.x }}"
+        ds = DependentString.create_dependent_string(template)
+        assert ds.dependents[0].tail == ""
+        ds.set_value("a", "x", "V")
+        assert ds.generate_string() == "Hi V"
+
+    def test_multiple_placeholders_in_order(self):
+        template = "Start ${{ a.outputs.x }} mid ${{ b.outputs.y }} end"
+        ds = DependentString.create_dependent_string(template)
+        # Keys should reflect insertion order (0, 1) when sorted
+        assert sorted(ds.dependents.keys()) == [0, 1]
+        assert ds.dependents[0].identifier == "a"
+        assert ds.dependents[0].field == "x"
+        assert ds.dependents[0].tail == " mid "
+        assert ds.dependents[1].identifier == "b"
+        assert ds.dependents[1].field == "y"
+        assert ds.dependents[1].tail == " end"
+        ds.set_value("a", "x", "AX")
+        ds.set_value("b", "y", "BY")
+        assert ds.generate_string() == "Start AX mid BY end"
+
+    def test_unclosed_placeholder_raises_value_error(self):
+        template = "Start ${{ a.outputs.x end"
+        with pytest.raises(ValueError) as exc:
+            DependentString.create_dependent_string(template)
+        msg = str(exc.value)
+        assert "Invalid syntax string placeholder" in msg
+        assert "'${{'" in msg or "not closed" in msg
+
+    def test_invalid_placeholder_wrong_parts_count_raises(self):
+        # Missing the third part after outputs
+        template = "Start ${{ a.outputs }} end"
+        with pytest.raises(ValueError) as exc:
+            DependentString.create_dependent_string(template)
+        assert "Invalid syntax string placeholder" in str(exc.value)
+
+    def test_invalid_placeholder_wrong_keyword_raises(self):
+        template = "Start ${{ a.outputz.x }} end"
+        with pytest.raises(ValueError) as exc:
+            DependentString.create_dependent_string(template)
+        assert "Invalid syntax string placeholder" in str(exc.value)
+
+    def test_placeholder_with_extra_whitespace_is_parsed(self):
+        template = "P ${{  step  .  outputs  .  foo  }} T"
+        ds = DependentString.create_dependent_string(template)
+        assert ds.dependents[0].identifier == "step"
+        assert ds.dependents[0].field == "foo"
+        ds.set_value("step", "foo", "VAL")
+        assert ds.generate_string() == "P VAL T"
+
+
+class TestMappingAndSetValue:
+    def test_get_identifier_field_returns_unique_keys(self):
+        template = "A ${{ a.outputs.x }} B ${{ a.outputs.x }} C ${{ b.outputs.y }}"
+        ds = DependentString.create_dependent_string(template)
+        # Should return two unique keys: ('a','x') and ('b','y'), order not guaranteed
+        keys = ds.get_identifier_field()
+        assert set(keys) == {("a", "x"), ("b", "y")}
+
+    def test_set_value_updates_all_matching_dependents(self):
+        template = "A ${{ a.outputs.x }} B ${{ a.outputs.x }}"
+        ds = DependentString.create_dependent_string(template)
+        ds.set_value("a", "x", "V")
+        # Both dependents should get the same value and render twice
+        assert ds.generate_string() == "A V B V"
+
+    def test_set_value_with_unknown_mapping_raises_keyerror(self):
+        template = "A ${{ a.outputs.x }}"
+        ds = DependentString.create_dependent_string(template)
+        with pytest.raises(KeyError):
+            ds.set_value("unknown", "field", "V")
+
+    def test_build_mapping_is_idempotent_and_cached(self):
+        template = "A ${{ a.outputs.x }} B ${{ b.outputs.y }}"
+        ds = DependentString.create_dependent_string(template)
+        # First call builds mapping
+        keys1 = set(ds.get_identifier_field())
+        # Second call should not change
+        keys2 = set(ds.get_identifier_field())
+        assert keys1 == keys2 == {("a", "x"), ("b", "y")}

state-manager/tests/unit/models/test_node_template_model.py

@@ -0,0 +1,146 @@
+"""
+Test suite for NodeTemplate and Unites models.
+
+Testing library/framework: pytest (with Pydantic v2 ValidationError assertions).
+
+Covers:
+- Successful model creation with valid data
+- Validators: node_name, identifier (non-empty), next_nodes (non-empty, unique)
+- Optional field `next_nodes` can be None
+- Optional nested model `unites` with identifier non-empty when provided
+- get_dependent_strings: returns one entry per input; raises on non-string values; handles empty inputs
+"""
+
+import builtins
+import types
+import sys
+import inspect
+import pytest
+
+try:
+    # Try common import paths — adapt if project layout differs.
+    # Prefer the actual model module housing NodeTemplate and Unites.
+    from state_manager.models.node_template_model import NodeTemplate, Unites  # type: ignore
+    import state_manager.models.node_template_model as node_template_module  # type: ignore
+except Exception:
+    try:
+        from state_manager.models.node_template import NodeTemplate, Unites  # type: ignore
+        import state_manager.models.node_template as node_template_module  # type: ignore
+    except Exception:
+        # Fallback: dynamically locate the module that defines NodeTemplate in sys.modules
+        # This keeps tests resilient if the path changes while still validating behavior.
+        candidates = []
+        for name, mod in list(sys.modules.items()):
+            if not isinstance(mod, types.ModuleType):
+                continue
+            try:
+                if hasattr(mod, "NodeTemplate") and hasattr(mod, "Unites"):
+                    candidates.append(mod)
+            except Exception:
+                continue
+        if not candidates:
+            # Attempt a lazy import scan by probing typical packages under repo
+            # This is a last-resort guard — if it fails, tests will clearly indicate missing module.
+            raise
+        node_template_module = candidates[0]
+        NodeTemplate = getattr(node_template_module, "NodeTemplate")
+        Unites = getattr(node_template_module, "Unites")
+
+
+from pydantic import ValidationError
+
+
+def _valid_payload(**overrides):
+    data = {
+        "node_name": "node_A",
+        "namespace": "ns.main",
+        "identifier": "node-A-id",
+        "inputs": {"foo": "bar", "alpha": "beta"},
+        "next_nodes": ["node_B", "node_C"],
+        "unites": Unites(identifier="u-1"),
+    }
+    data.update(overrides)
+    return data
+
+
+class TestNodeTemplateValidation:
+    def test_valid_creation_happy_path(self):
+        model = NodeTemplate(**_valid_payload())
+        assert model.node_name == "node_A"
+        assert model.namespace == "ns.main"
+        assert model.identifier == "node-A-id"
+        assert model.next_nodes == ["node_B", "node_C"]
+        assert model.unites is not None and model.unites.identifier == "u-1"
+
+    @pytest.mark.parametrize(
+        "field, bad_value, expected_msg",
+        [
+            ("node_name", "", "Node name cannot be empty"),
+            ("identifier", "", "Node identifier cannot be empty"),
+        ],
+    )
+    def test_required_string_fields_must_not_be_empty(self, field, bad_value, expected_msg):
+        payload = _valid_payload(**{field: bad_value})
+        with pytest.raises(ValidationError) as ei:
+            NodeTemplate(**payload)
+        # ValueError raised in field_validator should surface inside ValidationError text
+        assert expected_msg in str(ei.value)
+
+    def test_next_nodes_none_is_allowed(self):
+        payload = _valid_payload(next_nodes=None)
+        model = NodeTemplate(**payload)
+        assert model.next_nodes is None
+
+    def test_next_nodes_rejects_empty_and_duplicates_with_aggregated_errors(self):
+        # includes duplicate "dup" and an empty string
+        payload = _valid_payload(next_nodes=["ok1", "dup", "dup", ""])
+        with pytest.raises(ValidationError) as ei:
+            NodeTemplate(**payload)
+        msg = str(ei.value)
+        assert "Next node identifier dup is not unique" in msg
+        assert "Next node identifier cannot be empty" in msg
+
+    def test_unites_identifier_must_not_be_empty_when_provided(self):
+        payload = _valid_payload(unites=Unites(identifier=""))
+        with pytest.raises(ValidationError) as ei:
+            NodeTemplate(**payload)
+        assert "Unites identifier cannot be empty" in str(ei.value)
+
+
+class TestGetDependentStrings:
+    def test_returns_one_dependent_string_per_input_value(self):
+        payload = _valid_payload(inputs={"a": "X", "b": "Y", "c": "Z"})
+        model = NodeTemplate(**payload)
+
+        # Prefer not to mock: assert count and type if available
+        result = model.get_dependent_strings()
+        assert isinstance(result, list)
+        assert len(result) == 3
+
+        # If DependentString is importable from the module, verify type
+        DepStr = getattr(node_template_module, "DependentString", None)
+        if DepStr is not None and inspect.isclass(DepStr):
+            assert all(isinstance(d, DepStr) for d in result)
+
+    def test_raises_value_error_when_any_input_value_is_not_string(self):
+        payload = _valid_payload(inputs={"a": "X", "b": 123, "c": "Z"})
+        model = NodeTemplate(**payload)
+        with pytest.raises(ValueError) as ei:
+            model.get_dependent_strings()
+        assert "Input 123 is not a string" in str(ei.value)
+
+    def test_handles_empty_inputs_dict(self):
+        payload = _valid_payload(inputs={})
+        model = NodeTemplate(**payload)
+        out = model.get_dependent_strings()
+        assert out == []
+
+
+# Extra edge cases: whitespace-only strings considered non-empty by type,
+# but validators explicitly only check for equality with empty string.
+# Decide expected behavior: whitespace is allowed per current implementation.
+def test_whitespace_strings_are_allowed_by_validators():
+    payload = _valid_payload(node_name="  name  ", identifier="  id  ")
+    model = NodeTemplate(**payload)
+    assert model.node_name.strip() == "name"
+    assert model.identifier.strip() == "id"