Merge branch 'main' into run-fix-nx-command-error

* main:
  Remove the use of `sh` in tests (theskumar#612)

# Conflicts:
#	tests/test_cli.py

Author: theskumar

requirements.txt

@@ -3,7 +3,6 @@ click
 ipython
 pytest-cov
 pytest>=3.9
-sh>=2
 tox
 wheel
 ruff

tests/test_cli.py

@@ -1,32 +1,13 @@
 import os
-import subprocess
-import sys
 from pathlib import Path
-from typing import Optional, Sequence
+from typing import Optional
 
 import pytest
 
 import dotenv
 from dotenv.cli import cli as dotenv_cli
 from dotenv.version import __version__
-
-if sys.platform != "win32":
-    import sh
-
-
-def invoke_sub(args: Sequence[str]) -> subprocess.CompletedProcess:
-    """
-    Invoke the `dotenv` CLI in a subprocess.
-
-    This is necessary to test subcommands like `dotenv run` that replace the
-    current process.
-    """
-
-    return subprocess.run(
-        ["dotenv", *args],
-        capture_output=True,
-        text=True,
-    )
+from tests.test_lib import check_process, run_dotenv
 
 
 @pytest.mark.parametrize(
@@ -192,122 +173,123 @@ def test_set_no_file(cli):
     assert "Missing argument" in result.output
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="sh module doesn't support Windows")
 def test_get_default_path(tmp_path):
-    with sh.pushd(tmp_path):
-        (tmp_path / ".env").write_text("a=b")
+    (tmp_path / ".env").write_text("A=x")
 
-        result = sh.dotenv("get", "a")
+    result = run_dotenv(["get", "A"], cwd=tmp_path)
 
-        assert result == "b\n"
+    check_process(result, exit_code=0, stdout="x\n")
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="sh module doesn't support Windows")
 def test_run(tmp_path):
-    with sh.pushd(tmp_path):
-        (tmp_path / ".env").write_text("a=b")
+    (tmp_path / ".env").write_text("A=x")
 
-        result = sh.dotenv("run", "printenv", "a")
+    result = run_dotenv(["run", "printenv", "A"], cwd=tmp_path)
 
-        assert result == "b\n"
+    check_process(result, exit_code=0, stdout="x\n")
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="sh module doesn't support Windows")
 def test_run_with_existing_variable(tmp_path):
-    with sh.pushd(tmp_path):
-        (tmp_path / ".env").write_text("a=b")
-        env = dict(os.environ)
-        env.update({"LANG": "en_US.UTF-8", "a": "c"})
+    (tmp_path / ".env").write_text("A=x")
+    env = dict(os.environ)
+    env.update({"LANG": "en_US.UTF-8", "A": "y"})
 
-        result = sh.dotenv("run", "printenv", "a", _env=env)
+    result = run_dotenv(["run", "printenv", "A"], cwd=tmp_path, env=env)
 
-        assert result == "b\n"
+    check_process(result, exit_code=0, stdout="x\n")
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="sh module doesn't support Windows")
 def test_run_with_existing_variable_not_overridden(tmp_path):
-    with sh.pushd(tmp_path):
-        (tmp_path / ".env").write_text("a=b")
-        env = dict(os.environ)
-        env.update({"LANG": "en_US.UTF-8", "a": "c"})
+    (tmp_path / ".env").write_text("A=x")
+    env = dict(os.environ)
+    env.update({"LANG": "en_US.UTF-8", "A": "C"})
 
-        result = sh.dotenv("run", "--no-override", "printenv", "a", _env=env)
+    result = run_dotenv(
+        ["run", "--no-override", "printenv", "A"], cwd=tmp_path, env=env
+    )
 
-        assert result == "c\n"
+    check_process(result, exit_code=0, stdout="C\n")
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="sh module doesn't support Windows")
 def test_run_with_none_value(tmp_path):
-    with sh.pushd(tmp_path):
-        (tmp_path / ".env").write_text("a=b\nc")
+    (tmp_path / ".env").write_text("A=x\nc")
 
-        result = sh.dotenv("run", "printenv", "a")
+    result = run_dotenv(["run", "printenv", "A"], cwd=tmp_path)
 
-        assert result == "b\n"
+    check_process(result, exit_code=0, stdout="x\n")
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="sh module doesn't support Windows")
-def test_run_with_other_env(dotenv_path):
-    dotenv_path.write_text("a=b")
+def test_run_with_other_env(dotenv_path, tmp_path):
+    dotenv_path.write_text("A=x")
 
-    result = sh.dotenv("--file", dotenv_path, "run", "printenv", "a")
+    result = run_dotenv(
+        ["--file", str(dotenv_path), "run", "printenv", "A"],
+        cwd=tmp_path,
+    )
 
-    assert result == "b\n"
+    check_process(result, exit_code=0, stdout="x\n")
 
 
-def test_run_without_cmd(cli):
-    result = cli.invoke(dotenv_cli, ["run"])
+def test_run_without_cmd(tmp_path):
+    result = run_dotenv(["run"], cwd=tmp_path)
 
