Add unit tests for dependency group loading

A new unit test module is added for parsing dependency groups and used
to verify all of the pip-defined behaviors for handling
dependency-groups.

In one path, the underlying exception message from `dependency-groups`
is exposed to users, where it should offer some explanation of why
parsing failed, and this is therefore tested.

Some related changes are applied to the dependency groups usage sites
in the src tree. The signature of the dependency group requirement
parse function is simplified, and its usage is therefore updated.
A bugfix is applied to add a missing `f` on an intended f-string.

Author: sirosen

src/pip/_internal/cli/req_command.py

@@ -242,9 +242,7 @@ def get_requirements(
             requirements.append(req_to_add)
 
         if options.dependency_groups:
-            for req in parse_dependency_groups(
-                options.dependency_groups, session, finder=finder, options=options
-            ):
+            for req in parse_dependency_groups(options.dependency_groups):
                 req_to_add = install_req_from_req_string(
                     req,
                     isolated=options.isolated_mode,

src/pip/_internal/req/req_dependency_group.py

@@ -1,22 +1,12 @@
-import optparse
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 from pip._vendor import tomli
 from pip._vendor.dependency_groups import resolve as resolve_dependency_group
 
 from pip._internal.exceptions import InstallationError
-from pip._internal.network.session import PipSession
 
-if TYPE_CHECKING:
-    from pip._internal.index.package_finder import PackageFinder
 
-
-def parse_dependency_groups(
-    groups: List[str],
-    session: PipSession,
-    finder: Optional["PackageFinder"] = None,
-    options: Optional[optparse.Values] = None,
-) -> List[str]:
+def parse_dependency_groups(groups: List[str]) -> List[str]:
     """
     Parse dependency groups data in a way which is sensitive to the `pip` context and
     raises InstallationErrors if anything goes wrong.
@@ -36,7 +26,7 @@ def parse_dependency_groups(
     try:
         return list(resolve_dependency_group(raw_dependency_groups, *groups))
     except (ValueError, TypeError, LookupError) as e:
-        raise InstallationError("[dependency-groups] resolution failed: {e}") from e
+        raise InstallationError(f"[dependency-groups] resolution failed: {e}") from e
 
 
 def _load_pyproject() -> Dict[str, Any]:

tests/unit/test_req_dependency_group.py

@@ -0,0 +1,116 @@
+import errno
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.req.req_dependency_group import parse_dependency_groups
+
+
+def test_parse_simple_dependency_groups(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    pyproject = tmp_path.joinpath("pyproject.toml")
+    pyproject.write_text(
+        """\
+[dependency-groups]
+foo = ["bar"]
+"""
+    )
+    monkeypatch.chdir(tmp_path)
+
+    result = list(parse_dependency_groups(["foo"]))
+
+    assert len(result) == 1, result
+    assert result[0] == "bar"
+
+
+def test_parse_cyclic_dependency_groups(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    pyproject = tmp_path.joinpath("pyproject.toml")
+    pyproject.write_text(
+        """\
+[dependency-groups]
+foo = [{include-group="bar"}]
+bar = [{include-group="foo"}]
+"""
+    )
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(
+        InstallationError, match=r"\[dependency-groups\] resolution failed:"
+    ) as excinfo:
+        parse_dependency_groups(["foo"])
+
+    exception = excinfo.value
+    assert (
+        "Cyclic dependency group include while resolving foo: foo -> bar, bar -> foo"
+    ) in str(exception)
+
+
+def test_parse_with_no_dependency_groups_defined(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    pyproject = tmp_path.joinpath("pyproject.toml")
+    pyproject.write_text(
+        """\
+"""
+    )
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(
+        InstallationError, match=r"\[dependency-groups\] table was missing\."
+    ):
+        parse_dependency_groups(["foo"])
+
+
+def test_parse_with_no_pyproject_file(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(InstallationError, match=r"pyproject\.toml not found\."):
+        parse_dependency_groups(["foo"])
+
+
+def test_parse_with_malformed_pyproject_file(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    pyproject = tmp_path.joinpath("pyproject.toml")
+    pyproject.write_text(
+        """\
+[dependency-groups  # no closing bracket
+foo = ["bar"]
+"""
+    )
+    monkeypatch.chdir(tmp_path)
+
+    with pytest.raises(InstallationError, match=r"Error parsing pyproject\.toml"):
+        parse_dependency_groups(["foo"])
+
+
+def test_parse_gets_unexpected_oserror(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    pyproject = tmp_path.joinpath("pyproject.toml")
+    pyproject.write_text(
+        """\
+[dependency-groups]
+foo = ["bar"]
+"""
+    )
+    monkeypatch.chdir(tmp_path)
+
+    # inject an implementation of `tomli.load()` which emits an 'OSError(EPIPE, ...)'
+    # as though we were loading from a fifo or other unusual filetype
+    def epipe_toml_load(*args: Any, **kwargs: Any) -> None:
+        raise OSError(errno.EPIPE, "Broken pipe")
+
+    monkeypatch.setattr(
+        "pip._internal.req.req_dependency_group.tomli.load", epipe_toml_load
+    )
+
+    with pytest.raises(InstallationError, match=r"Error reading pyproject\.toml"):
+        parse_dependency_groups(["foo"])