Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

nushell/tests/work-scope.test.py

Raw
"""Isolated production wrapper generation and launch routing; no user systemd calls."""
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile

MODULES = Path(__file__).resolve().parents[1] / "modules"
NU = shutil.which("nu")
assert NU, "nu is required"
# Resolve a version-manager shim before replacing HOME/PATH.
NU = subprocess.check_output([NU, "--no-config-file", "-c", "$nu.current-exe"], text=True).strip()

with tempfile.TemporaryDirectory(prefix="nushell-work-scope-") as temporary:
    root = Path(temporary)
    config = root / "config"
    modules = config / "modules"
    modules.mkdir(parents=True)
    for name in ["commands.nu", "work_scope.nu", "pi.nu", "lib.nu"]:
        shutil.copy2(MODULES / name, modules / name)
    bin_dir = root / "bin"
    bin_dir.mkdir()
    scope_log = root / "scope.json"
    session_root = root / "sessions"
    session_root.mkdir()
    env = dict(os.environ, HOME=str(root), USERPROFILE=str(root), PATH=str(bin_dir),
               XDG_CONFIG_HOME=str(root / "xdg-config"), XDG_DATA_HOME=str(root / "data"),
               XDG_DATA_DIRS=str(root / "data"), XDG_CACHE_HOME=str(root / "cache"),
               PI_CODING_AGENT_SESSION_DIR=str(session_root), SCOPE_TEST_LOG=str(scope_log))

    def executable(name, body):
        path = bin_dir / name
        path.write_text(f"#!{sys.executable}\n" + body)
        path.chmod(0o700)
        return path

    for name in ["bun", "pi"]:
        executable(name, "import json, os, sys\nprint(json.dumps(sys.argv[1:]))\nsys.exit(int(os.environ.get('SCOPE_TEST_EXIT', '0')))\n")
    systemd = executable("systemd-run", "import json, os, pathlib, sys\nargs = sys.argv[1:]\npathlib.Path(os.environ['SCOPE_TEST_LOG']).write_text(json.dumps(args))\nwhile args and args[0].startswith('--'): args.pop(0)\nos.execvp(args[0], args)\n")

    def nu(code, expected=0):
        result = subprocess.run([NU, "--no-config-file", "--config-home", str(config), "-c", code],
                                env=env, text=True, capture_output=True, timeout=15)
        assert result.returncode == expected, (result.returncode, result.stdout, result.stderr)
        if expected == 0:
            assert not result.stderr, result.stderr
        return result

    imports = f"use '{modules / 'commands.nu'}' *; use '{modules / 'pi.nu'}'; "
    nu(imports + "generate-scoped-externals")
    generated = config / "autoload" / "90-work-scope.nu"
    assert generated.exists()
    stamp = generated.stat().st_mtime_ns
    nu(imports + "generate-scoped-externals")
    assert generated.stat().st_mtime_ns == stamp, "unchanged wrappers must not be rewritten"
    # Source, rather than merely inspect, the generated production definitions.
    launch = f"source '{generated}'; use '{modules / 'pi.nu'}'; "
    args = "install 'npm:example' --help -- 'a b' 0001 true"
    expected_args = ["install", "npm:example", "--help", "--", "a b", "0001", "true"]
    prefix = ["--user", "--scope", "--same-dir", "--collect", "--quiet", "--slice=work.slice"]
    for name in ["bun", "pi"]:
        result = nu(launch + name + " " + args)
        assert json.loads(result.stdout) == expected_args
        assert json.loads(scope_log.read_text()) == prefix + [name] + expected_args
        env["SCOPE_TEST_EXIT"] = "17"
        nu(launch + name + " " + args, expected=17)
        del env["SCOPE_TEST_EXIT"]

    # Native Pi subcommands never launch the external executable or enter a scope.
    scope_log.unlink()
    browser = "def 'tui run' [] { tui debug --size [80 8] --keys [enter] | ignore }; "
    nu(browser + launch + "pi sessions")
    assert not scope_log.exists()

    # Fail closed on both custom subcommands and aliases before replacing output.
    before = generated.read_bytes()
    for conflict in ["def 'bun custom' [] {}", "alias bun = ^bun"]:
        failed = nu(imports + conflict + "; generate-scoped-externals", expected=1)
        assert "Refusing to wrap bun" in failed.stderr
        assert generated.read_bytes() == before

    # Exercise Nu's real login/autoload ordering, including a stale Pi wrapper
    # from the previous generator. Never source the user's real login or secrets.
    # Full historical autoload snapshot: all 17 wrappers, not only Pi.
    legacy = (Path(__file__).parent / "fixtures" / "legacy-work-scope.nu").read_text()
    generated.write_text(legacy)
    (config / "config.nu").write_text("$env.config.show_banner = false\n")
    (config / "login.nu").write_text(browser + imports + "generate-scoped-externals\n")

    def startup(code):
        result = subprocess.run([NU, "--config-home", str(config), "--login", "--execute", code + "; exit"],
                                env=env, text=True, capture_output=True, timeout=15)
        assert result.returncode == 0, (result.returncode, result.stdout, result.stderr)
        assert not result.stderr, result.stderr
        return result

    for cycle in [1, 2]:
        scope_log.unlink(missing_ok=True)
        assert json.loads(startup("pi " + args).stdout) == expected_args
        assert json.loads(scope_log.read_text()) == prefix + ["pi"] + expected_args
        assert generated.read_bytes() == before, f"startup {cycle} failed to regenerate production wrappers"
        scope_log.unlink()
        startup("pi sessions")
        assert not scope_log.exists(), "autoload overrode the native session browser"
        assert json.loads(startup("bun " + args).stdout) == expected_args
        assert json.loads(scope_log.read_text()) == prefix + ["bun"] + expected_args
    scope_log.unlink()

    # A genuine collision must still abort login before stale autoload can run.
    generated.write_text(legacy)
    (config / "login.nu").write_text(browser + imports + "def 'bun custom' [] {}; generate-scoped-externals\n")
    marker = root / "LOGIN_MUST_NOT_CONTINUE"
    rejected = subprocess.run(
        [NU, "--config-home", str(config), "--login", "--execute", f"'unexpected' | save '{marker}'; exit"],
        env=env, text=True, capture_output=True, timeout=15,
    )
    assert rejected.returncode == 1, (rejected.returncode, rejected.stdout, rejected.stderr)
    assert "Refusing to wrap bun" in rejected.stderr
    assert not marker.exists()
    assert generated.read_text() == legacy
    (config / "login.nu").write_text(browser + imports + "generate-scoped-externals\n")
    startup("pi sessions")
    assert generated.read_bytes() == before

    # No systemd on PATH: same argument and exit semantics, without a scope.
    systemd.unlink()
    for name in ["bun", "pi"]:
        assert json.loads(nu(launch + name + " " + args).stdout) == expected_args
        env["SCOPE_TEST_EXIT"] = "17"
        nu(launch + name + " " + args, expected=17)
        del env["SCOPE_TEST_EXIT"]
    assert not scope_log.exists()

print("PASS: generated + custom commands, scope argv, literal argv, exit codes, collision guard, idempotence, local Pi browser, legacy migration across actual login/autoload cycles, no-systemd fallback")