test: make pre-GUI hook integ test interpreter-portable + prove the hook ran

Addresses a PR #480 review comment on the hook fixture: `command: python` is
not a reliable interpreter name. deadline-cloud resolves a hook `command` as an
absolute path, then relative to the hooks dir, then via `shutil.which` on PATH
(deadline.client.job_bundle._hooks._executor) with no env-var expansion. A bare
`python` doesn't exist on macOS (only `python3` since the system Python 2
removal) and otherwise depends on the PATH Cinema 4D inherited, so it could fail
to resolve — and when it did, the hook silently never ran and the failure
surfaced as the three value assertions failing rather than "the hook could not
be launched".

- hooks.yaml is no longer committed. The test generates it per-run
  (_materialize_pregui_hooks_dir) with `command` = sys.executable — an absolute
  path that always resolves; pregui_hook.py needs only the stdlib, so any
  interpreter works. args references the committed script by absolute path.
- pregui_hook.py writes a marker file when DEADLINE_CLOUD_PREGUI_MARKER is set;
  the test asserts the marker up front, separating "hook never launched" from
  "hook ran but its output wasn't wired into the bundle". Value-assertion
  messages reworded to reflect that the hook is known to have run by then.
- test/AGENTS.md updated to describe the generated manifest + marker.

The generated hooks dir is a temp dir, always cleaned up; on failure actual_dir
is what stays behind for inspection, matching the rest of the suite.

Signed-off-by: Leon Li <2182521+leon-li-inspire@users.noreply.github.com>

Author: leon-li-inspire

test/AGENTS.md

@@ -374,18 +374,25 @@ behavior in this repository.
 
 **Pre-GUI hook case (`test_pre_gui_hook`):** this one does *not* use the `_CASES`
 / golden-bundle model — it's a standalone test asserting only the fields a
