test(evaluators): expand starts_with coverage

Author: lan17

evaluators/builtin/tests/list/test_list.py

@@ -54,6 +54,27 @@ async def test_starts_with_matches_prefix(self) -> None:
         assert result.matched is True
         assert result.metadata["matches"] == ["/home/lev/agent-control/server/src/app.py"]
 
+    @pytest.mark.asyncio
+    async def test_starts_with_matches_exact_path_value(self) -> None:
+        """Test that starts_with mode matches the configured path value exactly."""
+        # Given: a starts_with evaluator config
+        evaluator = ListEvaluator(
+            ListEvaluatorConfig(
+                values=["/home/lev/agent-control"],
+                logic="any",
+                match_on="match",
+                match_mode="starts_with",
+                case_sensitive=True,
+            )
+        )
+
+        # When: evaluating the exact configured path
+        result = await evaluator.evaluate("/home/lev/agent-control")
+
+        # Then: the exact path matches
+        assert result.matched is True
+        assert result.metadata["matches"] == ["/home/lev/agent-control"]
+
     @pytest.mark.asyncio
     async def test_starts_with_no_match_when_prefix_absent(self) -> None:
         """Test that starts_with mode does not trigger when no prefix matches."""
@@ -74,6 +95,27 @@ async def test_starts_with_no_match_when_prefix_absent(self) -> None:
         # Then: the evaluator does not trigger
         assert result.matched is False
 
+    @pytest.mark.asyncio
+    async def test_starts_with_uses_raw_string_prefix_for_path_like_values(self) -> None:
+        """Test that starts_with is generic string-prefix matching, not path-segment aware."""
+        # Given: a starts_with evaluator configured with a path-like prefix
+        evaluator = ListEvaluator(
+            ListEvaluatorConfig(
+                values=["/home/lev/agent-control"],
+                logic="any",
+                match_on="match",
+                match_mode="starts_with",
+                case_sensitive=True,
+            )
+        )
+
+        # When: evaluating a sibling path that shares the same string prefix
+        result = await evaluator.evaluate("/home/lev/agent-control-old/server")
+
+        # Then: the evaluator matches because starts_with is not path-boundary aware
+        assert result.matched is True
+        assert result.metadata["matches"] == ["/home/lev/agent-control-old/server"]
+
     @pytest.mark.asyncio
     async def test_starts_with_honors_case_sensitivity(self) -> None:
         """Test that starts_with mode respects case sensitivity settings."""
@@ -127,6 +169,97 @@ async def test_starts_with_supports_no_match_allowlists(self) -> None:
         assert allowed_result.matched is False
         assert denied_result.matched is True
 
+    @pytest.mark.asyncio
+    async def test_starts_with_matches_plain_text_prefix(self) -> None:
+        """Test that starts_with mode works for ordinary non-path strings."""
+        # Given: a starts_with evaluator config for ordinary strings
+        evaluator = ListEvaluator(
+            ListEvaluatorConfig(
+                values=["agent", "control:"],
+                logic="any",
+                match_on="match",
+                match_mode="starts_with",
+                case_sensitive=True,
+            )
+        )
+
+        # When: evaluating values with and without the configured prefixes
+        matched_result = await evaluator.evaluate("agent-control")
+        unmatched_result = await evaluator.evaluate("please control: now")
+
+        # Then: only the true prefix match triggers
+        assert matched_result.matched is True
+        assert unmatched_result.matched is False
+
+    @pytest.mark.asyncio
+    async def test_starts_with_escapes_regex_metacharacters(self) -> None:
+        """Test that starts_with treats configured values as literals, not regex."""
+        # Given: prefixes containing regex metacharacters
+        evaluator = ListEvaluator(
+            ListEvaluatorConfig(
+                values=["release/v1.2+", "[beta]"],
+                logic="any",
+                match_on="match",
+                match_mode="starts_with",
+                case_sensitive=True,
+            )
+        )
+
+        # When: evaluating values that begin with those literal prefixes
+        release_result = await evaluator.evaluate("release/v1.2+rc1")
+        beta_result = await evaluator.evaluate("[beta] feature flag")
+
+        # Then: both values match literally
+        assert release_result.matched is True
+        assert beta_result.matched is True
+
+    @pytest.mark.asyncio
+    async def test_starts_with_supports_list_input_with_any_logic(self) -> None:
+        """Test that starts_with works on list inputs when any item matches."""
+        # Given: a starts_with evaluator with any-item semantics
+        evaluator = ListEvaluator(
+            ListEvaluatorConfig(
+                values=["/home/lev/agent-control", "agent"],
+                logic="any",
+                match_on="match",
+                match_mode="starts_with",
+                case_sensitive=True,
+            )
+        )
+
+        # When: evaluating a list where only one element matches
+        result = await evaluator.evaluate(["/var/log/system.log", "agent-control"])
+
+        # Then: the evaluator triggers and reports the matching entry
+        assert result.matched is True
+        assert result.metadata["matches"] == ["agent-control"]
+
+    @pytest.mark.asyncio
+    async def test_starts_with_supports_list_input_with_all_logic(self) -> None:
+        """Test that starts_with respects all-item semantics for list inputs."""
+        # Given: a starts_with evaluator with all-item semantics
+        evaluator = ListEvaluator(
+            ListEvaluatorConfig(
+                values=["/home/lev/agent-control", "/tmp/cache"],
+                logic="all",
+                match_on="match",
+                match_mode="starts_with",
+                case_sensitive=True,
+            )
+        )
+
+        # When: evaluating one fully matching list and one partially matching list
+        matching_result = await evaluator.evaluate(
+            ["/home/lev/agent-control/server", "/tmp/cache/build"]
+        )
+        partial_result = await evaluator.evaluate(
+            ["/home/lev/agent-control/server", "/var/log/system.log"]
+        )
+
+        # Then: only the fully matching list triggers
+        assert matching_result.matched is True
+        assert partial_result.matched is False
+
     @pytest.mark.asyncio
     async def test_legacy_empty_string_value_is_ignored_defensively(self) -> None:
         """Test that legacy invalid configs do not compile into a match-all regex."""