fix(application): check context options preflight

This change ensures that context options like --project and --directory
are validated prior to executing the application to prevent runtime
exceptions.

Author: abn

src/poetry/console/application.py

@@ -20,6 +20,7 @@
 from poetry.console.command_loader import CommandLoader
 from poetry.console.commands.command import Command
 from poetry.utils.helpers import directory
+from poetry.utils.helpers import ensure_path
 
 
 if TYPE_CHECKING:
@@ -214,6 +215,12 @@ def create_io(
         return io
 
     def _run(self, io: IO) -> int:
+        # we do this here and not inside the _configure_io implementation in order
+        # to ensure the users are not exposed to a stack trace for providing invalid values to
+        # the options --directory or --project, configuring the options here allow cleo to trap and
+        # display the error cleanly unless the user uses verbose or debug
+        self._configure_custom_application_options(io)
+
         self._load_plugins(io)
 
         with directory(self._working_directory):
@@ -251,16 +258,20 @@ def _configure_custom_application_options(self, io: IO | None) -> None:
         self._disable_cache = self._option_get_value(
             io, "no-cache", self._disable_cache
         )
-        self._working_directory = self._project_directory = Path(
-            self._option_get_value(io, "directory", Path.cwd())
-        )
 
-        self._project_directory = Path(
-            self._option_get_value(io, "project", self._working_directory)
+        # we use ensure_path for the directories to make sure these are valid paths
+        # this will raise an exception if the path is invalid
+        self._working_directory = self._project_directory = ensure_path(
+            self._option_get_value(io, "directory", Path.cwd()), is_directory=True
         )
 
-        if self._project_directory != self._working_directory:
-            with directory(self._working_directory):
+        with directory(self._working_directory):
+            # project directory is always resolved relative to the working directory
+            self._project_directory = ensure_path(
+                self._option_get_value(io, "project", self._working_directory),
+                is_directory=True,
+            )
+            if not self._project_directory.is_absolute():
                 self._project_directory = self._project_directory.absolute()
 
     def _configure_io(self, io: IO) -> None:
@@ -299,8 +310,6 @@ def _configure_io(self, io: IO) -> None:
 
         super()._configure_io(io)
 
-        self._configure_custom_application_options(io)
-
     def register_command_loggers(
         self, event: Event, event_name: str, _: EventDispatcher
     ) -> None:

src/poetry/utils/helpers.py

@@ -258,6 +258,18 @@ def paths_csv(paths: list[Path]) -> str:
     return ", ".join(f'"{c!s}"' for c in paths)
 
 
+def ensure_path(path: str | Path, is_directory: bool = False) -> Path:
+    if isinstance(path, str):
+        path = Path(path)
+
+    if path.exists() and path.is_dir() == is_directory:
+        return path
+
+    raise ValueError(
+        f"Specified path '{path}' is not a valid {'directory' if is_directory else 'file'}."
+    )
+
+
 def is_dir_writable(path: Path, create: bool = False) -> bool:
     try:
         if not path.exists():

tests/console/test_application_global_options.py

@@ -92,6 +92,34 @@ def test_application_global_option_position_does_not_matter(
     assert len(stdout.splitlines()) == 8
 
 
+@pytest.mark.parametrize("parameter", ["-C", "--directory", "-P", "--project"])
+@pytest.mark.parametrize(
+    "invalid_source_directory",
+    [
+        "--/invalid/path",
+        __file__,
+        "is this a path ?",
+    ],
+)
+def test_application_global_option_context_is_validated(
+    parameter: str,
+    tester: ApplicationTester,
+    invalid_source_directory: str,
+) -> None:
+    source_directory = Path(invalid_source_directory).as_posix()
+    error_string = f"\nSpecified path '{source_directory}' is not a valid directory.\n"
+
+    option = f"{parameter} '{source_directory}'"
+    tester.execute(f"show {option}")
+    assert tester.status_code != 0
+
+    stdout = tester.io.fetch_output()
+    assert stdout == ""
+
+    stderr = tester.io.fetch_error()
+    assert stderr == error_string
+
+
 @pytest.mark.parametrize("parameter", ["project", "directory"])
 def test_application_with_context_parameters(
     parameter: str,

tests/utils/test_helpers.py

@@ -3,6 +3,7 @@
 import base64
 import re
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import Any
 
@@ -14,13 +15,12 @@
 from poetry.utils.helpers import Downloader
 from poetry.utils.helpers import HTTPRangeRequestSupportedError
 from poetry.utils.helpers import download_file
+from poetry.utils.helpers import ensure_path
 from poetry.utils.helpers import get_file_hash
 from poetry.utils.helpers import get_highest_priority_hash_type
 
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
     from httpretty import httpretty
     from httpretty.core import HTTPrettyRequest
 
@@ -299,3 +299,47 @@ def test_downloader_uses_authenticator_by_default(
     request = http.last_request()
     basic_auth = base64.b64encode(b"bar:baz").decode()
     assert request.headers["Authorization"] == f"Basic {basic_auth}"
+
+
+def test_ensure_path_converts_string(tmp_path: Path) -> None:
+    assert tmp_path.exists()
+    assert ensure_path(path=tmp_path.as_posix(), is_directory=True) == tmp_path
+
+
+def test_ensure_path_does_not_convert_path(tmp_path: Path) -> None:
+    assert tmp_path.exists()
+    assert Path(tmp_path.as_posix()) is not tmp_path
+
+    result = ensure_path(path=tmp_path, is_directory=True)
+
+    assert result == tmp_path
+    assert result is tmp_path
+
+
+def test_ensure_path_is_directory_parameter(tmp_path: Path) -> None:
+    with pytest.raises(ValueError):
+        ensure_path(path=tmp_path, is_directory=False)
+
+    assert ensure_path(path=tmp_path, is_directory=True) is tmp_path
+
+
+def test_ensure_path_file(tmp_path: Path) -> None:
+    path = tmp_path.joinpath("some_file.txt")
+    assert not path.exists()
+
+    with pytest.raises(ValueError):
+        ensure_path(path=path, is_directory=False)
+
+    path.write_text("foobar")
+    assert ensure_path(path=path, is_directory=False) is path
+
+
+def test_ensure_path_directory(tmp_path: Path) -> None:
+    path = tmp_path.joinpath("foobar")
+    assert not path.exists()
+
+    with pytest.raises(ValueError):
+        ensure_path(path=path, is_directory=True)
+
+    path.mkdir()
+    assert ensure_path(path=path, is_directory=True) is path