-pre-GUI hook owns. A hook fixture lives in `fixtures/pregui_hooks/` (a
-`hooks.yaml`, version `"1.0"`, plus `pregui_hook.py`, which reads the job
-metadata on stdin and emits `name` / `description` / `parameters` as JSON on
-stdout). The test enables `settings.allow_environment_hooks` (so the submitter
-sources `DEADLINE_HOOKS_DIR`) and `settings.auto_accept` (so hooks run without
-the Qt confirmation prompt) in the config the `deadline_farm` fixture wrote,
-points `DEADLINE_HOOKS_DIR` at the fixture via the launch env, Exports, and
-asserts the emitted `name`/`description` reached `template.yaml` and
-`deadline:priority` reached `parameter_values.yaml`. To change what the hook
-injects, edit `pregui_hook.py` and the `_HOOK_*` constants in `test_cinema4d.py`
-together (they're the paired source of truth). It has no `expected/job_bundle/`
-and never renders, so it needs no golden capture and runs on macOS too.
+pre-GUI hook owns. The hook script `fixtures/pregui_hooks/pregui_hook.py` reads
+the job metadata on stdin and emits `name` / `description` / `parameters` as JSON
+on stdout. Its `hooks.yaml` (version `"1.0"`) is *not* committed: the test
+generates it per-run (`_materialize_pregui_hooks_dir`) with `command` set to
+`sys.executable`, because deadline-cloud resolves a hook `command` via absolute
+path / hooks-dir / `shutil.which` with no env-var expansion, so a static `python`
+isn't a portable interpreter (absent on macOS; PATH-dependent everywhere) and the
+hook would silently not run. The test enables `settings.allow_environment_hooks`
+(so the submitter sources `DEADLINE_HOOKS_DIR`) and `settings.auto_accept` (so
+hooks run without the Qt confirmation prompt) in the config the `deadline_farm`
+fixture wrote, points `DEADLINE_HOOKS_DIR` at that generated dir via the launch
+env, Exports, then asserts a marker file proves the hook actually ran before
+asserting the emitted `name`/`description` reached `template.yaml` and
+`deadline:priority` reached `parameter_values.yaml` (the marker separates "hook
+never launched" from "hook ran but output wasn't wired in"). To change what the
+hook injects, edit `pregui_hook.py` and the `_HOOK_*` constants in
+`test_cinema4d.py` together (they're the paired source of truth). It has no
+`expected/job_bundle/` and never renders, so it needs no golden capture and runs
+on macOS too.
 
 ## Installer Tests
 

test/integ/fixtures/pregui_hooks/hooks.yaml

@@ -11,9 +11,13 @@
 wires ``run_pre_gui_hooks`` + ``apply_pre_gui_output`` correctly (PR #480). This case has no
 ``expected/job_bundle/`` golden dir; the assertions compare against the ``_HOOK_*`` constants in
 ``test/integ/test_cinema4d.py`` instead, so keep the emitted values in sync with those constants.
+
+The test also sets ``DEADLINE_CLOUD_PREGUI_MARKER``; when present this script writes that file, so
+the test can assert the hook actually ran (separately from asserting its output was applied).
 """
 
 import json
+import os
 import sys
 
 # Consume the metadata C4D passes on stdin (jobName, parameters, submitterName, ...). We do not
@@ -27,6 +31,18 @@
     # No usable metadata on stdin; the fixture's output does not depend on it, so continue.
     pass
 
+# Signal that this hook actually executed. The integ test points DEADLINE_CLOUD_PREGUI_MARKER at a
+# path it checks after export, so a run that yields the wrong bundle can be told apart as "the hook
+# never launched" (discovery / interpreter resolution failure) rather than "the hook ran but its
+# output wasn't wired in". Best-effort: marker I/O must never break the hook's stdout contract.
+_marker = os.environ.get("DEADLINE_CLOUD_PREGUI_MARKER")
+if _marker:
+    try:
+        with open(_marker, "w", encoding="utf-8") as _fh:
+            _fh.write("ran")
+    except OSError:
+        pass
+
 output = {
     "name": "PREGUI RAN",
     "description": "populated by pre-GUI hook",

test/integ/fixtures/pregui_hooks/pregui_hook.py

@@ -11,7 +11,7 @@
 
 import pytest
 import xa11y
-from yaml import safe_load
+from yaml import safe_dump, safe_load
 from deadline_test_fixtures.job_bundle import (
     JobBundleCase,
     assert_valid_job_bundle,
@@ -767,17 +767,50 @@ def test_job_specific_take_selection(
     )
 
 
-# The directory holding the pre-GUI hook fixture (hooks.yaml + pregui_hook.py). Pointed at by
-# DEADLINE_HOOKS_DIR when launching C4D for the hook case; gated by settings.allow_environment_hooks.
-_PREGUI_HOOKS_DIR = Path(__file__).parent / "fixtures" / "pregui_hooks"
+# The committed pre-GUI hook script. Its hooks.yaml is NOT committed: it is generated per-run by
+# _materialize_pregui_hooks_dir so the hook's `command` can be this interpreter's absolute path
+# (see that helper for why a static `command` is not portable). DEADLINE_HOOKS_DIR points at the
+# generated dir; the run is gated by settings.allow_environment_hooks.
+_PREGUI_HOOK_SCRIPT = Path(__file__).parent / "fixtures" / "pregui_hooks" / "pregui_hook.py"
 
-# The values fixtures/pregui_hooks/pregui_hook.py emits. Kept next to the test as the single source
-# of truth for the assertions; must match that script.
+# The values pregui_hook.py emits. Kept next to the test as the single source of truth for the
+# assertions; must match that script.
 _HOOK_JOB_NAME = "PREGUI RAN"
 _HOOK_DESCRIPTION = "populated by pre-GUI hook"
 _HOOK_PRIORITY = 88
 
 
+def _materialize_pregui_hooks_dir(dest: Path) -> None:
+    """Write a ``hooks.yaml`` under ``dest`` that runs the committed ``pregui_hook.py`` with the
+    interpreter currently running the tests (``sys.executable``).
+
+    The manifest cannot be a static committed file with a portable ``command``. deadline-cloud
+    resolves a hook ``command`` as an absolute path, then relative to the hooks dir, then via
+    ``shutil.which`` on PATH (``deadline.client.job_bundle._hooks._executor``) — it does not expand
+    environment variables. A bare ``python`` is not a reliable interpreter name: on macOS only
+    ``python3`` exists (the system ``python`` went away with Python 2), and on every platform
+    whether it resolves depends on the PATH Cinema 4D happened to inherit, not on this fixture. When
+    it fails to resolve, the hook silently never runs and the failure surfaces as the value
+    assertions below failing rather than a clear "hook could not be launched".
+
+    Writing ``sys.executable`` (an absolute path that exists on this machine — and ``pregui_hook.py``
+    needs only the stdlib, so any interpreter works) makes the hook resolve on every platform.
+    ``args`` references the committed script by absolute path, so only ``hooks.yaml`` lives here.
+    """
+    dest.mkdir(parents=True, exist_ok=True)
+    manifest = {
+        "version": "1.0",
+        "preGUI": [
+            {
+                "command": sys.executable,
+                "args": [str(_PREGUI_HOOK_SCRIPT)],
+                "timeout": 60,
+            }
+        ],
+    }
+    (dest / "hooks.yaml").write_text(safe_dump(manifest, sort_keys=False), encoding="utf-8")
+
+
 def _bundle_parameter_values(actual_dir: Path) -> dict:
     """Read the exported bundle's parameter_values.yaml into a {name: value} dict."""
     params_file = actual_dir / "parameter_values.yaml"
@@ -795,9 +828,10 @@ def test_pre_gui_hook(
     This is the GUI counterpart to the headless ``test_pre_gui_hooks`` unit tests: those check the
     ``apply_pre_gui_output`` mapping in isolation, whereas this drives the *real* submitter end to
     end and proves the wiring holds through an actual export. It launches Cinema 4D with
-    ``DEADLINE_HOOKS_DIR`` pointing at ``fixtures/pregui_hooks`` and ``allow_environment_hooks`` /
-    ``auto_accept`` enabled, so the shipped submitter runs the hook (``run_pre_gui_hooks``) before
-    building the dialog and applies its output (``apply_pre_gui_output``). The hook emits a fixed
+    ``DEADLINE_HOOKS_DIR`` pointing at a per-run hooks dir (see ``_materialize_pregui_hooks_dir``)
+    and ``allow_environment_hooks`` / ``auto_accept`` enabled, so the shipped submitter runs the
+    hook (``run_pre_gui_hooks``) before building the dialog and applies its output
+    (``apply_pre_gui_output``). A marker file proves the hook actually ran. The hook emits a fixed
     name, description, and ``deadline:priority``; the same Export path the render cases use then
     writes a job bundle, and we assert those three values survived into it:
 
@@ -815,44 +849,67 @@ def test_pre_gui_hook(
 
     scene_path = _build_cinema4d_scene(cinema4d_location, case_folder, actual_dir, case)
 
-    # Enable the env-hook path in the config the fixture wrote, and point C4D at the hooks dir.
+    # Enable the env-hook path in the config the fixture wrote.
     _enable_environment_hooks(deadline_farm["env_overlay"])
 
-    _export_job_bundle_via_submitter(
-        cinema4d_location=cinema4d_location,
-        scene_path=scene_path,
-        job_bundle_generated=actual_dir,
-        deadline_farm=deadline_farm,
-        configure=None,
-        extra_env={"DEADLINE_HOOKS_DIR": str(_PREGUI_HOOKS_DIR)},
-    )
+    # Generate the hooks dir (so `command` is sys.executable, resolvable on every platform) and
+    # give the hook a marker path so we can prove it actually ran. The dir is temporary and always
+    # cleaned up; on failure `actual_dir` (below) is what stays behind for inspection.
+    hooks_dir = Path(tempfile.mkdtemp(prefix="c4d-pregui-hooks-"))
+    marker_path = hooks_dir / "hook_ran.marker"
+    try:
+        _materialize_pregui_hooks_dir(hooks_dir)
+
+        _export_job_bundle_via_submitter(
+            cinema4d_location=cinema4d_location,
+            scene_path=scene_path,
+            job_bundle_generated=actual_dir,
+            deadline_farm=deadline_farm,
+            configure=None,
+            extra_env={
+                "DEADLINE_HOOKS_DIR": str(hooks_dir),
+                "DEADLINE_CLOUD_PREGUI_MARKER": str(marker_path),
+            },
+        )
 
-    # The submitter reached the mock, not real AWS. The hook itself is a local subprocess that runs
-    # before any AWS call, so no new mock routes are needed; still confirm nothing hit an unmocked
-    # route (a hook misfire that changed the submit path would surface here).
-    backend = deadline_farm["backend"]
-    log(f"mock backend call_counts: {dict(backend.call_counts)}")
-    assert (
-        backend.unmatched_requests == []
-    ), f"submitter hit routes the mock doesn't implement: {backend.unmatched_requests}"
+        # The submitter reached the mock, not real AWS. The hook itself is a local subprocess that
+        # runs before any AWS call, so no new mock routes are needed; still confirm nothing hit an
+        # unmocked route (a hook misfire that changed the submit path would surface here).
+        backend = deadline_farm["backend"]
+        log(f"mock backend call_counts: {dict(backend.call_counts)}")
+        assert (
+            backend.unmatched_requests == []
+        ), f"submitter hit routes the mock doesn't implement: {backend.unmatched_requests}"
+
+        # Prove the hook subprocess ran at all before trusting the exported values. This separates
+        # "the hook never launched" (discovery / interpreter resolution failure) from "the hook ran
+        # but its output wasn't wired into the bundle" — the value assertions below can't tell those
+        # two apart on their own.
+        assert marker_path.is_file(), (
+            f"pre-GUI hook never ran: no marker at {marker_path} (DEADLINE_HOOKS_DIR={hooks_dir}). "
+            "The submitter didn't execute the hook subprocess — look at hook discovery / "
+            "interpreter resolution, not the output-mapping wiring."
+        )
 
-    # The exported bundle must carry the hook's output.
-    assert_valid_job_bundle(actual_dir / "template.yaml")
-    template = safe_load((actual_dir / "template.yaml").read_text(encoding="utf-8"))
-    params = _bundle_parameter_values(actual_dir)
+        # The exported bundle must carry the hook's output.
+        assert_valid_job_bundle(actual_dir / "template.yaml")
+        template = safe_load((actual_dir / "template.yaml").read_text(encoding="utf-8"))
+        params = _bundle_parameter_values(actual_dir)
 
-    assert template.get("name") == _HOOK_JOB_NAME, (
-        f"pre-GUI hook name did not reach the bundle: template name is "
-        f"{template.get('name')!r}, expected {_HOOK_JOB_NAME!r}"
-    )
-    assert template.get("description") == _HOOK_DESCRIPTION, (
-        f"pre-GUI hook description did not reach the bundle: template description is "
-        f"{template.get('description')!r}, expected {_HOOK_DESCRIPTION!r}"
-    )
-    assert params.get("deadline:priority") == _HOOK_PRIORITY, (
-        f"pre-GUI hook priority did not reach the bundle: parameter_values has "
-        f"{params.get('deadline:priority')!r}, expected {_HOOK_PRIORITY}"
-    )
+        assert template.get("name") == _HOOK_JOB_NAME, (
+            f"pre-GUI hook ran but its name did not reach the bundle: template name is "
+            f"{template.get('name')!r}, expected {_HOOK_JOB_NAME!r}"
+        )
+        assert template.get("description") == _HOOK_DESCRIPTION, (
+            f"pre-GUI hook ran but its description did not reach the bundle: template description is "
+            f"{template.get('description')!r}, expected {_HOOK_DESCRIPTION!r}"
+        )
+        assert params.get("deadline:priority") == _HOOK_PRIORITY, (
+            f"pre-GUI hook ran but its priority did not reach the bundle: parameter_values has "
+            f"{params.get('deadline:priority')!r}, expected {_HOOK_PRIORITY}"
+        )
 
-    # Clean up if the test was successful
-    rmtree(actual_dir, ignore_errors=True)
+        # Clean up if the test was successful
+        rmtree(actual_dir, ignore_errors=True)
+    finally:
+        rmtree(hooks_dir, ignore_errors=True)