tests/_internal/subprocess(test[typing]): Refine SubprocessCommand test types

why: Reduce broad typing in test fixtures without changing behavior.
what:
- Replace varargs fixture shape with explicit cmd_args
- Type expected_result as SubprocessCommand
- Add CmdArgs alias for clearer argument intent

Author: tony

tests/_internal/subprocess/test_SubprocessCommand.py

@@ -8,12 +8,17 @@
 import pytest
 
 from libvcs._internal.subprocess import SubprocessCommand
+from libvcs._internal.types import StrOrBytesPath
 
 if t.TYPE_CHECKING:
     import pathlib
 
 
-def idfn(val: t.Any) -> str:
+CmdArgs = StrOrBytesPath | t.Sequence[StrOrBytesPath]
+Kwargs = dict[str, t.Any]
+
+
+def idfn(val: CmdArgs | Kwargs | SubprocessCommand | None) -> str:
     """Test ID naming function for SubprocessCommand py.test parametrize."""
     if isinstance(val, list):
         if len(val):
@@ -24,28 +29,36 @@ def idfn(val: t.Any) -> str:
 
 
 @pytest.mark.parametrize(
-    ("args", "kwargs", "expected_result"),
+    ("cmd_args", "kwargs", "expected_result"),
     [
-        (["ls"], {}, SubprocessCommand("ls")),
-        ([["ls", "-l"]], {}, SubprocessCommand(["ls", "-l"])),
-        ([], {"args": ["ls", "-l"]}, SubprocessCommand(["ls", "-l"])),
-        (["ls -l"], {"shell": True}, SubprocessCommand("ls -l", shell=True)),
-        ([], {"args": "ls -l", "shell": True}, SubprocessCommand("ls -l", shell=True)),
+        ("ls", {}, SubprocessCommand("ls")),
+        (["ls", "-l"], {}, SubprocessCommand(["ls", "-l"])),
+        (None, {"args": ["ls", "-l"]}, SubprocessCommand(["ls", "-l"])),
+        ("ls -l", {"shell": True}, SubprocessCommand("ls -l", shell=True)),
+        (
+            None,
+            {"args": "ls -l", "shell": True},
+            SubprocessCommand("ls -l", shell=True),
+        ),
         (
-            [],
+            None,
             {"args": ["ls", "-l"], "shell": True},
             SubprocessCommand(["ls", "-l"], shell=True),
         ),
     ],
     ids=idfn,
 )
 def test_init(
-    args: list[t.Any],
-    kwargs: dict[str, t.Any],
-    expected_result: t.Any,
+    cmd_args: CmdArgs | None,
+    kwargs: Kwargs,
+    expected_result: SubprocessCommand,
 ) -> None:
     """Test SubprocessCommand via list + kwargs, assert attributes."""
-    cmd = SubprocessCommand(*args, **kwargs)
+    cmd = (
+        SubprocessCommand(cmd_args, **kwargs)
+        if cmd_args is not None
+        else SubprocessCommand(**kwargs)
+    )
     assert cmd == expected_result
 
     # Attributes in cmd should match what's passed in
