fix(test): distinguish an unknown test name from an unknown file

Review feedback on #6061. A `path::test_name` selector that fails
because the file is not a test file and one that fails because the file
has no such test both reported "is not a known model or test file",
which points at the wrong thing in the second case.

The two are now told apart: if the path resolves to a known test file,
the error names the test and the file it looked in. Otherwise the
message is unchanged.

Also adds Python model coverage for path selection, both in isolation
and combined with --local, since selection is by file path and there was
nothing pinning that .py behaves the same as .sql.

Separately, renames a loop variable in _select_tests_by_test_path. It
shadowed a str binding from the branch above with a Path, which mypy
rejects; it was pre-existing on this branch rather than introduced here.

Signed-off-by: Adegbite Ayoade <tripleaceme@gmail.com>

Author: tripleaceme

sqlmesh/core/context.py

@@ -3659,13 +3659,29 @@ def _select_tests_by_test_path(self, selector: str) -> t.Optional[t.List[ModelTe
                 )
             return [metadata] if metadata is not None else None
 
-        for path in (Path(selector), Path(os.path.abspath(selector))):
-            matched = self._model_test_metadata_path_index.get(path)
+        for candidate in (Path(selector), Path(os.path.abspath(selector))):
+            matched = self._model_test_metadata_path_index.get(candidate)
             if matched is not None:
                 return list(matched)
 
         return None
 
+    def _unknown_test_selector_error(self, selector: str) -> str:
+        """Explains why a selector matched nothing.
+
+        A `path::test_name` whose file is a known test file failed on the test name, not the
+        path, so the message says so rather than claiming the file is unknown.
+        """
+        if "::" in selector:
+            path, _, _ = selector.rpartition("::")
+            if any(
+                candidate in self._model_test_metadata_path_index
+                for candidate in (Path(path), Path(os.path.abspath(path)))
+            ):
+                return f"'{selector}' is not a known test in '{path}'."
+
+        return f"'{selector}' is not a known model or test file."
+
     def select_tests(
         self,
         tests: t.Optional[t.List[str]] = None,
@@ -3704,7 +3720,7 @@ def select_tests(
                     matched = tests_by_model_path.get(os.path.abspath(test))
                 if matched is None:
                     if raise_on_unknown_paths:
-                        raise SQLMeshError(f"'{test}' is not a known model or test file.")
+                        raise SQLMeshError(self._unknown_test_selector_error(test))
                     continue
                 filtered_tests.extend(matched)
 

tests/cli/test_cli.py

@@ -2820,3 +2820,54 @@ def test_test_local_with_model_paths(runner: CliRunner, tmp_path: Path, mocker)
     assert result.exit_code != 0
     assert "is not a known model or test file" in result.output
     mock.assert_not_called()
+
+
+def test_test_local_with_python_model_paths(runner: CliRunner, tmp_path: Path, mocker) -> None:
+    """The `--local` + path-selector combination works for Python models too."""
+    create_example_project(tmp_path)
+
+    (tmp_path / "models" / "py_model.py").write_text(
+        """
+import pandas as pd  # noqa: TID253
+from sqlmesh import model, ExecutionContext
+import typing as t
+
+@model(
+  name="sqlmesh_example.py_model",
+  columns={"id": "int"},
+)
+def execute(context: ExecutionContext, **kwargs: t.Any) -> pd.DataFrame:
+  return pd.DataFrame([{"id": 1}])
+""",
+        encoding="utf-8",
+    )
+    (tmp_path / "tests" / "test_py_model.yaml").write_text(
+        """
+test_py_model:
+  model: sqlmesh_example.py_model
+  outputs:
+    query:
+      rows:
+      - id: 1
+""",
+        encoding="utf-8",
+    )
+
+    mock = _patch_state_access(mocker)
+
+    result = runner.invoke(
+        cli,
+        ["--paths", str(tmp_path), "test", "--local", str(tmp_path / "models" / "py_model.py")],
+    )
+
+    assert result.exit_code == 0, f"Test failed: {result.output}\nException: {result.exception}"
+    assert "Successfully Ran 1 tests" in " ".join(result.output.split())
+    mock.assert_not_called()
+
+    # A Python file that is not a model is still an error rather than a silent no-op.
+    result = runner.invoke(
+        cli, ["--paths", str(tmp_path), "test", "--local", str(tmp_path / "models" / "nope.py")]
+    )
+    assert result.exit_code != 0
+    assert "is not a known model or test file" in result.output
+    mock.assert_not_called()

tests/core/test_test.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import datetime
+import re
 import typing as t
 import io
 from pathlib import Path
@@ -2697,6 +2698,46 @@ def test_model_path_selects_its_tests(tmp_path: Path) -> None:
     assert results.testsRun == 1
 
 
+def test_python_model_path_selects_its_tests(tmp_path: Path) -> None:
+    """Selection is by file path, so a Python model works the same way a SQL one does."""
+    init_example_project(tmp_path, engine_type="duckdb")
+
+    py_model = tmp_path / "models" / "py_model.py"
+    py_model.write_text(
+        """
+import pandas as pd  # noqa: TID253
+from sqlmesh import model, ExecutionContext
+import typing as t
+
+@model(
+  name="sqlmesh_example.py_model",
+  columns={"id": "int"},
+)
+def execute(context: ExecutionContext, **kwargs: t.Any) -> pd.DataFrame:
+  return pd.DataFrame([{"id": 1}])
+"""
+    )
+    (tmp_path / "tests" / "test_py_model.yaml").write_text(
+        """
+test_py_model:
+  model: sqlmesh_example.py_model
+  outputs:
+    query:
+      rows:
+      - id: 1
+"""
+    )
+
+    context = Context(paths=tmp_path)
+
+    results = context.test(tests=[str(py_model)])
+    assert results.testsRun == 1
+    assert len(results.successes) == 1
+
+    # The SQL model's own test is not pulled in by selecting the Python model.
+    assert context.test(tests=[str(tmp_path / "models" / "full_model.sql")]).testsRun == 1
+
+
 def test_model_path_without_tests_selects_nothing(tmp_path: Path) -> None:
     """A known model that simply has no tests is not an error."""
     init_example_project(tmp_path, engine_type="duckdb")
@@ -2763,15 +2804,25 @@ def test_unknown_path_errors_when_requested(tmp_path: Path) -> None:
 
 
 def test_unknown_test_name_errors_when_requested(tmp_path: Path) -> None:
-    """A known YAML file with an unknown `::test_name` is just as wrong as a bad path."""
+    """A known YAML file with an unknown `::test_name` reports the test, not the file."""
     init_example_project(tmp_path, engine_type="duckdb")
     context = Context(paths=tmp_path)
 
     test_path = tmp_path / "tests" / "test_full_model.yaml"
-    with pytest.raises(SQLMeshError, match="is not a known model or test file"):
+    with pytest.raises(SQLMeshError, match=f"is not a known test in '{re.escape(str(test_path))}'"):
         context.select_tests(tests=[f"{test_path}::nope"], raise_on_unknown_paths=True)
 
 
+def test_unknown_test_name_in_unknown_file_reports_the_file(tmp_path: Path) -> None:
+    """A `::test_name` on a file that isn't a test file is a path problem, not a name one."""
+    init_example_project(tmp_path, engine_type="duckdb")
+    context = Context(paths=tmp_path)
+
+    missing = tmp_path / "tests" / "test_nope.yaml"
+    with pytest.raises(SQLMeshError, match="is not a known model or test file"):
+        context.select_tests(tests=[f"{missing}::nope"], raise_on_unknown_paths=True)
+
+
 def test_select_model_still_filters_path_selection(tmp_path: Path) -> None:
     """`--select-model` keeps narrowing the selection rather than adding to it."""
     init_example_project(tmp_path, engine_type="duckdb")