Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

nushell/tests/completion-integration.py

Raw
"""Read-only completion checks; fixtures live under OS temp, never in dotfiles."""

import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import unittest


NU_DIR = Path(__file__).resolve().parents[1]
NU = shutil.which("nu")


def literal(value):
    return "r###'" + str(value) + "'###"


class CompletionIntegration(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        if not NU or not shutil.which("mise"):
            raise unittest.SkipTest("Nu and Mise are required")
        # Resolve version-manager shims before applying isolated Mise settings.
        resolved = subprocess.run(
            [NU, "--no-config-file", "-c", "$nu.current-exe"],
            capture_output=True, text=True, timeout=20,
        )
        if resolved.returncode != 0 or resolved.stderr:
            raise AssertionError(resolved.stderr or resolved.stdout)
        cls.nu = resolved.stdout.strip()
        parent = Path(tempfile.gettempdir()) / "pi-nu-completion-tests"
        parent.mkdir(exist_ok=True)
        cls.temporary = tempfile.TemporaryDirectory(dir=parent)
        cls.root = Path(cls.temporary.name)
        (cls.root / "folder with spaces").mkdir()
        (cls.root / "report with spaces.html").write_text("fixture", encoding="utf-8")
        (cls.root / "owner's report.html").write_text("fixture", encoding="utf-8")
        (cls.root / "plain.txt").write_text("fixture", encoding="utf-8")
        (cls.root / "alternate project").mkdir()
        cls.fake_mise = cls.root / "fake-mise"
        cls.fake_mise.mkdir()
        probe = cls.fake_mise / "probe.py"
        probe.write_text(
            "import json, os, sys\n"
            "if os.environ.get('COMPLETION_MODE') == 'files':\n"
            "    print('\\x01files'); sys.exit(0)\n"
            "print('probe\\t' + json.dumps({"
            "'path': os.environ.get('PATH'), "
            "'converted': os.environ.get('COMPLETION_TEST')}))\n",
            encoding="utf-8",
        )
        if os.name == "nt":
            (cls.fake_mise / "mise.cmd").write_text(
                f'@"{sys.executable}" "{probe}"\n', encoding="utf-8"
            )
        (cls.root / "mise.toml").write_text(
            '[tasks.test]\n'
            'description = "Fixture test task"\n'
            'run = "echo unexpected > TASK_MUST_NOT_RUN"\n'
            'usage = \'arg "<suite>" { choices "unit" "integration" }\'\n'
            '[tasks."build:docs"]\n'
            'description = "Fixture docs task"\n'
            'run = "echo unexpected > TASK_MUST_NOT_RUN"\n',
            encoding="utf-8",
        )
        (cls.root / "alternate project" / "mise.toml").write_text(
            '[tasks.alternate]\nrun = "echo unexpected > TASK_MUST_NOT_RUN"\n',
            encoding="utf-8",
        )
        cls.environment = os.environ.copy()
        cls.environment.update(
            MISE_TRUSTED_CONFIG_PATHS=str(cls.root),
            MISE_CONFIG_DIR=str(cls.root / "config"),
            MISE_CACHE_DIR=str(cls.root / "cache"),
            MISE_GLOBAL_CONFIG_FILE=str(cls.root / "empty-global.toml"),
            MISE_SYSTEM_CONFIG_FILE=str(cls.root / "empty-system.toml"),
            MISE_NO_HOOKS="1",
            MISE_NO_ENV="1",
            MISE_OFFLINE="1",
        )
        # Test current production generation, never the user's stale autoload.
        cls.wrapper_config = cls.root / "nu-config"
        cls.wrapper_config.mkdir()
        generation = subprocess.run(
            [cls.nu, "--no-config-file", "--config-home", str(cls.wrapper_config), "-c",
             f"use {literal(NU_DIR / 'modules' / 'commands.nu')} *; generate-scoped-externals"],
            env=cls.environment, capture_output=True, text=True, timeout=20,
        )
        if generation.returncode != 0 or generation.stderr:
            raise AssertionError(generation.stderr or generation.stdout)
        cls.wrappers = cls.wrapper_config / "autoload" / "90-work-scope.nu"
        if not cls.wrappers.exists():
            raise AssertionError("Production wrapper generation produced no autoload")
        if os.name != "nt":
            # Completion must not enter the scope runner or contact user systemd.
            guard_bin = cls.root / "scope-tripwire"
            guard_bin.mkdir()
            guard = guard_bin / "systemd-run"
            guard.write_text(
                f"#!{sys.executable}\n"
                "from pathlib import Path\n"
                f"Path({str(cls.root / 'WRAPPER_MUST_NOT_RUN')!r}).touch()\n"
                "raise SystemExit(99)\n", encoding="utf-8",
            )
            guard.chmod(0o700)
            cls.environment["PATH"] = str(guard_bin) + os.pathsep + cls.environment.get("PATH", "")

    @classmethod
    def tearDownClass(cls):
        try:
            if list(cls.root.rglob("TASK_MUST_NOT_RUN")):
                raise AssertionError("Completion executed a task")
            if (cls.root / "WRAPPER_MUST_NOT_RUN").exists():
                raise AssertionError("Completion executed a generated wrapper")
        finally:
            cls.temporary.cleanup()

    def run_nu(self, code, *, environment=None):
        imports = (
            f"source {literal(NU_DIR / 'autoload' / '30-carapace.nu')}; "
            f"source {literal(self.wrappers)}; "
            f"use {literal(NU_DIR / 'modules' / 'start.nu')}; "
        )
        result = subprocess.run(
            [self.nu, "--no-config-file", "-c", imports + code],
            cwd=self.root,
            env=self.environment if environment is None else environment,
            capture_output=True,
            encoding="utf-8",
            timeout=20,
            check=False,
        )
        self.assertEqual(0, result.returncode, result.stderr)
        self.assertNotIn("deprecated", result.stderr)
        return json.loads(result.stdout)

    def completions(self, text, setup=""):
        return self.run_nu(
            "do { " + setup + f"{literal(text)} | commandline complete }} | to json"
        )

    def test_commands_and_nested_flags(self):
        self.assertIn("use", self.completions("mise us"))
        self.assertIn("--dry-run", self.completions("mise run --dr"))
        self.assertIn("nu", self.completions("mise env --shell n"))
        self.assertEqual([], self.completions("mise --not-a-real-flag"))

    def test_tasks_and_descriptions(self):
        self.assertIn("test", self.completions("mise run te"))
        self.assertIn("build:docs", self.completions("mise build:"))
        result = self.run_nu(
            "'mise run te' | commandline complete --detailed | to json"
        )
        self.assertTrue(any("Fixture test" in x.get("description", "") for x in result))

    def test_available_tools(self):
        self.assertIn("node@", self.completions("mise use no"))

    def test_task_arguments(self):
        self.assertIn("unit", self.completions("mise run test u"))
        self.assertIn("integration", self.completions("mise test i"))

    def test_wrapper_alias_and_pipeline(self):
        wrapper = (
            "@complete external\ndef --wrapped mise [...args] { "
            "error make {msg: 'wrapper must not execute during completion'} }; "
        )
        self.assertIn("--dry-run", self.completions("mise run --dr", wrapper))
        self.assertIn("--dry-run", self.completions("m run --dr", wrapper + "alias m = mise; "))
        self.assertIn("use", self.completions("'ignored' | mise us"))
        if os.name == "nt":
            self.assertIn("use", self.completions("mise.exe us"))

    def test_quoted_project_context(self):
        variants = [
            '"alternate project"',
            "`alternate project`",
            "'" + str(self.root / "alternate project") + "'",
        ]
        for repeat in range(3):
            for directory in variants:
                with self.subTest(repeat=repeat + 1, directory=directory):
                    self.assertIn(
                        "alternate",
                        self.completions("mise -C " + directory + " run alt"),
                    )

    @unittest.skipUnless(os.name == "nt", "Windows PATH casing regression")
    def test_path_casing_and_nested_scopes(self):
        text = "mise -C '" + str(self.root / "alternate project") + "' run alt"
        query = (
            "$env.ENV_CONVERSIONS = ($env.ENV_CONVERSIONS | upsert COMPLETION_TEST "
            "{to_string: { 'preserved' }}); "
            "let before = ($env | select -o PATH Path path); "
            "let matches = (" + literal(text) + " | commandline complete); "
            "{matches: $matches, parent_unchanged: "
            "(($env | select -o PATH Path path) == $before), "
            "conversion_preserved: (do $env.ENV_CONVERSIONS.COMPLETION_TEST.to_string)}"
        )
        for casing in ["PATH", "Path", "path"]:
            environment = {
                k: v for k, v in self.environment.items() if k.lower() != "path"
            }
            environment[casing] = os.environ["PATH"]
            for nested in [False, True]:
                code = query
                if nested:
                    code = (
                        "do { load-env {path: ($env.PATH | prepend "
                        + literal(self.root / "outer-path") + ")}; "
                        "do { load-env {PATH: ($env.PATH | prepend "
                        + literal(self.root / "inner-path") + ")}; " + code + " } }"
                    )
                for repeat in range(3):
                    with self.subTest(casing=casing, nested=nested, repeat=repeat + 1):
                        result = self.run_nu(code + " | to json", environment=environment)
                        self.assertIn("alternate", result["matches"])
                        self.assertTrue(result["parent_unchanged"])
                        self.assertEqual("preserved", result["conversion_preserved"])

    @unittest.skipUnless(os.name == "nt", "Windows PATH serialization regression")
    def test_child_path_serialization(self):
        semicolon = self.root / "tools;archive"
        query = (
            "use " + literal(NU_DIR / "modules" / "mise-completions.nu") + "; "
            "let before = ($env | select -o PATH Path path); "
            "let captured = (with-env {PATH: (["
            + literal(self.fake_mise) + " '~/nu-completion-missing' "
            + literal(semicolon) + "] ++ $env.PATH)} { "
            "mise-completions {command: [mise probe]} "
            "| get completions.0.description | from json }); "
            "{payload: $captured, parent_unchanged: "
            "(($env | select -o PATH Path path) == $before)} | to json"
        )
        result = self.run_nu(query)
        self.assertIn('"' + str(semicolon) + '"', result["payload"]["path"])
        self.assertIn(str(Path.home() / "nu-completion-missing"), result["payload"]["path"])
        self.assertNotIn("~/", result["payload"]["path"])
        self.assertTrue(result["parent_unchanged"])

    @unittest.skipUnless(os.name == "nt", "Windows PATH conversion regression")
    def test_existing_child_conversions(self):
        custom = str(self.root / "custom-conversion")
        query = (
            "use " + literal(NU_DIR / "modules" / "mise-completions.nu") + "; "
            "$env.ENV_CONVERSIONS = ($env.ENV_CONVERSIONS | merge {"
            "Path: {from_string: { split row ';' }, "
            "to_string: {|paths| $paths | prepend " + literal(custom)
            + " | str join (char esep)}}, "
            "COMPLETION_TEST: {to_string: { str join ':' }}}); "
            "$env.COMPLETION_TEST = [converted yes]; "
            "let before = (do $env.ENV_CONVERSIONS.Path.to_string $env.PATH); "
            "let captured = (with-env {PATH: ($env.PATH | prepend "
            + literal(self.fake_mise) + ")} { "
            "mise-completions {command: [mise probe]} "
            "| get completions.0.description | from json }); "
            "{payload: $captured, converter_unchanged: "
            "((do $env.ENV_CONVERSIONS.Path.to_string $env.PATH) == $before), "
            "from_string: ('a;b' | do $env.ENV_CONVERSIONS.Path.from_string 'a;b')} | to json"
        )
        result = self.run_nu(query)
        self.assertIn(custom, result["payload"]["path"])
        self.assertEqual("converted:yes", result["payload"]["converted"])
        self.assertTrue(result["converter_unchanged"])
        self.assertEqual(["a", "b"], result["from_string"])

    def test_mise_directory_values(self):
        results = self.completions('mise -C "folder')
        self.assertTrue(any("folder with spaces" in value for value in results))
        self.assertFalse(any("plain.txt" in value for value in results))

    def test_start_files_and_multiple_arguments(self):
        for text in ["start report", "start plain.txt report", 'start "report']:
            results = self.completions(text)
            self.assertTrue(any("report with spaces.html" in value for value in results))
        result = self.run_nu(
            "'start report' | commandline complete | first | to json"
        )
        self.assertIn("report with spaces.html", result)
        self.assertIn(result[0], ['`', "'", '"'])
        self.assertTrue(any("owner's report" in x for x in self.completions("start owner")))

    def test_start_replacement_spans(self):
        for text in ["start report", "start plain.txt report", 'start "report']:
            with self.subTest(input=text):
                records = self.run_nu(
                    literal(text) + " | commandline complete --detailed | to json"
                )
                suggestion = next(x for x in records if "report with spaces" in x["value"])
                span = suggestion["span"]
                completed = text[:span["start"]] + suggestion["value"] + text[span["end"]:]
                expected_prefix = "start plain.txt " if "plain.txt" in text else "start "
                self.assertTrue(completed.startswith(expected_prefix), completed)

    @unittest.skipUnless(os.name == "nt", "Windows mock Mise launcher")
    def test_mise_path_hint_spans(self):
        text = "mise probe report"
        records = self.run_nu(
            "with-env {PATH: ($env.PATH | prepend " + literal(self.fake_mise)
            + "), COMPLETION_MODE: files} { " + literal(text)
            + " | commandline complete --detailed } | to json"
        )
        suggestion = next(x for x in records if "report with spaces" in x["value"])
        self.assertEqual(len("mise probe "), suggestion["span"]["start"])
        self.assertEqual(len(text), suggestion["span"]["end"])

    def test_start_urls(self):
        for url in ["https://example.com/report", "mailto:person@example.com", "file:///report"]:
            self.assertEqual([], self.completions("start " + url))
        self.assertTrue(self.completions("start https://example.com report"))

    def test_missing_mise_declines(self):
        result = self.run_nu(
            "use " + literal(NU_DIR / "modules" / "mise-completions.nu") + "; "
            "let place = ('mise us' | commandline complete --input | get place); "
            "with-env {Path: [], PATH: []} { "
            "mise-completions $place } | to json"
        )
        self.assertIsNone(result)


if __name__ == "__main__":
    unittest.main()