@@ -57,116 +70,116 @@ def test_init(
     assert proc.returncode == 0
 
 
-FIXTURES = [
-    [["ls"], {}, SubprocessCommand("ls")],
-    [[["ls", "-l"]], {}, SubprocessCommand(["ls", "-l"])],
+FIXTURES: list[tuple[CmdArgs, Kwargs, SubprocessCommand]] = [
+    ("ls", {}, SubprocessCommand("ls")),
+    (["ls", "-l"], {}, SubprocessCommand(["ls", "-l"])),
 ]
 
 
 @pytest.mark.parametrize(
-    ("args", "kwargs", "expected_result"),
+    ("cmd_args", "kwargs", "expected_result"),
     FIXTURES,
     ids=idfn,
 )
 def test_init_and_Popen(
-    args: list[t.Any],
-    kwargs: dict[str, t.Any],
-    expected_result: t.Any,
+    cmd_args: CmdArgs,
+    kwargs: Kwargs,
+    expected_result: SubprocessCommand,
 ) -> None:
     """Test SubprocessCommand with Popen."""
-    cmd = SubprocessCommand(*args, **kwargs)
+    cmd = SubprocessCommand(cmd_args, **kwargs)
     assert cmd == expected_result
 
     cmd_proc = cmd.Popen()
     cmd_proc.communicate()
     assert cmd_proc.returncode == 0
 
-    proc = subprocess.Popen(*args, **kwargs)
+    proc = subprocess.Popen(cmd_args, **kwargs)
     proc.communicate()
     assert proc.returncode == 0
 
 
 @pytest.mark.parametrize(
-    ("args", "kwargs", "expected_result"),
+    ("cmd_args", "kwargs", "expected_result"),
     FIXTURES,
     ids=idfn,
 )
 def test_init_and_Popen_run(
-    args: list[t.Any],
-    kwargs: dict[str, t.Any],
-    expected_result: t.Any,
+    cmd_args: CmdArgs,
+    kwargs: Kwargs,
+    expected_result: SubprocessCommand,
 ) -> None:
     """Test SubprocessCommand with run."""
-    cmd = SubprocessCommand(*args, **kwargs)
+    cmd = SubprocessCommand(cmd_args, **kwargs)
     assert cmd == expected_result
 
     cmd_proc = cmd.Popen()
     cmd_proc.communicate()
     assert cmd_proc.returncode == 0
 
-    proc = subprocess.run(*args, **kwargs, check=False)
+    proc = subprocess.run(cmd_args, **kwargs, check=False)
     assert proc.returncode == 0
 
 
 @pytest.mark.parametrize(
-    ("args", "kwargs", "expected_result"),
+    ("cmd_args", "kwargs", "expected_result"),
     FIXTURES,
     ids=idfn,
 )
 def test_init_and_check_call(
-    args: list[t.Any],
-    kwargs: dict[str, t.Any],
-    expected_result: t.Any,
+    cmd_args: CmdArgs,
+    kwargs: Kwargs,
+    expected_result: SubprocessCommand,
 ) -> None:
     """Test SubprocessCommand with Popen.check_call."""
-    cmd = SubprocessCommand(*args, **kwargs)
+    cmd = SubprocessCommand(cmd_args, **kwargs)
     assert cmd == expected_result
 
     return_code = cmd.check_call()
     assert return_code == 0
 
-    proc = subprocess.check_call(*args, **kwargs)
+    proc = subprocess.check_call(cmd_args, **kwargs)
     assert proc == return_code
 
 
 @pytest.mark.parametrize(
-    ("args", "kwargs", "expected_result"),
+    ("cmd_args", "kwargs", "expected_result"),
     FIXTURES,
 )
 def test_init_and_check_output(
-    args: list[t.Any],
-    kwargs: dict[str, t.Any],
-    expected_result: t.Any,
+    cmd_args: CmdArgs,
+    kwargs: Kwargs,
+    expected_result: SubprocessCommand,
 ) -> None:
     """Test SubprocessCommand with Popen.check_output."""
-    cmd = SubprocessCommand(*args, **kwargs)
+    cmd = SubprocessCommand(cmd_args, **kwargs)
     assert cmd == expected_result
 
     return_output = cmd.check_output()
     assert isinstance(return_output, bytes)
 
-    proc = subprocess.check_output(*args, **kwargs)
+    proc = subprocess.check_output(cmd_args, **kwargs)
     assert proc == return_output
 
 
 @pytest.mark.parametrize(
-    ("args", "kwargs", "run_kwargs"),
+    ("cmd_args", "kwargs", "run_kwargs"),
     [
-        (["ls"], {}, {}),
-        ([["ls", "-l"]], {}, {}),
-        ([["ls", "-al"]], {}, {"stdout": subprocess.DEVNULL}),
+        ("ls", {}, {}),
+        (["ls", "-l"], {}, {}),
+        (["ls", "-al"], {}, {"stdout": subprocess.DEVNULL}),
     ],
     ids=idfn,
 )
 def test_run(
     tmp_path: pathlib.Path,
-    args: list[t.Any],
-    kwargs: dict[str, t.Any],
-    run_kwargs: dict[str, t.Any],
+    cmd_args: CmdArgs,
+    kwargs: Kwargs,
+    run_kwargs: Kwargs,
 ) -> None:
     """Test SubprocessCommand.run()."""
     kwargs["cwd"] = tmp_path
-    cmd = SubprocessCommand(*args, **kwargs)
+    cmd = SubprocessCommand(cmd_args, **kwargs)
     response = cmd.run(**run_kwargs)
 
     assert response.returncode == 0