-    assert result.exit_code == 2
-    assert "Invalid value for '-f'" in result.output
+    check_process(result, exit_code=2)
+    assert "Invalid value for '-f'" in result.stderr
 
 
-def test_run_with_invalid_cmd(cli, dotenv_path):
-    result = cli.invoke(dotenv_cli, ["--file", dotenv_path, "run", "i_do_not_exist"])
+def test_run_with_invalid_cmd(dotenv_path, tmp_path):
+    result = run_dotenv(
+        ["--file", str(dotenv_path), "run", "i_do_not_exist"],
+        cwd=tmp_path,
+    )
 
-    assert result.exit_code == 1
-    assert "Command not found: i_do_not_exist" in result.output
+    check_process(result, exit_code=1)
+    assert "Command not found: i_do_not_exist" in result.stderr
 
 
-def test_run_with_env_missing_and_invalid_cmd(cli):
+def test_run_with_env_missing_and_invalid_cmd(tmp_path):
     """
     Check that an .env file missing takes precedence over a command not found error.
     """
 
-    result = cli.invoke(dotenv_cli, ["run", "i_do_not_exist"])
+    result = run_dotenv(["run", "i_do_not_exist"], cwd=tmp_path)
 
-    assert result.exit_code == 2
-    assert "Invalid value for '-f'" in result.output
+    check_process(result, exit_code=2)
+    assert "Invalid value for '-f'" in result.stderr
 
 
-def test_run_with_version(cli):
-    result = cli.invoke(dotenv_cli, ["--version"])
+def test_run_with_version(tmp_path):
+    result = run_dotenv(["--version"], cwd=tmp_path)
 
-    assert result.exit_code == 0
-    assert result.output.strip().endswith(__version__)
+    check_process(result, exit_code=0)
+    assert result.stdout.strip().endswith(__version__)
 
 
-def test_run_with_command_flags(dotenv_path):
+def test_run_with_command_flags(dotenv_path, tmp_path):
     """
     Check that command flags passed after `dotenv run` are not interpreted.
 
     Here, we want to run `printenv --version`, not `dotenv --version`.
     """
 
-    result = invoke_sub(["--file", dotenv_path, "run", "printenv", "--version"])
+    result = run_dotenv(
+        ["--file", str(dotenv_path), "run", "printenv", "--version"],
+        cwd=tmp_path,
+    )
 
-    assert result.returncode == 0
+    check_process(result, exit_code=0)
     assert result.stdout.strip().startswith("printenv ")
 
 
-def test_run_with_dotenv_and_command_flags(cli, dotenv_path):
+def test_run_with_dotenv_and_command_flags(dotenv_path, tmp_path):
     """
     Check that dotenv flags supersede command flags.
     """
 
-    result = invoke_sub(
-        ["--version", "--file", dotenv_path, "run", "printenv", "--version"]
+    result = run_dotenv(
+        ["--version", "--file", str(dotenv_path), "run", "printenv", "--version"],
+        cwd=tmp_path,
     )
 
-    assert result.returncode == 0
+    check_process(result, exit_code=0)
     assert result.stdout.strip().startswith("dotenv, version")

tests/test_lib.py

@@ -0,0 +1,46 @@
+import subprocess
+from pathlib import Path
+from typing import Sequence
+
+
+def run_dotenv(
+    args: Sequence[str],
+    cwd: str | Path | None = None,
+    env: dict | None = None,
+) -> subprocess.CompletedProcess:
+    """
+    Run the `dotenv` CLI in a subprocess with the given arguments.
+    """
+
+    process = subprocess.run(
+        ["dotenv", *args],
+        capture_output=True,
+        text=True,
+        cwd=cwd,
+        env=env,
+    )
+
+    return process
+
+
+def check_process(
+    process: subprocess.CompletedProcess,
+    exit_code: int,
+    stdout: str | None = None,
+):
+    """
+    Check that the process completed with the expected exit code and output.
+
+    This provides better error messages than directly checking the attributes.
+    """
+
+    assert process.returncode == exit_code, (
+        f"Unexpected exit code {process.returncode} (expected {exit_code})\n"
+        f"stdout:\n{process.stdout}\n"
+        f"stderr:\n{process.stderr}"
+    )
+
+    if stdout is not None:
+        assert process.stdout == stdout, (
+            f"Unexpected output: {process.stdout.strip()!r} (expected {stdout!r})"
+        )

tests/test_main.py

@@ -2,6 +2,7 @@
 import logging
 import os
 import stat
+import subprocess
 import sys
 import textwrap
 from unittest import mock
@@ -10,9 +11,6 @@
 
 import dotenv
 
-if sys.platform != "win32":
-    import sh
-
 
 def test_set_key_no_file(tmp_path):
     nx_path = tmp_path / "nx"
@@ -483,7 +481,6 @@ def test_load_dotenv_file_stream(dotenv_path):
     assert os.environ == {"a": "b"}
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="sh module doesn't support Windows")
 def test_load_dotenv_in_current_dir(tmp_path):
     dotenv_path = tmp_path / ".env"
     dotenv_path.write_bytes(b"a=b")
@@ -499,9 +496,14 @@ def test_load_dotenv_in_current_dir(tmp_path):
     )
     os.chdir(tmp_path)
 
-    result = sh.Command(sys.executable)(code_path)
+    result = subprocess.run(
+        [sys.executable, str(code_path)],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
 
-    assert result == "b\n"
+    assert result.stdout == "b\n"
 
 
 def test_dotenv_values_file(dotenv_path):