WIP: Re-work chaining parametrize arguments for ease of use

Author: MHendricks

tests/test_env_var_chaining.py

@@ -1,56 +1,106 @@
+from __future__ import annotations
+
+import copy
 import json
 import re
 import subprocess
+import sys
+from dataclasses import dataclass, field
 from pathlib import Path
 
 import pytest
 
 
-def generate_reference_tests():
-    # For each test .json file, create a test for each supported shell type.
-    reference_dir = Path(__file__).parent / "env_chaining"
-    references = []
-    ids = []
-    for ref in reference_dir.glob("*.json"):
-        plat = ref.name.split("-")[0]
-        if plat == "windows":
-            shells = ["bash_win", "bat", "ps1"]
-        else:
-            shells = ["bash_linux"]
-        for shell in shells:
-            references.append((shell, ref))
+@dataclass
+class FileRef:
+    path: Path
+    name: str = field(init=False)
+    shell: str | None = field(default=None)
+    platform: str = field(init=False)
+    distros: list = field(init=False)
+    alias: str = field(init=False)
+    _parser = re.compile(
+        r"(?P<platform>[^-]+)-(?P<distros>[^-]+)-(?P<alias>[^.]+).json"
+    )
 
-    # Ensure consistent test sorting across all platforms
-    references = sorted(references)
-    for a, b in references:
-        ids.append(f"{a},{b.name}")
-    return references, ids
+    def __post_init__(self) -> None:
+        if not hasattr(self, "name"):
+            self.name = self.path.stem
+            match = self._parser.match(self.path.name)
+            if not match:
+                raise ValueError(f"Invalid filename: {self.path}")
+            kwargs = match.groupdict()
+            self.platform = kwargs["platform"]
+            self.distros = kwargs["distros"].split(",")
+            self.alias = kwargs["alias"]
 
+    @classmethod
+    def from_glob(cls, path, glob_str="*.json"):
+        ret = []
+        for filename in path.glob(glob_str):
+            ret.append(cls(filename))
+        return ret
 
-references, ids = generate_reference_tests()
+    @classmethod
+    def shell_matrix(cls, file_refs, shells: dict[str, list]) -> list:
+        ret = []
+        for file_ref in file_refs:
+            plat_shells = shells.get(file_ref.platform, [])
+            for shell in plat_shells:
+                ref = copy.copy(file_ref)
+                ref.shell = shell
+                ret.append(ref)
+        ret.sort(key=lambda i: repr(i))
+        return ret
 
+    def __repr__(self) -> str:
+        if self.shell:
+            return f"{self.shell},{self.name}"
+        return self.name
 
-@pytest.mark.parametrize("shell,reference", references, ids=ids)
-def test_chaining(shell, reference, config_root, tmp_path, run_hab):
 
-    match = re.match(
-        r"(?P<platform>[^-]+)-(?P<distros>[^-]+)-(?P<alias>[^.]+).json", reference.name
-    )
-    kwargs = match.groupdict()
+references = FileRef.from_glob(Path(__file__).parent / "env_chaining")
+shell_references = FileRef.shell_matrix(
+    references, {"windows": ["bash_win", "bat", "ps1"], "linux": ["bash_linux"]}
+)
 
+
+@pytest.mark.parametrize("reference", shell_references, ids=lambda f: repr(f))
+def test_chaining(reference, config_root, tmp_path, run_hab):
     # Skip tests that will not run on the current platform
-    run_hab.skip_wrong_platform(shell)
+    run_hab.skip_wrong_platform(reference.shell)
 
     runner = run_hab(config_root, tmp_path, stderr=subprocess.PIPE)
     sub_cmd = []
-    for d in kwargs["distros"].split(","):
+    for d in reference.distros:
         sub_cmd.extend(["-r", f"var-chain-{d}"])
-    sub_cmd += ["launch", ",", kwargs["alias"]]
-    proc = runner.run_in_shell(shell, sub_cmd)
+    sub_cmd += ["launch", ",", reference.alias]
+    proc = runner.run_in_shell(reference.shell, sub_cmd)
 
     # Check that the env vars were set as expected
     assert proc.returncode == 0
 
-    check = json.load(reference.open())
+    check = json.load(reference.path.open())
     result = json.loads(proc.stdout)
     assert result == check
+
+
+@pytest.mark.parametrize("reference", references, ids=lambda f: repr(f))
+def test_launch(habcached_resolver, reference):
+    if sys.platform.startswith("linux"):
+        if reference.platform != "linux":
+            raise pytest.skip("test doesn't apply on linux")
+    elif sys.platform == "win32":
+        if reference.platform != "windows":
+            raise pytest.skip("test doesn't apply on windows")
+
+    forced_requirements = []
+    for d in reference.distros:
+        forced_requirements.extend([f"var-chain-{d}"])
+    cfg = habcached_resolver.resolve(",", forced_requirements=forced_requirements)
+
+    proc = cfg.launch(reference.alias, args=None, blocking=True, stderr=subprocess.PIPE)
+    assert proc.returncode == 0
+    check = json.load(reference.path.open())
+    result = json.loads(proc.output_stdout)
+    assert result == check