derivepassphrase.git

@@ -4,30 +4,19 @@

 from __future__ import annotations

-import base64

 import contextlib

 import copy

-import ctypes

-import enum

 import errno

-import io

 import json

-import logging

-import operator

 import os

 import pathlib

-import re

-import shlex

 import shutil

 import socket

-import tempfile

 import textwrap

 import types

-import warnings

 from typing import TYPE_CHECKING

 import click.testing

-import exceptiongroup

 import hypothesis

 import pytest

 from hypothesis import strategies

@@ -36,18 +25,14 @@ from typing_extensions import Any, NamedTuple

 from derivepassphrase import _types, cli, ssh_agent, vault

 from derivepassphrase._internals import (

     cli_helpers,

-    cli_machinery,

     cli_messages,

 )

-from derivepassphrase.ssh_agent import socketprovider

 from tests import data, machinery

 from tests.data import callables

 from tests.machinery import hypothesis as hypothesis_machinery

 from tests.machinery import pytest as pytest_machinery

 if TYPE_CHECKING:

-    from collections.abc import Callable, Iterable, Iterator, Sequence

-    from collections.abc import Set as AbstractSet

     from typing import NoReturn

     from typing_extensions import Literal

@@ -90,43 +75,6 @@ class OptionCombination(NamedTuple):

     check_success: bool

-class VersionOutputData(NamedTuple):

-    derivation_schemes: dict[str, bool]

-    foreign_configuration_formats: dict[str, bool]

-    extras: frozenset[str]

-    subcommands: frozenset[str]

-    features: dict[str, bool]

-

-

-class KnownLineType(str, enum.Enum):

-    SUPPORTED_FOREIGN_CONFS = cli_messages.Label.SUPPORTED_FOREIGN_CONFIGURATION_FORMATS.value.singular.rstrip(

-        ":"

-    )

-    UNAVAILABLE_FOREIGN_CONFS = cli_messages.Label.UNAVAILABLE_FOREIGN_CONFIGURATION_FORMATS.value.singular.rstrip(

-        ":"

-    )

-    SUPPORTED_SCHEMES = (

-        cli_messages.Label.SUPPORTED_DERIVATION_SCHEMES.value.singular.rstrip(

-            ":"

-        )

-    )

-    UNAVAILABLE_SCHEMES = cli_messages.Label.UNAVAILABLE_DERIVATION_SCHEMES.value.singular.rstrip(

-        ":"

-    )

-    SUPPORTED_SUBCOMMANDS = (

-        cli_messages.Label.SUPPORTED_SUBCOMMANDS.value.singular.rstrip(":")

-    )

-    SUPPORTED_FEATURES = (

-        cli_messages.Label.SUPPORTED_FEATURES.value.singular.rstrip(":")

-    )

-    UNAVAILABLE_FEATURES = (

-        cli_messages.Label.UNAVAILABLE_FEATURES.value.singular.rstrip(":")

-    )

-    ENABLED_EXTRAS = (

-        cli_messages.Label.ENABLED_PEP508_EXTRAS.value.singular.rstrip(":")

-    )

-

-

 PASSPHRASE_GENERATION_OPTIONS: list[tuple[str, ...]] = [

     ("--phrase",),

     ("--key",),

@@ -320,535 +268,12 @@ def assert_vault_config_is_indented_and_line_broken(

     ])

-def vault_config_exporter_shell_interpreter(  # noqa: C901

-    script: str | Iterable[str],

-    /,

-    *,

-    prog_name_list: list[str] | None = None,

-    command: click.BaseCommand | None = None,

-    runner: machinery.CliRunner | None = None,

-) -> Iterator[machinery.ReadableResult]:

-    """A rudimentary sh(1) interpreter for `--export-as=sh` output.

-

-    Assumes a script as emitted by `derivepassphrase vault

-    --export-as=sh --export -` and interprets the calls to

-    `derivepassphrase vault` within.  (One call per line, skips all

-    other lines.)  Also has rudimentary support for (quoted)

-    here-documents using `HERE` as the marker.

-

-    """

-    if isinstance(script, str):  # pragma: no cover

-        script = script.splitlines(False)

-    if prog_name_list is None:  # pragma: no cover

-        prog_name_list = ["derivepassphrase", "vault"]

-    if command is None:  # pragma: no cover

-        command = cli.derivepassphrase_vault

-    if runner is None:  # pragma: no cover

-        runner = machinery.CliRunner(mix_stderr=False)

