feat: allow dbx test and dbx just to accept '.' or any path as repo argument

aclark4life · aclark4life · commit db102dc6831c · 2026-04-14T13:03:02.000-04:00
- Import find_repo_by_path in test.py and just.py
- Add path detection (., .., absolute/relative paths) in the no-group
  lookup branch of both commands
- Update repo_name to the real name after path resolution so test-runner
  config lookups, env-var lookups, and output messages are correct
- Add tests for path lookup from repo root and from an unmanaged directory
  in both test_test_command.py and test_just_command.py
diff --git a/src/dbx_python_cli/commands/just.py b/src/dbx_python_cli/commands/just.py
@@ -12,6 +12,7 @@
     find_all_repos,
     find_all_repos_by_name,
     find_repo_by_name,
+    find_repo_by_path,
     get_base_dir,
     get_config,
     get_global_groups,
@@ -129,25 +130,46 @@ def _run_just_in_repo(
             "group": group,
         }
     else:
-        # Find repo by name across all groups
-        repo = find_repo_by_name(repo_name, base_dir, config)
-        if not repo:
-            typer.echo(f"❌ Error: Repository '{repo_name}' not found", err=True)
-            typer.echo("\nRun 'dbx list' to see available repositories")
-            raise typer.Exit(1)
+        # Detect path-like inputs: ".", "..", absolute paths, relative paths with /
+        _is_path_like = (
+            repo_name in (".", "..")
+            or repo_name.startswith(("./", "../", "/", "~/"))
+            or "/" in repo_name
+            or Path(repo_name).is_dir()
+        )
 
-        # Check if repo exists in multiple groups
-        all_matches = find_all_repos_by_name(repo_name, base_dir, config)
-        if len(all_matches) > 1:
-            groups = [r["group"] for r in all_matches]
-            typer.echo(
-                f"⚠️  Warning: '{repo_name}' exists in multiple groups: {', '.join(groups)}",
-                err=True,
-            )
-            typer.echo(
-                f"⚠️  Using '{repo['group']}' group. Specify -g <group> to use a different one.\n",
-                err=True,
-            )
+        if _is_path_like:
+            repo = find_repo_by_path(repo_name, base_dir, config)
+            if not repo:
+                typer.echo(
+                    f"❌ Error: No managed repository found at '{Path(repo_name).resolve()}'",
+                    err=True,
+                )
+                typer.echo("\nRun 'dbx list' to see available repositories")
+                raise typer.Exit(1)
+            # Update repo_name so env-var lookups and messages use the real name
+            repo_name = repo["name"]
+        else:
+            # Find repo by name across all groups
+            repo = find_repo_by_name(repo_name, base_dir, config)
+            if not repo:
+                typer.echo(f"❌ Error: Repository '{repo_name}' not found", err=True)
+                typer.echo("\nRun 'dbx list' to see available repositories")
+                raise typer.Exit(1)
+
+        # Check if repo exists in multiple groups (name-based lookup only)
+        if not _is_path_like:
+            all_matches = find_all_repos_by_name(repo_name, base_dir, config)
+            if len(all_matches) > 1:
+                groups = [r["group"] for r in all_matches]
+                typer.echo(
+                    f"⚠️  Warning: '{repo_name}' exists in multiple groups: {', '.join(groups)}",
+                    err=True,
+                )
+                typer.echo(
+                    f"⚠️  Using '{repo['group']}' group. Specify -g <group> to use a different one.\n",
+                    err=True,
+                )
 
     repo_path = Path(repo["path"])
 