-    n = len(prog_name_list)

-    it = iter(script)

-    while True:

-        try:

-            raw_line = next(it)

-        except StopIteration:

-            break

-        else:

-            line = shlex.split(raw_line)

-        input_buffer: list[str] = []

-        if line[:n] != prog_name_list:

-            continue

-        line[:n] = []

-        if line and line[-1] == "<<HERE":

-            # naive HERE document support

-            while True:

-                try:

-                    raw_line = next(it)

-                except StopIteration as exc:  # pragma: no cover

-                    msg = "incomplete here document"

-                    raise EOFError(msg) from exc

-                else:

-                    if raw_line == "HERE":

-                        break

-                    input_buffer.append(raw_line)

-            line.pop()

-        yield runner.invoke(

-            command,

-            line,

-            catch_exceptions=False,

-            input=("".join(x + "\n" for x in input_buffer) or None),

-        )

-

-

-def parse_version_output(  # noqa: C901

-    version_output: str,

-    /,

-    *,

-    prog_name: str | None = cli_messages.PROG_NAME,

-    version: str | None = cli_messages.VERSION,

-) -> VersionOutputData:

-    r"""Parse the output of the `--version` option.

-

-    The version output contains two paragraphs.  The first paragraph

-    details the version number, and the version number of any major

-    libraries in use.  The second paragraph details known and supported

-    passphrase derivation schemes, foreign configuration formats,

-    subcommands and PEP 508 package extras.  For the schemes and

-    formats, there is a "supported" line for supported items, and

-    a "known" line for known but currently unsupported items (usually

-    because of missing dependencies), either of which may be empty and

-    thus omitted.  For extras, only active items are shown, and there is

-    a separate message for the "no extras active" case.  Item lists may

-    be spilled across multiple lines, but only at item boundaries, and

-    the continuation lines are then indented.

-

-    Args:

-        version_output:

-            The version output text to parse.

-        prog_name:

-            The program name to assert, defaulting to the true program

-            name, `derivepassphrase`.  Set to `None` to disable this

-            check.

-        version:

-            The program version to assert, defaulting to the true

-            current version of `derivepassphrase`.  Set to `None` to

-            disable this check.

-

-    Examples:

-        See [`Parametrize.VERSION_OUTPUT_DATA`][].

-

-    """

-    paragraphs: list[list[str]] = []

-    paragraph: list[str] = []

-    for line in version_output.splitlines(keepends=False):

-        if not line.strip():

-            if paragraph:

-                paragraphs.append(paragraph.copy())

-            paragraph.clear()

-        elif paragraph and line.lstrip() != line:

-            paragraph[-1] = f"{paragraph[-1]} {line.lstrip()}"

-        else:

-            paragraph.append(line)

-    if paragraph:  # pragma: no branch

-        paragraphs.append(paragraph.copy())

-        paragraph.clear()

-    assert paragraphs, (

-        f"expected at least one paragraph of version output: {paragraphs!r}"

-    )

-    assert prog_name is None or prog_name in paragraphs[0][0], (

-        f"first version output line should mention "

-        f"{prog_name}: {paragraphs[0][0]!r}"

-    )

-    assert version is None or version in paragraphs[0][0], (

-        f"first version output line should mention the version number "

-        f"{version}: {paragraphs[0][0]!r}"

-    )

-    schemes: dict[str, bool] = {}

-    formats: dict[str, bool] = {}

-    subcommands: set[str] = set()

-    extras: set[str] = set()

-    features: dict[str, bool] = {}

-    if len(paragraphs) < 2:  # pragma: no cover

-        return VersionOutputData(

-            derivation_schemes=schemes,

-            foreign_configuration_formats=formats,

-            subcommands=frozenset(subcommands),

-            extras=frozenset(extras),

-            features=features,

-        )

-    for line in paragraphs[1]:

-        line_type, _, value = line.partition(":")

-        if line_type == line:

-            continue

-        for item_ in re.split(r"(?:, *|.$)", value):

-            item = item_.strip()

-            if not item:

-                continue

-            if line_type == KnownLineType.SUPPORTED_FOREIGN_CONFS:

-                formats[item] = True

-            elif line_type == KnownLineType.UNAVAILABLE_FOREIGN_CONFS:

-                formats[item] = False

-            elif line_type == KnownLineType.SUPPORTED_SCHEMES:

-                schemes[item] = True

-            elif line_type == KnownLineType.UNAVAILABLE_SCHEMES:

-                schemes[item] = False

-            elif line_type == KnownLineType.SUPPORTED_SUBCOMMANDS:

-                subcommands.add(item)

-            elif line_type == KnownLineType.ENABLED_EXTRAS:

-                extras.add(item)

-            elif line_type == KnownLineType.SUPPORTED_FEATURES:

-                features[item] = True

-            elif line_type == KnownLineType.UNAVAILABLE_FEATURES:

-                features[item] = False

-            else:

-                raise AssertionError(  # noqa: TRY003

-                    f"Unknown version info line type: {line_type!r}"  # noqa: EM102

-                )

-    return VersionOutputData(

-        derivation_schemes=schemes,

-        foreign_configuration_formats=formats,

-        subcommands=frozenset(subcommands),

-        extras=frozenset(extras),

-        features=features,

-    )

-

-

-def bash_format(item: click.shell_completion.CompletionItem) -> str:

-    """A formatter for `bash`-style shell completion items.

-

-    The format is `type,value`, and is dictated by [`click`][].

-

-    """

-    type, value = (  # noqa: A001

-        item.type,

-        item.value,

-    )

-    return f"{type},{value}"

-

-

-def fish_format(item: click.shell_completion.CompletionItem) -> str:

-    r"""A formatter for `fish`-style shell completion items.

-

-    The format is `type,value<tab>help`, and is dictated by [`click`][].

-

-    """

-    type, value, help = (  # noqa: A001

-        item.type,

-        item.value,

-        item.help,

-    )

-    return f"{type},{value}\t{help}" if help else f"{type},{value}"

-

-

-def zsh_format(item: click.shell_completion.CompletionItem) -> str:

-    r"""A formatter for `zsh`-style shell completion items.

-

-    The format is `type<newline>value<newline>help<newline>`, and is

-    dictated by [`click`][].  Upstream `click` currently (v8.2.0) does

-    not deal with colons in the value correctly when the help text is

-    non-degenerate.  Our formatter here does, provided the upstream

-    `zsh` completion script is used; see the

-    [`cli_machinery.ZshComplete`][] class.  A request is underway to

-    merge this change into upstream `click`; see

-    [`pallets/click#2846`][PR2846].

-

-    [PR2846]: https://github.com/pallets/click/pull/2846

-

-    """

-    empty_help = "_"

-    help_, value = (

-        (item.help, item.value.replace(":", r"\:"))

-        if item.help and item.help == empty_help

-        else (empty_help, item.value)

-    )

-    return f"{item.type}\n{value}\n{help_}"

-

-

-class ListKeysAction(str, enum.Enum):

-    """Test fixture settings for [`ssh_agent.SSHAgentClient.list_keys`][].

-

-    Attributes:

-        EMPTY: Return an empty key list.

-        FAIL: Raise an [`ssh_agent.SSHAgentFailedError`][].

-        FAIL_RUNTIME: Raise an [`ssh_agent.TrailingDataError`][].

-

-    """

-

-    EMPTY = enum.auto()

-    """"""

-    FAIL = enum.auto()

-    """"""

-    FAIL_RUNTIME = enum.auto()

-    """"""

-

-    def __call__(self, *_args: Any, **_kwargs: Any) -> Any:

-        """Execute the respective action."""

-        # TODO(the-13th-letter): Rewrite using structural pattern

-        # matching.

-        # https://the13thletter.info/derivepassphrase/latest/pycompatibility/#after-eol-py3.9

-        if self == self.EMPTY:

-            return []

-        if self == self.FAIL:

-            raise ssh_agent.SSHAgentFailedError(

-                _types.SSH_AGENT.FAILURE.value, b""

-            )

-        if self == self.FAIL_RUNTIME:

-            raise ssh_agent.TrailingDataError()

-        raise AssertionError()

-

-

-class SignAction(str, enum.Enum):

-    """Test fixture settings for [`ssh_agent.SSHAgentClient.sign`][].

-

-    Attributes:

-        FAIL: Raise an [`ssh_agent.SSHAgentFailedError`][].

-        FAIL_RUNTIME: Raise an [`ssh_agent.TrailingDataError`][].

-

-    """

-

-    FAIL = enum.auto()

-    """"""

-    FAIL_RUNTIME = enum.auto()

-    """"""

-

-    def __call__(self, *_args: Any, **_kwargs: Any) -> Any:

-        """Execute the respective action."""

-        # TODO(the-13th-letter): Rewrite using structural pattern

-        # matching.

-        # https://the13thletter.info/derivepassphrase/latest/pycompatibility/#after-eol-py3.9

-        if self == self.FAIL:

-            raise ssh_agent.SSHAgentFailedError(

-                _types.SSH_AGENT.FAILURE.value, b""

-            )

-        if self == self.FAIL_RUNTIME:

-            raise ssh_agent.TrailingDataError()

-        raise AssertionError()

-

-

-class SocketAddressAction(str, enum.Enum):

-    """Test fixture settings for the SSH agent socket address.

-

-    Attributes:

-        MANGLE_ANNOYING_OS_NAMED_PIPE:

-            Mangle the address for the Annoying OS named pipe endpoint.

-        MANGLE_SSH_AUTH_SOCK:

-            Mangle the address for the UNIX domain socket (the

-            `SSH_AUTH_SOCK` environment variable).

-        UNSET_ANNOYING_OS_NAMED_PIPE:

-            Unset the address for the Annoying OS named pipe endpoint.

-        UNSET_SSH_AUTH_SOCK:

-            Unset the `SSH_AUTH_SOCK` environment variable (the address

-            for the UNIX domain socket).

-

-    """

-

-    MANGLE_ANNOYING_OS_NAMED_PIPE = enum.auto()

-    """"""

-    MANGLE_SSH_AUTH_SOCK = enum.auto()

-    """"""

-    UNSET_ANNOYING_OS_NAMED_PIPE = enum.auto()

-    """"""

-    UNSET_SSH_AUTH_SOCK = enum.auto()

-    """"""

-

-    def __call__(

-        self, monkeypatch: pytest.MonkeyPatch, /, *_args: Any, **_kwargs: Any

-    ) -> None:

-        """Execute the respective action."""

-        # TODO(the-13th-letter): Rewrite using structural pattern

-        # matching.

-        # https://the13thletter.info/derivepassphrase/latest/pycompatibility/#after-eol-py3.9

-        if self in {

-            self.MANGLE_ANNOYING_OS_NAMED_PIPE,

-            self.UNSET_ANNOYING_OS_NAMED_PIPE,

-        }:  # pragma: no cover [unused]

-            pass

-        elif self == self.MANGLE_SSH_AUTH_SOCK:

-            monkeypatch.setenv(

-                "SSH_AUTH_SOCK", os.environ["SSH_AUTH_SOCK"] + "~"

-            )

-        elif self == self.UNSET_SSH_AUTH_SOCK:

-            monkeypatch.delenv("SSH_AUTH_SOCK", raising=False)

-        else:

-            raise AssertionError()

-

-

-class SystemSupportAction(str, enum.Enum):

-    """Test fixture settings for [`ssh_agent.SSHAgentClient`][] system support.

-

-    Attributes:

-        UNSET_AF_UNIX:

-            Ensure lack of support for UNIX domain sockets.

-        UNSET_AF_UNIX_AND_ENSURE_USE:

-            Ensure lack of support for UNIX domain sockets, and that the

-            agent will use this socket provider.

-        UNSET_NATIVE:

-            Ensure both `UNSET_AF_UNIX` and `UNSET_WINDLL`.

-        UNSET_NATIVE_AND_ENSURE_USE:

-            Ensure both `UNSET_AF_UNIX` and `UNSET_WINDLL`, and that the

-            agent will use the native socket provider.

-        UNSET_PROVIDER_LIST:

-            Ensure an empty list of SSH agent socket providers.

-        UNSET_WINDLL:

-            Ensure lack of support for The Annoying OS named pipes.

-        UNSET_WINDLL_AND_ENSURE_USE:

-            Ensure lack of support for The Annoying OS named pipes, and

-            that the agent will use this socket provider.

-

-    """

-

-    UNSET_AF_UNIX = enum.auto()

-    """"""

-    UNSET_AF_UNIX_AND_ENSURE_USE = enum.auto()

-    """"""

-    UNSET_NATIVE = enum.auto()

-    """"""

-    UNSET_NATIVE_AND_ENSURE_USE = enum.auto()

-    """"""

-    UNSET_PROVIDER_LIST = enum.auto()

-    """"""

-    UNSET_WINDLL = enum.auto()

-    """"""

-    UNSET_WINDLL_AND_ENSURE_USE = enum.auto()

-    """"""

-

-    def __call__(

-        self, monkeypatch: pytest.MonkeyPatch, /, *_args: Any, **_kwargs: Any

-    ) -> None:

-        """Execute the respective action.

-

-        Args:

-            monkeypatch: The current monkeypatch context.

-

-        """

-        # TODO(the-13th-letter): Rewrite using structural pattern

-        # matching.

-        # https://the13thletter.info/derivepassphrase/latest/pycompatibility/#after-eol-py3.9

-        if self == self.UNSET_PROVIDER_LIST:

-            monkeypatch.setattr(

-                ssh_agent.SSHAgentClient, "SOCKET_PROVIDERS", []

-            )

-        elif self in {self.UNSET_NATIVE, self.UNSET_NATIVE_AND_ENSURE_USE}:

-            self.check_or_ensure_use(

-                "native",

-                monkeypatch=monkeypatch,

-                ensure_use=(self == self.UNSET_NATIVE_AND_ENSURE_USE),

-            )

-            monkeypatch.delattr(socket, "AF_UNIX", raising=False)

-            monkeypatch.delattr(ctypes, "WinDLL", raising=False)

-            monkeypatch.delattr(ctypes, "windll", raising=False)

-        elif self in {self.UNSET_AF_UNIX, self.UNSET_AF_UNIX_AND_ENSURE_USE}:

-            self.check_or_ensure_use(

-                "posix",

-                monkeypatch=monkeypatch,

-                ensure_use=(self == self.UNSET_AF_UNIX_AND_ENSURE_USE),

-            )

-            monkeypatch.delattr(socket, "AF_UNIX", raising=False)

-        elif self in {self.UNSET_WINDLL, self.UNSET_WINDLL_AND_ENSURE_USE}:

-            self.check_or_ensure_use(

-                "the_annoying_os",

-                monkeypatch=monkeypatch,

-                ensure_use=(self == self.UNSET_WINDLL_AND_ENSURE_USE),

-            )

-            monkeypatch.delattr(ctypes, "WinDLL", raising=False)

-            monkeypatch.delattr(ctypes, "windll", raising=False)

-        else:

-            raise AssertionError()

-

-    @staticmethod

-    def check_or_ensure_use(

-        provider: str, /, *, monkeypatch: pytest.MonkeyPatch, ensure_use: bool

-    ) -> None:

-        """Check that the named SSH agent socket provider will be used.

-

-        Either ensure that the socket provider will definitely be used,

-        or, upon detecting that it won't be used, skip the test.

-

-        Args:

-            provider:

-                The provider to check for.

-            ensure_use:

-                If true, ensure that the socket provider will definitely

-                be used.  If false, then check for whether it will be

-                used, and skip this test if not.

-            monkeypatch:

-                The monkeypatch context within which the fixture

-                adjustments should be executed.

-

-        """

-        if ensure_use:

-            monkeypatch.setattr(

-                ssh_agent.SSHAgentClient, "SOCKET_PROVIDERS", [provider]

-            )

-        else:  # pragma: no cover [external]

-            # This branch operates completely on instrumented or on

-            # externally defined, non-deterministic state.

-            intended: (

-                _types.SSHAgentSocketProvider

-                | socketprovider.NoSuchProviderError

-                | None

-            )

-            try:

-                intended = socketprovider.SocketProvider.lookup(provider)

-            except socketprovider.NoSuchProviderError as exc:

-                intended = exc

-            actual: (

-                _types.SSHAgentSocketProvider

-                | socketprovider.NoSuchProviderError

-                | None

-            )

-            for name in ssh_agent.SSHAgentClient.SOCKET_PROVIDERS:

-                try:

-                    actual = socketprovider.SocketProvider.lookup(name)

-                except socketprovider.NoSuchProviderError as exc:

-                    actual = exc

-                if actual is None:

-                    continue

-                break

-            else:

-                actual = None

-            if intended != actual:

-                pytest.skip(

-                    f"{provider!r} SSH agent socket provider "

-                    f"is not currently in use"

-                )

-

-

 class Parametrize(types.SimpleNamespace):

     """Common test parametrizations."""

-    EAGER_ARGUMENTS = pytest.mark.parametrize(

-        "arguments",

-        [["--help"], ["--version"]],

-        ids=["help", "version"],

-    )

     CHARSET_NAME = pytest.mark.parametrize(

         "charset_name", ["lower", "upper", "number", "space", "dash", "symbol"]

     )

-    COMMAND_NON_EAGER_ARGUMENTS = pytest.mark.parametrize(

-        ["command", "non_eager_arguments"],

-        [

-            pytest.param(

-                [],

-                [],

-                id="top-nothing",

-            ),

-            pytest.param(

-                [],

-                ["export"],

-                id="top-export",

-            ),

-            pytest.param(

-                ["export"],

-                [],

-                id="export-nothing",

-            ),

-            pytest.param(

-                ["export"],

-                ["vault"],

-                id="export-vault",

-            ),

-            pytest.param(

-                ["export", "vault"],

-                [],

-                id="export-vault-nothing",

-            ),

-            pytest.param(

-                ["export", "vault"],

-                ["--format", "this-format-doesnt-exist"],

-                id="export-vault-args",

-            ),

-            pytest.param(

-                ["vault"],

-                [],

-                id="vault-nothing",

-            ),

-            pytest.param(

-                ["vault"],

-                ["--export", "./"],

-                id="vault-args",

-            ),

-        ],

-    )

     UNICODE_NORMALIZATION_COMMAND_LINES = pytest.mark.parametrize(

         "command_line",

         [

@@ -866,45 +291,6 @@ class Parametrize(types.SimpleNamespace):

             ),

         ],

     )

-    DELETE_CONFIG_INPUT = pytest.mark.parametrize(

-        ["command_line", "config", "result_config"],

-        [

-            pytest.param(

-                ["--delete-globals"],

-                {"global": {"phrase": "abc"}, "services": {}},

-                {"services": {}},

-                id="globals",

-            ),

-            pytest.param(

-                ["--delete", "--", DUMMY_SERVICE],

-                {

-                    "global": {"phrase": "abc"},

-                    "services": {DUMMY_SERVICE: {"notes": "..."}},

-                },

-                {"global": {"phrase": "abc"}, "services": {}},

-                id="service",

-            ),

-            pytest.param(

-                ["--clear"],

-                {

-                    "global": {"phrase": "abc"},

-                    "services": {DUMMY_SERVICE: {"notes": "..."}},

-                },

-                {"services": {}},

-                id="all",

-            ),

-        ],

-    )

-    COLORFUL_COMMAND_INPUT = pytest.mark.parametrize(

-        ["command_line", "input"],

-        [

-            (

-                ["vault", "--import", "-"],

-                '{"services": {"": {"length": 20}}}',

-            ),

-        ],

-        ids=["cmd"],

-    )

     CONFIG_EDITING_VIA_CONFIG_FLAG_FAILURES = pytest.mark.parametrize(

         ["command_line", "input", "err_text"],

         [

@@ -993,182 +379,6 @@ class Parametrize(types.SimpleNamespace):

             ),

         ],

     )

-    COMPLETABLE_PATH_ARGUMENT = pytest.mark.parametrize(

-        "command_prefix",

-        [

-            pytest.param(

-                ("export", "vault"),

-                id="derivepassphrase-export-vault",

-            ),

-            pytest.param(

-                ("vault", "--export"),

-                id="derivepassphrase-vault--export",

-            ),

-            pytest.param(

-                ("vault", "--import"),

-                id="derivepassphrase-vault--import",

-            ),

-        ],

-    )

-    COMPLETABLE_OPTIONS = pytest.mark.parametrize(

-        ["command_prefix", "incomplete", "completions"],

-        [

-            pytest.param(

-                (),

-                "-",

-                frozenset({

-                    "--help",

-                    "-h",

-                    "--version",

-                    "--debug",

-                    "--verbose",

-                    "-v",

-                    "--quiet",

-                    "-q",

-                }),

-                id="derivepassphrase",

-            ),

-            pytest.param(

-                ("export",),

-                "-",

-                frozenset({

-                    "--help",

-                    "-h",

-                    "--version",

-                    "--debug",

-                    "--verbose",

-                    "-v",

-                    "--quiet",

-                    "-q",

-                }),

-                id="derivepassphrase-export",

-            ),

-            pytest.param(

-                ("export", "vault"),

-                "-",

-                frozenset({

-                    "--help",

-                    "-h",

-                    "--version",

-                    "--debug",

-                    "--verbose",

-                    "-v",

-                    "--quiet",

-                    "-q",

-                    "--format",

-                    "-f",

-                    "--key",

-                    "-k",

-                }),

-                id="derivepassphrase-export-vault",

-            ),

-            pytest.param(

-                ("vault",),

-                "-",

-                frozenset({

-                    "--help",

-                    "-h",

-                    "--version",

-                    "--debug",

-                    "--verbose",

-                    "-v",

-                    "--quiet",

-                    "-q",

-                    "--phrase",

-                    "-p",

-                    "--key",

-                    "-k",

-                    "--length",

-                    "-l",

-                    "--repeat",

-                    "-r",

-                    "--upper",

-                    "--lower",

-                    "--number",

-                    "--space",

-                    "--dash",

-                    "--symbol",

-                    "--config",

-                    "-c",

-                    "--notes",

-                    "-n",

-                    "--delete",

-                    "-x",

-                    "--delete-globals",

-                    "--clear",

-                    "-X",

-                    "--export",

-                    "-e",

-                    "--import",

-                    "-i",

-                    "--overwrite-existing",

-                    "--merge-existing",

-                    "--unset",

-                    "--export-as",

-                    "--modern-editor-interface",

-                    "--vault-legacy-editor-interface",

-                    "--print-notes-before",

-                    "--print-notes-after",

-                }),

-                id="derivepassphrase-vault",

-            ),

-        ],

-    )

-    COMPLETABLE_SUBCOMMANDS = pytest.mark.parametrize(

-        ["command_prefix", "incomplete", "completions"],

-        [

-            pytest.param(

-                (),

-                "",

-                frozenset({"export", "vault"}),

-                id="derivepassphrase",

-            ),

-            pytest.param(

-                ("export",),

-                "",

-                frozenset({"vault"}),

-                id="derivepassphrase-export",

-            ),

-        ],

-    )

-    BAD_CONFIGS = pytest.mark.parametrize(

-        "config",

-        [

-            {"global": "", "services": {}},

-            {"global": 0, "services": {}},

-            {

-                "global": {"phrase": "abc"},

-                "services": False,

-            },

-            {

-                "global": {"phrase": "abc"},

-                "services": True,

-            },

-            {

-                "global": {"phrase": "abc"},

-                "services": None,

-            },

-        ],

-    )

-    BASE_CONFIG_VARIATIONS = pytest.mark.parametrize(

-        "config",

-        [

-            {"global": {"phrase": "my passphrase"}, "services": {}},

-            {"global": {"key": DUMMY_KEY1_B64}, "services": {}},

-            {

-                "global": {"phrase": "abc"},

-                "services": {"sv": {"phrase": "my passphrase"}},

-            },

-            {

-                "global": {"phrase": "abc"},

-                "services": {"sv": {"key": DUMMY_KEY1_B64}},

-            },

-            {

-                "global": {"phrase": "abc"},

-                "services": {"sv": {"key": DUMMY_KEY1_B64, "length": 15}},

-            },

-        ],

-    )

     BASE_CONFIG_WITH_KEY_VARIATIONS = pytest.mark.parametrize(

         "config",

         [

@@ -1253,404 +463,24 @@ class Parametrize(types.SimpleNamespace):

             ),

         ],

     )

-    COMPLETION_FUNCTION_INPUTS = pytest.mark.parametrize(

-        ["config", "comp_func", "args", "incomplete", "results"],

-        [

-            pytest.param(

-                {"services": {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}},

-                cli_helpers.shell_complete_service,

-                ["vault"],

-                "",

-                [DUMMY_SERVICE],

-                id="base_config-service",

-            ),

-            pytest.param(

-                {"services": {}},

-                cli_helpers.shell_complete_service,

-                ["vault"],

-                "",

-                [],

-                id="empty_config-service",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),

-                        "newline\nin\nname": DUMMY_CONFIG_SETTINGS.copy(),

-                    }

-                },

-                cli_helpers.shell_complete_service,

-                ["vault"],

-                "",

-                [DUMMY_SERVICE],

-                id="incompletable_newline_config-service",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),

-                        "backspace\bin\bname": DUMMY_CONFIG_SETTINGS.copy(),

-                    }

-                },

-                cli_helpers.shell_complete_service,

-                ["vault"],

-                "",

-                [DUMMY_SERVICE],

-                id="incompletable_backspace_config-service",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),

-                        "colon:in:name": DUMMY_CONFIG_SETTINGS.copy(),

-                    }

-                },

-                cli_helpers.shell_complete_service,

-                ["vault"],

-                "",

-                sorted([DUMMY_SERVICE, "colon:in:name"]),

-                id="brittle_colon_config-service",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),

-                        "colon:in:name": DUMMY_CONFIG_SETTINGS.copy(),

-                        "newline\nin\nname": DUMMY_CONFIG_SETTINGS.copy(),

-                        "backspace\bin\bname": DUMMY_CONFIG_SETTINGS.copy(),

-                        "nul\x00in\x00name": DUMMY_CONFIG_SETTINGS.copy(),

-                        "del\x7fin\x7fname": DUMMY_CONFIG_SETTINGS.copy(),

-                    }

-                },

-                cli_helpers.shell_complete_service,

-                ["vault"],

-                "",

-                sorted([DUMMY_SERVICE, "colon:in:name"]),

-                id="brittle_incompletable_multi_config-service",

-            ),

-            pytest.param(

-                {"services": {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}},

-                cli_helpers.shell_complete_path,

-                ["vault", "--import"],

-                "",

-                [click.shell_completion.CompletionItem("", type="file")],

-                id="base_config-path",

-            ),

-            pytest.param(

-                {"services": {}},

-                cli_helpers.shell_complete_path,

-                ["vault", "--import"],

-                "",

-                [click.shell_completion.CompletionItem("", type="file")],

-                id="empty_config-path",

-            ),

-        ],

-    )

-    COMPLETABLE_SERVICE_NAMES = pytest.mark.parametrize(

-        ["config", "incomplete", "completions"],

-        [

-            pytest.param(

-                {"services": {}},

-                "",

-                frozenset(),

-                id="no_services",

-            ),

-            pytest.param(

-                {"services": {}},

-                "partial",

-                frozenset(),

-                id="no_services_partial",

-            ),

-            pytest.param(

-                {"services": {DUMMY_SERVICE: {"length": 10}}},

-                "",

-                frozenset({DUMMY_SERVICE}),

-                id="one_service",

-            ),

-            pytest.param(

-                {"services": {DUMMY_SERVICE: {"length": 10}}},

-                DUMMY_SERVICE[:4],

-                frozenset({DUMMY_SERVICE}),

-                id="one_service_partial",

-            ),

-            pytest.param(

-                {"services": {DUMMY_SERVICE: {"length": 10}}},

-                DUMMY_SERVICE[-4:],

-                frozenset(),

-                id="one_service_partial_miss",

-            ),

-        ],

-    )

-    SERVICE_NAME_COMPLETION_INPUTS = pytest.mark.parametrize(

-        ["config", "key", "incomplete", "completions"],

-        [

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "newline\nin\nname": {"length": 10},

-                    },

-                },

-                "newline\nin\nname",

-                "",

-                frozenset({DUMMY_SERVICE}),

-                id="newline",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "newline\nin\nname": {"length": 10},

-                    },

-                },

-                "newline\nin\nname",

-                "serv",

-                frozenset({DUMMY_SERVICE}),

-                id="newline_partial_other",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "newline\nin\nname": {"length": 10},

-                    },

-                },

-                "newline\nin\nname",

-                "newline",

-                frozenset({}),

-                id="newline_partial_specific",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "nul\x00in\x00name": {"length": 10},

-                    },

-                },

-                "nul\x00in\x00name",

-                "",

-                frozenset({DUMMY_SERVICE}),

-                id="nul",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "nul\x00in\x00name": {"length": 10},

-                    },

-                },

-                "nul\x00in\x00name",

-                "serv",

-                frozenset({DUMMY_SERVICE}),

-                id="nul_partial_other",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "nul\x00in\x00name": {"length": 10},

-                    },

-                },

-                "nul\x00in\x00name",

-                "nul",

-                frozenset({}),

-                id="nul_partial_specific",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "backspace\bin\bname": {"length": 10},

-                    },

-                },

-                "backspace\bin\bname",

-                "",

-                frozenset({DUMMY_SERVICE}),

-                id="backspace",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "backspace\bin\bname": {"length": 10},

-                    },

-                },

-                "backspace\bin\bname",

-                "serv",

-                frozenset({DUMMY_SERVICE}),

-                id="backspace_partial_other",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "backspace\bin\bname": {"length": 10},

-                    },

-                },

-                "backspace\bin\bname",

-                "back",

-                frozenset({}),

-                id="backspace_partial_specific",

-            ),

-            pytest.param(

-                {

-                    "services": {

-                        DUMMY_SERVICE: {"length": 10},

-                        "del\x7fin\x7fname": {"length": 10},

-                    },

-                },

-                "del\x7fin\x7fname",

-                "",

-                frozenset({DUMMY_SERVICE}),

-                id="del",

-            ),

-            pytest.param(