diff --git a/src/dbx_python_cli/commands/test.py b/src/dbx_python_cli/commands/test.py
@@ -10,6 +10,7 @@
 
 from dbx_python_cli.utils.repo import (
     find_repo_by_name,
+    find_repo_by_path,
     find_all_repos_by_name,
     get_base_dir,
     get_config,
@@ -159,25 +160,46 @@ def test_callback(
                 "group": group,
             }
         else:
-            # Default behavior: find repo by name across all groups
-            repo = find_repo_by_name(repo_name, base_dir, config)
-            if not repo:
-                typer.echo(f"Error: Repository '{repo_name}' not found.", err=True)
-                typer.echo("Run 'dbx list' to see available repositories.", err=True)
-                raise typer.Exit(1)
+            # Detect path-like inputs: ".", "..", absolute paths, relative paths with /
+            _is_path_like = (
+                repo_name in (".", "..")
+                or repo_name.startswith(("./", "../", "/", "~/"))
+                or "/" in repo_name
+                or Path(repo_name).is_dir()
+            )
 
-            # Check if repo exists in multiple groups
-            all_matches = find_all_repos_by_name(repo_name, base_dir, config)
-            if len(all_matches) > 1:
-                groups = [r["group"] for r in all_matches]
-                typer.echo(
-                    f"⚠️  Warning: '{repo_name}' exists in multiple groups: {', '.join(groups)}",
-                    err=True,
-                )
-                typer.echo(
-                    f"⚠️  Using '{repo['group']}' group. Specify -g <group> to use a different one.\n",
-                    err=True,
-                )
+            if _is_path_like:
+                repo = find_repo_by_path(repo_name, base_dir, config)
+                if not repo:
+                    typer.echo(
+                        f"Error: No managed repository found at '{Path(repo_name).resolve()}'.",
+                        err=True,
+                    )
+                    typer.echo("Run 'dbx list' to see available repositories.", err=True)
+                    raise typer.Exit(1)
+                # Update repo_name so test-runner config lookups and messages use real name
+                repo_name = repo["name"]
+            else:
+                # Default behavior: find repo by name across all groups
+                repo = find_repo_by_name(repo_name, base_dir, config)
+                if not repo:
+                    typer.echo(f"Error: Repository '{repo_name}' not found.", err=True)
+                    typer.echo("Run 'dbx list' to see available repositories.", err=True)
+                    raise typer.Exit(1)
+
+            # Check if repo exists in multiple groups (name-based lookup only)
+            if not _is_path_like:
+                all_matches = find_all_repos_by_name(repo_name, base_dir, config)
+                if len(all_matches) > 1:
+                    groups = [r["group"] for r in all_matches]
+                    typer.echo(
+                        f"⚠️  Warning: '{repo_name}' exists in multiple groups: {', '.join(groups)}",
+                        err=True,
+                    )
+                    typer.echo(
+                        f"⚠️  Using '{repo['group']}' group. Specify -g <group> to use a different one.\n",
+                        err=True,
+                    )
 
             repo_path = repo["path"]
             # Use repo's own group
diff --git a/tests/test_just_command.py b/tests/test_just_command.py
@@ -99,6 +99,43 @@ def test_just_repo_not_found(tmp_path, temp_repos_dir, mock_config):
             assert "not found" in output or "available repositories" in output
 
 
+def test_just_dot_from_repo_root(tmp_path, temp_repos_dir, mock_config, monkeypatch):
+    """Test that '.' resolves to the repo at the current directory."""
+    repo_dir = temp_repos_dir / "pymongo" / "mongo-python-driver"
+
+    monkeypatch.chdir(repo_dir)
+
+    with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
+        with patch(
+            "dbx_python_cli.commands.just.ensure_mongodb",
+            side_effect=lambda e, *a, **k: e,
+        ):
+            with patch("subprocess.run") as mock_run:
+                mock_get_path.return_value = mock_config
+                mock_run.return_value = MagicMock(returncode=0)
+
+                result = runner.invoke(app, ["just", ".", "test"])
+                assert result.exit_code == 0
+                assert "Running 'just test' in" in result.stdout
+                args = mock_run.call_args[0][0]
+                assert args == ["just", "test"]
+
+
+def test_just_dot_not_in_managed_repo(tmp_path, temp_repos_dir, mock_config, monkeypatch):
+    """Test that '.' in an unmanaged directory gives a clear error."""
+    unrelated = tmp_path / "unrelated"
+    unrelated.mkdir()
+    monkeypatch.chdir(unrelated)
+
+    with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
+        mock_get_path.return_value = mock_config
+
+        result = runner.invoke(app, ["just", "."])
+        assert result.exit_code == 1
+        output = result.stdout + result.stderr
+        assert "No managed repository found" in output
+
+
 def test_just_no_justfile(tmp_path, temp_repos_dir, mock_config):
     """Test that just with repo without justfile shows warning."""
     with patch(
diff --git a/tests/test_test_command.py b/tests/test_test_command.py
@@ -96,6 +96,44 @@ def test_test_nonexistent_repo(mock_config, temp_repos_dir):
         assert "Repository 'nonexistent-repo' not found" in output
 
 
+def test_test_dot_from_repo_root(mock_config, temp_repos_dir, monkeypatch):
+    """Test that '.' resolves to the repo at the current directory."""
+    repo_dir = temp_repos_dir / "pymongo" / "mongo-python-driver"
+
+    monkeypatch.chdir(repo_dir)
+
+    with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
+        with patch("dbx_python_cli.commands.test.get_venv_info") as mock_venv:
+            with patch("subprocess.run") as mock_run:
+                with patch.dict("os.environ", {"MONGODB_URI": "mongodb://localhost:27017"}):
+                    mock_get_path.return_value = mock_config
+                    mock_venv.return_value = ("python", "venv")
+
+                    mock_result = MagicMock()
+                    mock_result.returncode = 0
+                    mock_run.return_value = mock_result
+
+                    result = runner.invoke(app, ["test", "."])
+                    assert result.exit_code == 0
+                    assert "Running pytest" in result.stdout
+                    assert "Tests passed in mongo-python-driver" in result.stdout
+
+
+def test_test_dot_not_in_managed_repo(mock_config, temp_repos_dir, monkeypatch):
+    """Test that '.' in an unmanaged directory gives a clear error."""
+    unrelated = temp_repos_dir / "unrelated"
+    unrelated.mkdir()
+    monkeypatch.chdir(unrelated)
+
+    with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
+        mock_get_path.return_value = mock_config
+
+        result = runner.invoke(app, ["test", "."])
+        assert result.exit_code == 1
+        output = result.stdout + result.stderr
+        assert "No managed repository found" in output
+
+
 def test_test_runs_pytest_success(mock_config, temp_repos_dir):
     """Test that test runs pytest successfully."""
     with patch("dbx_python_cli.utils.repo.get_config_path") as mock_get_path:
