Clean up testing machinery (types, helper functions) (f76e05e) - derivepassphrase.git

Clean up testing machinery (types, helper functions)

Marco Ricci commited on 2024-09-02 01:23:14
Zeige 6 geänderte Dateien mit 445 Einfügungen und 431 Löschungen.

- Submit all input to, and read all output from, `click`-based
  command-line interfaces via the textual streams.  This includes the
  `.stdout`/`.output` and `.stderr` properties of a test runner result,
  and the input to the command-line call.

- Write a new `typing.NamedTuple`-based interface for collecting the
  test runner result in a readable fashion, because the
  `click.testing.Result` `repr` output is really unhelpful.  This also
  allows to define a higher-level API to check whether a `click`
  application ran successfully, with certain expected output, or whether
  it ran unsuccessfully, with certain expected error output.

- Annotate all pytest `monkeypatch` fixtures as `pytest.MonkeyPatch`.

tests/__init__.py 41c8758..fee9d7b
tests/test_derivepassphrase_cli.py d1fcb2b..f74aafe
tests/test_derivepassphrase_exporter.py 05d6894..9a6edee
tests/test_derivepassphrase_exporter_cli.py 560fbdc..9179a57
tests/test_derivepassphrase_ssh_agent.py c0194fc..70f1954
tests/test_derivepassphrase_vault.py b221bc6..c21aa82

tests/__init__.py

Zeige Datei @ f76e05e

@@ -15,7 +15,7 @@ import zipfile
 from typing import TYPE_CHECKING
 
 import pytest
-from typing_extensions import assert_never
+from typing_extensions import NamedTuple, Self, assert_never
 
 from derivepassphrase import _types, cli
 
@@ -323,7 +323,7 @@ JAu0J3Q+cypZuKQVAAAAMQD5sTy8p+B1cn/DhOmXquui1BcxvASqzzevkBlbQoBa73y04B
 }
 
 DUMMY_SERVICE = 'service1'
-DUMMY_PASSPHRASE = b'my secret passphrase\n'
+DUMMY_PASSPHRASE = 'my secret passphrase'
 DUMMY_KEY1 = SUPPORTED_KEYS['ed25519']['public_key_data']
 DUMMY_KEY1_B64 = base64.standard_b64encode(DUMMY_KEY1).decode('ASCII')
 DUMMY_KEY2 = SUPPORTED_KEYS['rsa']['public_key_data']
@@ -355,7 +355,7 @@ VAULT_MASTER_KEY = 'vault key'
 VAULT_V02_CONFIG = 'P7xeh5y4jmjpJ2pFq4KUcTVoaE9ZOEkwWmpVTURSSWQxbGt6emN4aFE4eFM3anVPbDRNTGpOLzY3eDF5aE1YTm5LNWh5Q1BwWTMwM3M5S083MWRWRFlmOXNqSFJNcStGMWFOS3c2emhiOUNNenZYTmNNMnZxaUErdlRoOGF2ZHdGT1ZLNTNLOVJQcU9jWmJrR3g5N09VcVBRZ0ZnSFNUQy9HdFVWWnFteVhRVkY3MHNBdnF2ZWFEbFBseWRGelE1c3BFTnVUckRQdWJSL29wNjFxd2Y2ZVpob3VyVzRod3FKTElTenJ1WTZacTJFOFBtK3BnVzh0QWVxcWtyWFdXOXYyenNQeFNZbWt1MDU2Vm1kVGtISWIxWTBpcWRFbyswUVJudVVhZkVlNVpGWDA4WUQ2Q2JTWW81SnlhQ2Zxa3cxNmZoQjJES0Uyd29rNXpSck5iWVBrVmEwOXFya1NpMi9saU5LL3F0M3N3MjZKekNCem9ER2svWkZ0SUJLdmlHRno0VlQzQ3pqZTBWcTM3YmRiNmJjTkhqUHZoQ0NxMW1ldW1XOFVVK3pQMEtUMkRMVGNvNHFlOG40ck5KcGhsYXg1b1VzZ1NYU1B2T3RXdEkwYzg4NWE3YWUzOWI1MDI0MThhMWZjODQ3MDA2OTJmNDQ0MDkxNGFiNmRlMGQ2YjZiNjI5NGMwN2IwMmI4MGZi'  # noqa: E501
 VAULT_V02_CONFIG_DATA = {
     'global': {
-        'phrase': DUMMY_PASSPHRASE.decode('utf-8').rstrip('\n'),
+        'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
     },
     'services': {
         '(meta)': {
@@ -367,7 +367,7 @@ VAULT_V02_CONFIG_DATA = {
 VAULT_V03_CONFIG = 'sBPBrr8BFHPxSJkV/A53zk9zwDQHFxLe6UIusCVvzFQre103pcj5xxmE11lMTA0U2QTYjkhRXKkH5WegSmYpAnzReuRsYZlWWp6N4kkubf+twZ9C3EeggPm7as2Af4TICHVbX4uXpIHeQJf9y1OtqrO+SRBrgPBzgItoxsIxebxVKgyvh1CZQOSkn7BIzt9xKhDng3ubS4hQ91fB0QCumlldTbUl8tj4Xs5JbvsSlUMxRlVzZ0OgAOrSsoWELXmsp6zXFa9K6wIuZa4wQuMLQFHiA64JO1CR3I+rviWCeMlbTOuJNx6vMB5zotKJqA2hIUpN467TQ9vI4g/QTo40m5LT2EQKbIdTvBQAzcV4lOcpr5Lqt4LHED5mKvm/4YfpuuT3I3XCdWfdG5SB7ciiB4Go+xQdddy3zZMiwm1fEwIB8XjFf2cxoJdccLQ2yxf+9diedBP04EsMHrvxKDhQ7/vHl7xF2MMFTDKl3WFd23vvcjpR1JgNAKYprG/e1p/7'  # noqa: E501
 VAULT_V03_CONFIG_DATA = {
     'global': {
-        'phrase': DUMMY_PASSPHRASE.decode('utf-8').rstrip('\n'),
+        'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
     },
     'services': {
         '(meta)': {
@@ -430,7 +430,7 @@ AAABAAAApIHsBwAAMWFQSwUGAAAAAAUABQDzAAAABAoAAAAA
 """
 VAULT_STOREROOM_CONFIG_DATA = {
     'global': {
-        'phrase': DUMMY_PASSPHRASE.decode('utf-8').rstrip('\n'),
+        'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
     },
     'services': {
         '(meta)': {
@@ -486,7 +486,7 @@ AAAApIHIBAAAMWVQSwUGAAAAAAQABADDAAAAoQYAAAAA
 """
 
 CANNOT_LOAD_CRYPTOGRAPHY = (
-    b'Cannot load the required Python module "cryptography".'
+    'Cannot load the required Python module "cryptography".'
 )
 
 skip_if_no_agent = pytest.mark.skipif(
@@ -543,7 +543,7 @@ def phrase_from_key(key: bytes) -> bytes:
 
 @contextlib.contextmanager
 def isolated_config(
-    monkeypatch: Any,
+    monkeypatch: pytest.MonkeyPatch,
     runner: click.testing.CliRunner,
     config: Any,
 ) -> Iterator[None]:
@@ -615,7 +615,7 @@ def isolated_vault_exporter_config(
 
 def auto_prompt(*args: Any, **kwargs: Any) -> str:
     del args, kwargs  # Unused.
-    return DUMMY_PASSPHRASE.decode('UTF-8')
+    return DUMMY_PASSPHRASE
 
 
 def make_file_readonly(
@@ -668,3 +668,63 @@ def make_file_readonly(
     finally:
         if isinstance(fname, int):
             os.close(fname)
+
+
+class ReadableResult(NamedTuple):
+    """Helper class for formatting and testing click.testing.Result objects."""
+
+    exception: BaseException | None
+    exit_code: int
+    output: str
+    stderr: str
+
+    @classmethod
+    def parse(cls, r: click.testing.Result, /) -> Self:
+        try:
+            stderr = r.stderr
+        except ValueError:
+            stderr = r.output
+        return cls(r.exception, r.exit_code, r.output or '', stderr or '')
+
+    def clean_exit(
+        self, *, output: str = '', empty_stderr: bool = False
+    ) -> bool:
+        """Return whether the invocation exited cleanly.
+
+        Args:
+            output:
+                An expected output string.
+
+        """
+        return (
+            (
+                not self.exception
+                or (
+                    isinstance(self.exception, SystemExit)
+                    and self.exit_code == 0
+                )
+            )
+            and (not output or output in self.output)
+            and (not empty_stderr or not self.stderr)
+        )
+
+    def error_exit(
+        self, *, error: str | type[BaseException] = BaseException
+    ) -> bool:
+        """Return whether the invocation exited uncleanly.
+
+        Args:
+            error:
+                An expected error message, or an expected numeric error
+                code, or an expected exception type.
+
+        """
+        match error:
+            case str():
+                return (
+                    isinstance(self.exception, SystemExit)
+                    and self.exit_code > 0
+                    and (not error or error in self.stderr)
+                )
+            case _:
+                return isinstance(self.exception, error)

tests/test_derivepassphrase_cli.py

Zeige Datei @ f76e05e

@@ -44,12 +44,12 @@ DUMMY_KEY3_B64 = tests.DUMMY_KEY3_B64
 class IncompatibleConfiguration(NamedTuple):
     other_options: list[tuple[str, ...]]
     needs_service: bool | None
-    input: bytes | None
+    input: str | None
 
 
 class SingleConfiguration(NamedTuple):
     needs_service: bool | None
-    input: bytes | None
+    input: str | None
     check_success: bool
 
 
@@ -57,7 +57,7 @@ class OptionCombination(NamedTuple):
     options: list[str]
     incompatible: bool
     needs_service: bool | None
-    input: bytes | None
+    input: str | None
     check_success: bool
 
 
@@ -165,7 +165,7 @@ SINGLES: dict[tuple[str, ...], SingleConfiguration] = {
     ('--delete-globals',): SingleConfiguration(False, None, True),
     ('--clear',): SingleConfiguration(False, None, True),
     ('--export', '-'): SingleConfiguration(False, None, True),
-    ('--import', '-'): SingleConfiguration(False, b'{"services": {}}', True),
+    ('--import', '-'): SingleConfiguration(False, '{"services": {}}', True),
 }
 INTERESTING_OPTION_COMBINATIONS: list[OptionCombination] = []
 config: IncompatibleConfiguration | SingleConfiguration
@@ -200,29 +200,29 @@ for opt, config in SINGLES.items():
 
 
 class TestCLI:
-    def test_200_help_output(self, monkeypatch: Any) -> None:
+    def test_200_help_output(self, monkeypatch: pytest.MonkeyPatch) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
             runner=runner,
             config={'services': {}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, ['--help'], catch_exceptions=False
             )
-        assert result.exit_code == 0
-        assert (
-            'Password generation:\n' in result.output
-        ), 'Option groups not respected in help text.'
-        assert (
-            'Use NUMBER=0, e.g. "--symbol 0"' in result.output
-        ), 'Option group epilog not printed.'
+            result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(
+            empty_stderr=True, output='Password generation:\n'
+        ), 'expected clean exit, and option groups in help text'
+        assert result.clean_exit(
+            empty_stderr=True, output='Use NUMBER=0, e.g. "--symbol 0"'
+        ), 'expected clean exit, and option group epilog in help text'
 
     @pytest.mark.parametrize(
         'charset_name', ['lower', 'upper', 'number', 'space', 'dash', 'symbol']
     )
     def test_201_disable_character_set(
-        self, monkeypatch: Any, charset_name: str
+        self, monkeypatch: pytest.MonkeyPatch, charset_name: str
     ) -> None:
         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
         option = f'--{charset_name}'
@@ -233,25 +233,22 @@ class TestCLI:
             runner=runner,
             config={'services': {}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 [option, '0', '-p', DUMMY_SERVICE],
                 input=DUMMY_PASSPHRASE,
                 catch_exceptions=False,
             )
-        assert (
-            result.exit_code == 0
-        ), f'program died unexpectedly with exit code {result.exit_code}'
-        assert (
-            not result.stderr_bytes
-        ), f'program barfed on stderr: {result.stderr_bytes!r}'
+            result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(empty_stderr=True), 'expected clean exit:'
         for c in charset:
-            assert c not in result.stdout, (
-                f'derived password contains forbidden character {c!r}: '
-                f'{result.stdout!r}'
-            )
+            assert (
+                c not in result.output
+            ), f'derived password contains forbidden character {c!r}'
 
-    def test_202_disable_repetition(self, monkeypatch: Any) -> None:
+    def test_202_disable_repetition(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -259,23 +256,21 @@ class TestCLI:
             runner=runner,
             config={'services': {}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--repeat', '0', '-p', DUMMY_SERVICE],
                 input=DUMMY_PASSPHRASE,
                 catch_exceptions=False,
             )
-        assert (
-            result.exit_code == 0
-        ), f'program died unexpectedly with exit code {result.exit_code}'
-        assert (
-            not result.stderr_bytes
-        ), f'program barfed on stderr: {result.stderr_bytes!r}'
-        passphrase = result.stdout.rstrip('\r\n')
+            result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(
+            empty_stderr=True
+        ), 'expected clean exit and empty stderr'
+        passphrase = result.output.rstrip('\r\n')
         for i in range(len(passphrase) - 1):
             assert passphrase[i : i + 1] != passphrase[i + 1 : i + 2], (
                 f'derived password contains repeated character '
-                f'at position {i}: {result.stdout!r}'
+                f'at position {i}: {result.output!r}'
             )
 
     @pytest.mark.parametrize(
@@ -290,11 +285,7 @@ class TestCLI:
             ),
             pytest.param(
                 {
-                    'global': {
-                        'phrase': DUMMY_PASSPHRASE.rstrip(b'\n').decode(
-                            'ASCII'
-                        )
-                    },
+                    'global': {'phrase': DUMMY_PASSPHRASE.rstrip('\n')},
                     'services': {
                         DUMMY_SERVICE: {
                             'key': DUMMY_KEY1_B64,
@@ -308,7 +299,7 @@ class TestCLI:
     )
     def test_204a_key_from_config(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         config: _types.VaultConfig,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
@@ -318,21 +309,24 @@ class TestCLI:
             monkeypatch.setattr(
                 dpp.vault.Vault, 'phrase_from_key', tests.phrase_from_key
             )
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, [DUMMY_SERVICE], catch_exceptions=False
             )
-            assert (result.exit_code, result.stderr_bytes) == (
-                0,
-                b'',
-            ), 'program exited with failure'
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(
+            empty_stderr=True
+        ), 'expected clean exit and empty stderr'
+        assert _result.stdout_bytes
         assert (
-                result.stdout_bytes.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
-            ), 'program generated unexpected result (phrase instead of key)'
+            _result.stdout_bytes.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
+        ), 'known false output: phrase-based instead of key-based'
         assert (
-                result.stdout_bytes.rstrip(b'\n') == DUMMY_RESULT_KEY1
-            ), 'program generated unexpected result (wrong settings?)'
+            _result.stdout_bytes.rstrip(b'\n') == DUMMY_RESULT_KEY1
+        ), 'expected known output'
 
-    def test_204b_key_from_command_line(self, monkeypatch: Any) -> None:
+    def test_204b_key_from_command_line(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
@@ -345,21 +339,22 @@ class TestCLI:
             monkeypatch.setattr(
                 dpp.vault.Vault, 'phrase_from_key', tests.phrase_from_key
             )
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['-k', DUMMY_SERVICE],
-                input=b'1\n',
+                input='1\n',
                 catch_exceptions=False,
             )
-            assert result.exit_code == 0, 'program exited with failure'
-            assert result.stdout_bytes, 'program output expected'
-            last_line = result.stdout_bytes.splitlines(True)[-1]
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(), 'expected clean exit'
+        assert _result.stdout_bytes, 'expected program output'
+        last_line = _result.stdout_bytes.splitlines(True)[-1]
         assert (
             last_line.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
-            ), 'program generated unexpected result (phrase instead of key)'
+        ), 'known false output: phrase-based instead of key-based'
         assert (
             last_line.rstrip(b'\n') == DUMMY_RESULT_KEY1
-            ), 'program generated unexpected result (wrong settings?)'
+        ), 'expected known output'
 
     @tests.skip_if_no_agent
     @pytest.mark.parametrize(
@@ -388,7 +383,7 @@ class TestCLI:
     @pytest.mark.parametrize('key_index', [1, 2, 3], ids=lambda i: f'index{i}')
     def test_204c_key_override_on_command_line(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         config: dict[str, Any],
         key_index: int,
     ) -> None:
@@ -410,21 +405,22 @@ class TestCLI:
         with tests.isolated_config(
             monkeypatch=monkeypatch, runner=runner, config=config
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['-k', DUMMY_SERVICE],
-                input=f'{key_index}\n'.encode('ASCII'),
+                input=f'{key_index}\n',
             )
-            assert result.stderr_bytes is not None
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(), 'expected clean exit'
+        assert result.output, 'expected program output'
+        assert result.stderr, 'expected stderr'
         assert (
-                b'Error:' not in result.stderr_bytes
-            ), 'program exited with failure'
-            assert result.stdout_bytes, 'program output expected'
-            assert result.exit_code == 0, 'program exited with failure'
+            'Error:' not in result.stderr
+        ), 'expected no error messages on stderr'
 
     def test_205_service_phrase_if_key_in_global_config(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -434,26 +430,25 @@ class TestCLI:
                 'global': {'key': DUMMY_KEY1_B64},
                 'services': {
                     DUMMY_SERVICE: {
-                        'phrase': DUMMY_PASSPHRASE.rstrip(b'\n').decode(
-                            'ASCII'
-                        ),
+                        'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
                         **DUMMY_CONFIG_SETTINGS,
                     }
                 },
             },
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, [DUMMY_SERVICE], catch_exceptions=False
             )
-            assert result.exit_code == 0, 'program exited with failure'
-            assert result.stdout_bytes, 'program output expected'
-            last_line = result.stdout_bytes.splitlines(True)[-1]
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(), 'expected clean exit'
+        assert _result.stdout_bytes, 'expected program output'
+        last_line = _result.stdout_bytes.splitlines(True)[-1]
         assert (
             last_line.rstrip(b'\n') != DUMMY_RESULT_KEY1
-            ), 'program generated unexpected result (key instead of phrase)'
+        ), 'known false output: key-based instead of phrase-based'
         assert (
             last_line.rstrip(b'\n') == DUMMY_RESULT_PASSPHRASE
-            ), 'program generated unexpected result (wrong settings?)'
+        ), 'expected known output'
 
     @pytest.mark.parametrize(
         'option',
@@ -469,7 +464,7 @@ class TestCLI:
         ],
     )
     def test_210_invalid_argument_range(
-        self, monkeypatch: Any, option: str
+        self, monkeypatch: pytest.MonkeyPatch, option: str
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -478,19 +473,16 @@ class TestCLI:
             config={'services': {}},
         ):
             for value in '-42', 'invalid':
-                result = runner.invoke(
+                _result = runner.invoke(
                     cli.derivepassphrase,
                     [option, value, '-p', DUMMY_SERVICE],
                     input=DUMMY_PASSPHRASE,
                     catch_exceptions=False,
                 )
-                assert result.exit_code > 0, 'program unexpectedly succeeded'
-                assert (
-                    result.stderr_bytes
-                ), 'program did not print any error message'
-                assert (
-                    b'Error: Invalid value' in result.stderr_bytes
-                ), 'program did not print the expected error message'
+                result = tests.ReadableResult.parse(_result)
+                assert result.error_exit(
+                    error='Error: Invalid value'
+                ), 'expected error exit and known error message'
 
     @pytest.mark.parametrize(
         ['options', 'service', 'input', 'check_success'],
@@ -502,10 +494,10 @@ class TestCLI:
     )
     def test_211_service_needed(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         options: list[str],
         service: bool | None,
-        input: bytes | None,
+        input: str | None,
         check_success: bool,
     ) -> None:
         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
@@ -515,30 +507,26 @@ class TestCLI:
             runner=runner,
             config={'global': {'phrase': 'abc'}, 'services': {}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 options if service else [*options, DUMMY_SERVICE],
                 input=input,
                 catch_exceptions=False,
             )
+            result = tests.ReadableResult.parse(_result)
             if service is not None:
-                assert result.exit_code > 0, 'program unexpectedly succeeded'
-                assert (
-                    result.stderr_bytes
-                ), 'program did not print any error message'
                 err_msg = (
-                    b' requires a SERVICE'
+                    ' requires a SERVICE'
                     if service
-                    else b' does not take a SERVICE argument'
+                    else ' does not take a SERVICE argument'
                 )
-                assert (
-                    err_msg in result.stderr_bytes
-                ), 'program did not print the expected error message'
+                assert result.error_exit(
+                    error=err_msg
+                ), 'expected error exit and known error message'
             else:
-                assert (result.exit_code, result.stderr_bytes) == (
-                    0,
-                    b'',
-                ), 'program unexpectedly failed'
+                assert result.clean_exit(
+                    empty_stderr=True
+                ), 'expected clean exit'
         if check_success:
             with tests.isolated_config(
                 monkeypatch=monkeypatch,
@@ -548,16 +536,14 @@ class TestCLI:
                 monkeypatch.setattr(
                     cli, '_prompt_for_passphrase', tests.auto_prompt
                 )
-                result = runner.invoke(
+                _result = runner.invoke(
                     cli.derivepassphrase,
                     [*options, DUMMY_SERVICE] if service else options,
                     input=input,
                     catch_exceptions=False,
                 )
-                assert (result.exit_code, result.stderr_bytes) == (
-                    0,
-                    b'',
-                ), 'program unexpectedly failed'
+                result = tests.ReadableResult.parse(_result)
+            assert result.clean_exit(empty_stderr=True), 'expected clean exit'
 
     @pytest.mark.parametrize(
         ['options', 'service'],
@@ -569,7 +555,7 @@ class TestCLI:
     )
     def test_212_incompatible_options(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         options: list[str],
         service: bool | None,
     ) -> None:
@@ -579,65 +565,58 @@ class TestCLI:
             runner=runner,
             config={'services': {}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 [*options, DUMMY_SERVICE] if service else options,
                 input=DUMMY_PASSPHRASE,
                 catch_exceptions=False,
             )
-        assert result.exit_code > 0, 'program unexpectedly succeeded'
-        assert result.stderr_bytes, 'program did not print any error message'
-        assert (
-            b'mutually exclusive with ' in result.stderr_bytes
-        ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='mutually exclusive with '
+        ), 'expected error exit and known error message'
 
     def test_213_import_bad_config_not_vault_config(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--import', '-'],
-                input=b'null',
+                input='null',
                 catch_exceptions=False,
             )
-            assert result.exit_code > 0, 'program unexpectedly succeeded'
-            assert (
-                result.stderr_bytes
-            ), 'program did not print any error message'
-            assert (
-                b'Invalid vault config' in result.stderr_bytes
-            ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Invalid vault config'
+        ), 'expected error exit and known error message'
 
     def test_213a_import_bad_config_not_json_data(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--import', '-'],
-                input=b'This string is not valid JSON.',
+                input='This string is not valid JSON.',
                 catch_exceptions=False,
             )
-            assert result.exit_code > 0, 'program unexpectedly succeeded'
-            assert (
-                result.stderr_bytes
-            ), 'program did not print any error message'
-            assert (
-                b'cannot decode JSON' in result.stderr_bytes
-            ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='cannot decode JSON'
+        ), 'expected error exit and known error message'
 
     def test_213b_import_bad_config_not_a_file(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         # `isolated_config` validates the configuration.  So, to pass an
@@ -651,23 +630,19 @@ class TestCLI:
             ) as outfile:
                 print('This string is not valid JSON.', file=outfile)
             dname = os.path.dirname(cli._config_filename())
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--import', os.fsdecode(dname)],
                 catch_exceptions=False,
             )
-            assert result.exit_code > 0, 'program unexpectedly succeeded'
-            assert (
-                result.stderr_bytes
-            ), 'program did not print any error message'
-            assert (
-                os.strerror(errno.EISDIR).encode('utf-8')
-                in result.stderr_bytes
-            ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error=os.strerror(errno.EISDIR)
+        ), 'expected error exit and known error message'
 
     def test_214_export_settings_no_stored_settings(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -675,39 +650,34 @@ class TestCLI:
         ):
             with contextlib.suppress(FileNotFoundError):
                 os.remove(cli._config_filename())
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, ['--export', '-'], catch_exceptions=False
             )
-            assert (result.exit_code, result.stderr_bytes) == (
-                0,
-                b'',
-            ), 'program exited with failure'
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(empty_stderr=True), 'expected clean exit'
 
     def test_214a_export_settings_bad_stored_config(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch, runner=runner, config={}
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--export', '-'],
-                input=b'null',
+                input='null',
                 catch_exceptions=False,
             )
-            assert result.exit_code > 0, 'program unexpectedly succeeded'
-            assert (
-                result.stderr_bytes
-            ), 'program did not print any error message'
-            assert (
-                b'Cannot load config' in result.stderr_bytes
-            ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Cannot load config'
+        ), 'expected error exit and known error message'
 
     def test_214b_export_settings_not_a_file(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -716,46 +686,40 @@ class TestCLI:
             with contextlib.suppress(FileNotFoundError):
                 os.remove(cli._config_filename())
             os.makedirs(cli._config_filename())
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--export', '-'],
-                input=b'null',
+                input='null',
                 catch_exceptions=False,
             )
-            assert result.exit_code > 0, 'program unexpectedly succeeded'
-            assert (
-                result.stderr_bytes
-            ), 'program did not print any error message'
-            assert (
-                b'Cannot load config' in result.stderr_bytes
-            ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Cannot load config'
+        ), 'expected error exit and known error message'
 
     def test_214c_export_settings_target_not_a_file(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
         ):
             dname = os.path.dirname(cli._config_filename())
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--export', os.fsdecode(dname)],
-                input=b'null',
+                input='null',
                 catch_exceptions=False,
             )
-            assert result.exit_code > 0, 'program unexpectedly succeeded'
-            assert (
-                result.stderr_bytes
-            ), 'program did not print any error message'
-            assert (
-                b'Cannot store config' in result.stderr_bytes
-            ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Cannot store config'
+        ), 'expected error exit and known error message'
 
     def test_214d_export_settings_settings_directory_not_a_directory(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -765,21 +729,20 @@ class TestCLI:
                 shutil.rmtree('.derivepassphrase')
             with open('.derivepassphrase', 'w', encoding='UTF-8') as outfile:
                 print('Obstruction!!', file=outfile)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--export', '-'],
-                input=b'null',
+                input='null',
                 catch_exceptions=False,
             )
-            assert result.exit_code > 0, 'program unexpectedly succeeded'
-            assert (
-                result.stderr_bytes
-            ), 'program did not print any error message'
-            assert (
-                b'Cannot load config' in result.stderr_bytes
-            ), 'program did not print the expected error message'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Cannot load config'
+        ), 'expected error exit and known error message'
 
-    def test_220_edit_notes_successfully(self, monkeypatch: Any) -> None:
+    def test_220_edit_notes_successfully(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         edit_result = """
 
 # - - - - - >8 - - - - - >8 - - - - - >8 - - - - - >8 - - - - -
@@ -792,13 +755,11 @@ contents go here
             config={'global': {'phrase': 'abc'}, 'services': {}},
         ):
             monkeypatch.setattr(click, 'edit', lambda *a, **kw: edit_result)  # noqa: ARG005
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, ['--notes', 'sv'], catch_exceptions=False
             )
-            assert (result.exit_code, result.stderr_bytes) == (
-                0,
-                b'',
-            ), 'program exited with failure'
+            result = tests.ReadableResult.parse(_result)
+            assert result.clean_exit(empty_stderr=True), 'expected clean exit'
             with open(cli._config_filename(), encoding='UTF-8') as infile:
                 config = json.load(infile)
             assert config == {
@@ -806,7 +767,9 @@ contents go here
                 'services': {'sv': {'notes': 'contents go here'}},
             }
 
-    def test_221_edit_notes_noop(self, monkeypatch: Any) -> None:
+    def test_221_edit_notes_noop(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
@@ -814,18 +777,18 @@ contents go here
             config={'global': {'phrase': 'abc'}, 'services': {}},
         ):
             monkeypatch.setattr(click, 'edit', lambda *a, **kw: None)  # noqa: ARG005
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, ['--notes', 'sv'], catch_exceptions=False
             )
-            assert (result.exit_code, result.stderr_bytes) == (
-                0,
-                b'',
-            ), 'program exited with failure'
+            result = tests.ReadableResult.parse(_result)
+            assert result.clean_exit(empty_stderr=True), 'expected clean exit'
             with open(cli._config_filename(), encoding='UTF-8') as infile:
                 config = json.load(infile)
             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
 
-    def test_222_edit_notes_marker_removed(self, monkeypatch: Any) -> None:
+    def test_222_edit_notes_marker_removed(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
@@ -833,13 +796,11 @@ contents go here
             config={'global': {'phrase': 'abc'}, 'services': {}},
         ):
             monkeypatch.setattr(click, 'edit', lambda *a, **kw: 'long\ntext')  # noqa: ARG005
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, ['--notes', 'sv'], catch_exceptions=False
             )
-            assert (result.exit_code, result.stderr_bytes) == (
-                0,
-                b'',
-            ), 'program exited with failure'
+            result = tests.ReadableResult.parse(_result)
+            assert result.clean_exit(empty_stderr=True), 'expected clean exit'
             with open(cli._config_filename(), encoding='UTF-8') as infile:
                 config = json.load(infile)
             assert config == {
@@ -847,7 +808,9 @@ contents go here
                 'services': {'sv': {'notes': 'long\ntext'}},
             }
 
-    def test_223_edit_notes_abort(self, monkeypatch: Any) -> None:
+    def test_223_edit_notes_abort(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
@@ -855,14 +818,13 @@ contents go here
             config={'global': {'phrase': 'abc'}, 'services': {}},
         ):
             monkeypatch.setattr(click, 'edit', lambda *a, **kw: '\n\n')  # noqa: ARG005
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, ['--notes', 'sv'], catch_exceptions=False
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded'
-            assert result.stderr_bytes is not None
-            assert (
-                b'user aborted request' in result.stderr_bytes
-            ), 'expected error message missing'
+            result = tests.ReadableResult.parse(_result)
+            assert result.error_exit(
+                error='user aborted request'
+            ), 'expected known error message'
             with open(cli._config_filename(), encoding='UTF-8') as infile:
                 config = json.load(infile)
             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
@@ -872,17 +834,17 @@ contents go here
         [
             (
                 ['--phrase'],
-                b'my passphrase\n',
+                'my passphrase\n',
                 {'global': {'phrase': 'my passphrase'}, 'services': {}},
             ),
             (
                 ['--key'],
-                b'1\n',
+                '1\n',
                 {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
             ),
             (
                 ['--phrase', 'sv'],
-                b'my passphrase\n',
+                'my passphrase\n',
                 {
                     'global': {'phrase': 'abc'},
                     'services': {'sv': {'phrase': 'my passphrase'}},
@@ -890,7 +852,7 @@ contents go here
             ),
             (
                 ['--key', 'sv'],
-                b'1\n',
+                '1\n',
                 {
                     'global': {'phrase': 'abc'},
                     'services': {'sv': {'key': DUMMY_KEY1_B64}},
@@ -898,7 +860,7 @@ contents go here
             ),
             (
                 ['--key', '--length', '15', 'sv'],
-                b'1\n',
+                '1\n',
                 {
                     'global': {'phrase': 'abc'},
                     'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
@@ -908,9 +870,9 @@ contents go here
     )
     def test_224_store_config_good(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         command_line: list[str],
-        input: bytes,
+        input: str,
         result_config: Any,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
@@ -922,13 +884,14 @@ contents go here
             monkeypatch.setattr(
                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
             )
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--config', *command_line],
                 catch_exceptions=False,
                 input=input,
             )
-            assert result.exit_code == 0, 'program exited with failure'
+            result = tests.ReadableResult.parse(_result)
+            assert result.clean_exit(), 'expected clean exit'
             with open(cli._config_filename(), encoding='UTF-8') as infile:
                 config = json.load(infile)
             assert (
@@ -938,26 +901,22 @@ contents go here
     @pytest.mark.parametrize(
         ['command_line', 'input', 'err_text'],
         [
-            (
-                [],
-                b'',
-                b'Cannot update global settings without actual settings',
-            ),
+            ([], '', 'Cannot update global settings without actual settings'),
             (
                 ['sv'],
-                b'',
-                b'Cannot update service settings without actual settings',
+                '',
+                'Cannot update service settings without actual settings',
             ),
-            (['--phrase', 'sv'], b'', b'No passphrase given'),
-            (['--key'], b'', b'No valid SSH key selected'),
+            (['--phrase', 'sv'], '', 'No passphrase given'),
+            (['--key'], '', 'No valid SSH key selected'),
         ],
     )
     def test_225_store_config_fail(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         command_line: list[str],
-        input: bytes,
-        err_text: bytes,
+        input: str,
+        err_text: str,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -968,21 +927,20 @@ contents go here
             monkeypatch.setattr(
                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
             )
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--config', *command_line],
                 catch_exceptions=False,
                 input=input,
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded?!'
-            assert result.stderr_bytes is not None
-            assert (
-                err_text in result.stderr_bytes
-            ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error=err_text
+        ), 'expected error exit and known error message'
 
     def test_225a_store_config_fail_manual_no_ssh_key_selection(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -996,20 +954,19 @@ contents go here
                 raise RuntimeError(custom_error)
 
             monkeypatch.setattr(cli, '_select_ssh_key', raiser)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--key', '--config'],
                 catch_exceptions=False,
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded'
-            assert result.stderr_bytes is not None
-            assert (
-                custom_error.encode() in result.stderr_bytes
-            ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error=custom_error
+        ), 'expected error exit and known error message'
 
     def test_225b_store_config_fail_manual_no_ssh_agent(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -1018,20 +975,19 @@ contents go here
             config={'global': {'phrase': 'abc'}, 'services': {}},
         ):
             monkeypatch.delenv('SSH_AUTH_SOCK', raising=False)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--key', '--config'],
                 catch_exceptions=False,
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded'
-            assert result.stderr_bytes is not None
-            assert (
-                b'Cannot find running SSH agent' in result.stderr_bytes
-            ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Cannot find running SSH agent'
+        ), 'expected error exit and known error message'
 
     def test_225c_store_config_fail_manual_bad_ssh_agent_connection(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -1040,21 +996,20 @@ contents go here
             config={'global': {'phrase': 'abc'}, 'services': {}},
         ):
             monkeypatch.setenv('SSH_AUTH_SOCK', os.getcwd())
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--key', '--config'],
                 catch_exceptions=False,
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded'
-            assert result.stderr_bytes is not None
-            assert (
-                b'Cannot connect to SSH agent' in result.stderr_bytes
-            ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Cannot connect to SSH agent'
+        ), 'expected error exit and known error message'
 
     @pytest.mark.parametrize('try_race_free_implementation', [True, False])
     def test_225d_store_config_fail_manual_read_only_file(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         try_race_free_implementation: bool,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
@@ -1067,20 +1022,19 @@ contents go here
                 cli._config_filename(),
                 try_race_free_implementation=try_race_free_implementation,
             )
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--config', '--length=15', DUMMY_SERVICE],
                 catch_exceptions=False,
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded'
-            assert result.stderr_bytes is not None
-            assert (
-                b'Cannot store config' in result.stderr_bytes
-            ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Cannot store config'
+        ), 'expected error exit and known error message'
 
     def test_225e_store_config_fail_manual_custom_error(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -1095,50 +1049,51 @@ contents go here
                 raise RuntimeError(custom_error)
 
             monkeypatch.setattr(cli, '_save_config', raiser)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--config', '--length=15', DUMMY_SERVICE],
                 catch_exceptions=False,
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded'
-            assert result.stderr_bytes is not None
-            assert (
-                custom_error.encode() in result.stderr_bytes
-            ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error=custom_error
+        ), 'expected error exit and known error message'
 
-    def test_226_no_arguments(self, monkeypatch: Any) -> None:
+    def test_226_no_arguments(self, monkeypatch: pytest.MonkeyPatch) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
             runner=runner,
             config={'services': {}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, [], catch_exceptions=False
             )
-        assert result.exit_code != 0, 'program unexpectedly succeeded'
-        assert result.stderr_bytes is not None
-        assert (
-            b'SERVICE is required' in result.stderr_bytes
-        ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='SERVICE is required'
+        ), 'expected error exit and known error message'
 
-    def test_226a_no_passphrase_or_key(self, monkeypatch: Any) -> None:
+    def test_226a_no_passphrase_or_key(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
             runner=runner,
             config={'services': {}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase, [DUMMY_SERVICE], catch_exceptions=False
             )
-        assert result.exit_code != 0, 'program unexpectedly succeeded'
-        assert result.stderr_bytes is not None
-        assert (
-            b'No passphrase or key given' in result.stderr_bytes
-        ), 'expected error message missing'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='No passphrase or key given'
+        ), 'expected error exit and known error message'
 
-    def test_230_config_directory_nonexistant(self, monkeypatch: Any) -> None:
+    def test_230_config_directory_nonexistant(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """the-13th-letter/derivepassphrase#6"""
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -1157,16 +1112,17 @@ contents go here
                 return real_os_makedirs(*args, **kwargs)
 
             monkeypatch.setattr(os, 'makedirs', makedirs)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--config', '-p'],
                 catch_exceptions=False,
                 input='abc\n',
             )
+            result = tests.ReadableResult.parse(_result)
+            assert result.clean_exit(), 'expected clean exit'
             assert (
-                result.stderr_bytes == b'Passphrase:'
+                result.stderr == 'Passphrase:'
             ), 'program unexpectedly failed?!'
-            assert result.exit_code == 0, 'program unexpectedly failed?!'
             assert os_makedirs_called, 'os.makedirs has not been called?!'
             with open(cli._config_filename(), encoding='UTF-8') as infile:
                 config_readback = json.load(infile)
@@ -1175,7 +1131,9 @@ contents go here
                 'services': {},
             }, 'config mismatch'
 
-    def test_230a_config_directory_not_a_file(self, monkeypatch: Any) -> None:
+    def test_230a_config_directory_not_a_file(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """the-13th-letter/derivepassphrase#6"""
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -1196,19 +1154,20 @@ contents go here
                 return _save_config(*args, **kwargs)
 
             monkeypatch.setattr(cli, '_save_config', obstruct_config_saving)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--config', '-p'],
                 catch_exceptions=False,
                 input='abc\n',
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded?!'
-            assert result.stderr_bytes is not None
-            assert (
-                b'Cannot store config' in result.stderr_bytes
-            ), 'program unexpectedly failed?!'
+            result = tests.ReadableResult.parse(_result)
+            assert result.error_exit(
+                error='Cannot store config'
+            ), 'expected error exit and known error message'
 
-    def test_230b_store_config_custom_error(self, monkeypatch: Any) -> None:
+    def test_230b_store_config_custom_error(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
             monkeypatch=monkeypatch,
@@ -1228,20 +1187,19 @@ contents go here
                 return _save_config(*args, **kwargs)
 
             monkeypatch.setattr(cli, '_save_config', obstruct_config_saving)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 ['--config', '-p'],
                 catch_exceptions=False,
                 input='abc\n',
             )
-            assert result.exit_code != 0, 'program unexpectedly succeeded?!'
-            assert result.stderr_bytes is not None
-            assert (
-                b'Cannot store config' in result.stderr_bytes
-            ), 'program unexpectedly failed?!'
+            result = tests.ReadableResult.parse(_result)
+            assert result.error_exit(
+                error='Cannot store config'
+            ), 'expected error exit and known error message'
 
     @pytest.mark.parametrize(
-        ['command_line', 'input', 'error_message'],
+        ['command_line', 'input', 'warning_message'],
         [
             pytest.param(
                 ['--import', '-'],
@@ -1314,10 +1272,10 @@ contents go here
     )
     def test_300_unicode_normalization_form_warning(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         command_line: list[str],
         input: str | None,
-        error_message: str,
+        warning_message: str,
     ) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
         with tests.isolated_config(
@@ -1325,19 +1283,23 @@ contents go here
             runner=runner,
             config={'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}},
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase,
                 command_line,
                 catch_exceptions=False,
                 input=input,
             )
-            assert (result.exception, result.exit_code) == (None, 0)
-            assert result.stderr_bytes is not None
-            assert error_message in result.stderr
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(), 'expected clean exit'
+        assert (
+            warning_message in result.stderr
+        ), 'expected known warning message in stderr'
 
 
 class TestCLIUtils:
-    def test_100_save_bad_config(self, monkeypatch: Any) -> None:
+    def test_100_save_bad_config(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         runner = click.testing.CliRunner()
         with (
             tests.isolated_config(
@@ -1378,11 +1340,10 @@ class TestCLIUtils:
             click.echo('(Note: Vikings strictly optional.)')
 
         runner = click.testing.CliRunner(mix_stderr=True)
-        result = runner.invoke(driver, [], input='9')
-        assert result.exit_code == 0, 'driver program failed'
-        assert (
-            result.stdout
-            == """\
+        _result = runner.invoke(driver, [], input='9')
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(
+            output="""\
 Our menu:
 [1] Egg and bacon
 [2] Egg, sausage and bacon
@@ -1398,13 +1359,16 @@ Your selection? (1-10, leave empty to abort): 9
 A fine choice: Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
 (Note: Vikings strictly optional.)
 """  # noqa: E501
-        ), 'driver program produced unexpected output'
-        result = runner.invoke(
+        ), 'expected clean exit'
+        _result = runner.invoke(
             driver, ['--heading='], input='', catch_exceptions=True
         )
-        assert result.exit_code > 0, 'driver program succeeded?!'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error=IndexError
+        ), 'expected error exit and known error type'
         assert (
-            result.stdout
+            result.output
             == """\
 [1] Egg and bacon
 [2] Egg, sausage and bacon
@@ -1418,10 +1382,7 @@ A fine choice: Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam
 [10] Lobster thermidor aux crevettes with a mornay sauce garnished with truffle paté, brandy and a fried egg on top and spam
 Your selection? (1-10, leave empty to abort):\x20
 """  # noqa: E501
-        ), 'driver program produced unexpected output'
-        assert isinstance(
-            result.exception, IndexError
-        ), 'driver program did not raise IndexError?!'
+        ), 'expected known output'
 
     def test_102_prompt_for_selection_single(self) -> None:
         @click.command()
@@ -1439,37 +1400,38 @@ Your selection? (1-10, leave empty to abort):\x20
                 click.echo('Great!')
 
         runner = click.testing.CliRunner(mix_stderr=True)
-        result = runner.invoke(
+        _result = runner.invoke(
             driver, ['Will replace with spam. Confirm, y/n?'], input='y'
         )
-        assert result.exit_code == 0, 'driver program failed'
-        assert (
-            result.stdout
-            == """\
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(
+            output="""\
 [1] baked beans
 Will replace with spam. Confirm, y/n? y
 Great!
 """
-        ), 'driver program produced unexpected output'
-        result = runner.invoke(
+        ), 'expected clean exit'
+        _result = runner.invoke(
             driver,
             ['Will replace with spam, okay? ' '(Please say "y" or "n".)'],
             input='',
         )
-        assert result.exit_code > 0, 'driver program succeeded?!'
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error=IndexError
+        ), 'expected error exit and known error type'
         assert (
-            result.stdout
+            result.output
             == """\
 [1] baked beans
 Will replace with spam, okay? (Please say "y" or "n".):\x20
 Boo.
 """
-        ), 'driver program produced unexpected output'
-        assert isinstance(
-            result.exception, IndexError
-        ), 'driver program did not raise IndexError?!'
+        ), 'expected known output'
 
-    def test_103_prompt_for_passphrase(self, monkeypatch: Any) -> None:
+    def test_103_prompt_for_passphrase(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         monkeypatch.setattr(
             click,
             'prompt',
@@ -1513,7 +1475,7 @@ Boo.
     )
     def test_203_repeated_config_deletion(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         command_line: list[str],
         config: _types.VaultConfig,
         result_config: _types.VaultConfig,
@@ -1523,13 +1485,13 @@ Boo.
             with tests.isolated_config(
                 monkeypatch=monkeypatch, runner=runner, config=start_config
             ):
-                result = runner.invoke(
+                _result = runner.invoke(
                     cli.derivepassphrase, command_line, catch_exceptions=False
                 )
-                assert (result.exit_code, result.stderr_bytes) == (
-                    0,
-                    b'',
-                ), 'program exited with failure'
+                result = tests.ReadableResult.parse(_result)
+                assert result.clean_exit(
+                    empty_stderr=True
+                ), 'expected clean exit'
                 with open(cli._config_filename(), encoding='UTF-8') as infile:
                     config_readback = json.load(infile)
                 assert config_readback == result_config
@@ -1562,7 +1524,7 @@ Boo.
     @pytest.mark.parametrize('conn_hint', ['none', 'socket', 'client'])
     def test_227_get_suitable_ssh_keys(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         conn_hint: str,
     ) -> None:
         monkeypatch.setattr(

tests/test_derivepassphrase_exporter.py

Zeige Datei @ f76e05e

@@ -115,18 +115,16 @@ class Test002CLI:
             vault_config=tests.VAULT_V03_CONFIG,
             vault_key=tests.VAULT_MASTER_KEY,
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['-f', 'INVALID', 'VAULT_PATH'],
                 catch_exceptions=False,
             )
-        assert isinstance(result.exception, SystemExit)
-        assert result.exit_code
-        assert result.stderr_bytes
-        assert b'Invalid value for' in result.stderr_bytes
-        assert b'-f' in result.stderr_bytes
-        assert b'--format' in result.stderr_bytes
-        assert b'INVALID' in result.stderr_bytes
+        result = tests.ReadableResult.parse(_result)
+        for snippet in ('Invalid value for', '-f', '--format', 'INVALID'):
+            assert result.error_exit(
+                error=snippet
+            ), 'expected error exit and known error message'
 
     @tests.skip_if_cryptography_support
     @pytest.mark.parametrize(
@@ -166,12 +164,12 @@ class Test002CLI:
             vault_config=config,
             vault_key=key,
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['-f', format, 'VAULT_PATH'],
                 catch_exceptions=False,
             )
-        assert isinstance(result.exception, SystemExit)
-        assert result.exit_code
-        assert result.stderr_bytes
-        assert tests.CANNOT_LOAD_CRYPTOGRAPHY in result.stderr_bytes
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error=tests.CANNOT_LOAD_CRYPTOGRAPHY
+        ), 'expected error exit and known error message'

tests/test_derivepassphrase_exporter_cli.py

Zeige Datei @ f76e05e

@@ -31,13 +31,13 @@ class TestCLI:
             vault_key=tests.VAULT_MASTER_KEY,
         ):
             monkeypatch.setenv('VAULT_KEY', tests.VAULT_MASTER_KEY)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['VAULT_PATH'],
             )
-        assert not result.exception
-        assert (result.exit_code, result.stderr_bytes) == (0, b'')
-        assert json.loads(result.stdout) == tests.VAULT_V03_CONFIG_DATA
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(empty_stderr=True), 'expected clean exit'
+        assert json.loads(result.output) == tests.VAULT_V03_CONFIG_DATA
 
     def test_201_key_parameter(self, monkeypatch: pytest.MonkeyPatch) -> None:
         runner = click.testing.CliRunner(mix_stderr=False)
@@ -46,13 +46,13 @@ class TestCLI:
             runner=runner,
             vault_config=tests.VAULT_V03_CONFIG,
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['-k', tests.VAULT_MASTER_KEY, '.vault'],
             )
-        assert not result.exception
-        assert (result.exit_code, result.stderr_bytes) == (0, b'')
-        assert json.loads(result.stdout) == tests.VAULT_V03_CONFIG_DATA
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(empty_stderr=True), 'expected clean exit'
+        assert json.loads(result.output) == tests.VAULT_V03_CONFIG_DATA
 
     @pytest.mark.parametrize(
         ['format', 'config', 'config_data'],
@@ -90,13 +90,13 @@ class TestCLI:
             runner=runner,
             vault_config=config,
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['-f', format, '-k', tests.VAULT_MASTER_KEY, 'VAULT_PATH'],
             )
-        assert not result.exception
-        assert (result.exit_code, result.stderr_bytes) == (0, b'')
-        assert json.loads(result.stdout) == config_data
+        result = tests.ReadableResult.parse(_result)
+        assert result.clean_exit(empty_stderr=True), 'expected clean exit'
+        assert json.loads(result.output) == config_data
 
     # test_300_invalid_format is found in
     # tests.test_derivepassphrase_export::Test002CLI
@@ -112,18 +112,15 @@ class TestCLI:
             vault_config=tests.VAULT_V03_CONFIG,
             vault_key=tests.VAULT_MASTER_KEY,
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['does-not-exist.txt'],
             )
-        assert isinstance(result.exception, SystemExit)
-        assert result.exit_code
-        assert result.stderr_bytes
-        assert (
-            b"Cannot parse 'does-not-exist.txt' as a valid config"
-            in result.stderr_bytes
-        )
-        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error="Cannot parse 'does-not-exist.txt' as a valid config"
+        ), 'expected error exit and known error message'
+        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
 
     def test_302_vault_config_invalid(
         self,
@@ -136,17 +133,15 @@ class TestCLI:
             vault_config='',
             vault_key=tests.VAULT_MASTER_KEY,
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['.vault'],
             )
-        assert isinstance(result.exception, SystemExit)
-        assert result.exit_code
-        assert result.stderr_bytes
-        assert (
-            b"Cannot parse '.vault' as a valid config." in result.stderr_bytes
-        )
-        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error="Cannot parse '.vault' as a valid config"
+        ), 'expected error exit and known error message'
+        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
 
     def test_403_invalid_vault_config_bad_signature(
         self,
@@ -159,17 +154,15 @@ class TestCLI:
             vault_config=tests.VAULT_V02_CONFIG,
             vault_key=tests.VAULT_MASTER_KEY,
         ):
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['-f', 'v0.3', '.vault'],
             )
-        assert isinstance(result.exception, SystemExit)
-        assert result.exit_code
-        assert result.stderr_bytes
-        assert (
-            b"Cannot parse '.vault' as a valid config." in result.stderr_bytes
-        )
-        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error="Cannot parse '.vault' as a valid config"
+        ), 'expected error exit and known error message'
+        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
 
     def test_500_vault_config_invalid_internal(
         self,
@@ -187,15 +180,15 @@ class TestCLI:
                 return None
 
             monkeypatch.setattr(cli, '_load_data', _load_data)
-            result = runner.invoke(
+            _result = runner.invoke(
                 cli.derivepassphrase_export,
                 ['.vault'],
             )
-        assert isinstance(result.exception, SystemExit)
-        assert result.exit_code
-        assert result.stderr_bytes
-        assert b'Invalid vault config: ' in result.stderr_bytes
-        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
+        result = tests.ReadableResult.parse(_result)
+        assert result.error_exit(
+            error='Invalid vault config: '
+        ), 'expected error exit and known error message'
+        assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
 
 
 class TestStoreroom:

tests/test_derivepassphrase_ssh_agent.py

Zeige Datei @ f76e05e

@@ -41,7 +41,9 @@ class TestStaticFunctionality:
             keydata == public_key_data
         ), "recorded public key data doesn't match"
 
-    def test_200_constructor_no_running_agent(self, monkeypatch: Any) -> None:
+    def test_200_constructor_no_running_agent(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         monkeypatch.delenv('SSH_AUTH_SOCK', raising=False)
         sock = socket.socket(family=socket.AF_UNIX)
         with pytest.raises(
@@ -268,7 +270,7 @@ class TestAgentInteraction:
 
     @pytest.mark.parametrize(['key', 'single'], list(_params()))
     def test_210_ssh_key_selector(
-        self, monkeypatch: Any, key: bytes, single: bool
+        self, monkeypatch: pytest.MonkeyPatch, key: bytes, single: bool
     ) -> None:
         def key_is_suitable(key: bytes) -> bool:
             return key in {
@@ -308,24 +310,21 @@ class TestAgentInteraction:
             click.echo(base64.standard_b64encode(key).decode('ASCII'))
 
         runner = click.testing.CliRunner(mix_stderr=True)
-        result = runner.invoke(
+        _result = runner.invoke(
             driver,
             [],
             input=('yes\n' if single else f'{index}\n'),
             catch_exceptions=True,
         )
-        assert result.stdout.startswith(
-            'Suitable SSH keys:\n'
-        ), 'missing expected output'
-        assert text in result.stdout, 'missing expected output'
-        assert result.stdout.endswith(
-            f'\n{b64_key}\n'
-        ), 'missing expected output'
-        assert result.exit_code == 0, 'driver program failed?!'
+        result = tests.ReadableResult.parse(_result)
+        for snippet in ('Suitable SSH keys:\n', text, f'\n{b64_key}\n'):
+            assert result.clean_exit(output=snippet), 'expected clean exit'
 
     del _params
 
-    def test_300_constructor_bad_running_agent(self, monkeypatch: Any) -> None:
+    def test_300_constructor_bad_running_agent(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         monkeypatch.setenv('SSH_AUTH_SOCK', os.environ['SSH_AUTH_SOCK'] + '~')
         sock = socket.socket(family=socket.AF_UNIX)
         with pytest.raises(OSError):  # noqa: PT011
@@ -339,7 +338,7 @@ class TestAgentInteraction:
         ],
     )
     def test_310_truncated_server_response(
-        self, monkeypatch: Any, response: bytes
+        self, monkeypatch: pytest.MonkeyPatch, response: bytes
     ) -> None:
         client = ssh_agent.SSHAgentClient()
         response_stream = io.BytesIO(response)
@@ -382,7 +381,7 @@ class TestAgentInteraction:
     )
     def test_320_list_keys_error_responses(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         response_code: _types.SSH_AGENT,
         response: bytes | bytearray,
         exc_type: type[Exception],
@@ -419,7 +418,7 @@ class TestAgentInteraction:
     )
     def test_330_sign_error_responses(
         self,
-        monkeypatch: Any,
+        monkeypatch: pytest.MonkeyPatch,
         key: bytes | bytearray,
         check: bool,
         response: tuple[_types.SSH_AGENT, bytes | bytearray],

tests/test_derivepassphrase_vault.py

Zeige Datei @ f76e05e

@@ -7,7 +7,6 @@
 from __future__ import annotations
 
 import math
-from typing import Any
 
 import pytest
 
@@ -193,7 +192,10 @@ class TestVault:
         ],
     )
     def test_223_hash_length_expansion(
-        self, monkeypatch: Any, service: str | bytes, expected: bytes
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        service: str | bytes,
+        expected: bytes,
     ) -> None:
         v = Vault(phrase=self.phrase)
         monkeypatch.setattr(


...	...	@@ -15,7 +15,7 @@ import zipfile
15	15	from typing import TYPE_CHECKING
16	16
17	17	import pytest
18		-from typing_extensions import assert_never
	18	+from typing_extensions import NamedTuple, Self, assert_never
19	19
20	20	from derivepassphrase import _types, cli
21	21
...	...	@@ -323,7 +323,7 @@ JAu0J3Q+cypZuKQVAAAAMQD5sTy8p+B1cn/DhOmXquui1BcxvASqzzevkBlbQoBa73y04B
323	323	}
324	324
325	325	DUMMY_SERVICE = 'service1'
326		-DUMMY_PASSPHRASE = b'my secret passphrase\n'
	326	+DUMMY_PASSPHRASE = 'my secret passphrase'
327	327	DUMMY_KEY1 = SUPPORTED_KEYS['ed25519']['public_key_data']
328	328	DUMMY_KEY1_B64 = base64.standard_b64encode(DUMMY_KEY1).decode('ASCII')
329	329	DUMMY_KEY2 = SUPPORTED_KEYS['rsa']['public_key_data']
...	...	@@ -355,7 +355,7 @@ VAULT_MASTER_KEY = 'vault key'
355	355	VAULT_V02_CONFIG = 'P7xeh5y4jmjpJ2pFq4KUcTVoaE9ZOEkwWmpVTURSSWQxbGt6emN4aFE4eFM3anVPbDRNTGpOLzY3eDF5aE1YTm5LNWh5Q1BwWTMwM3M5S083MWRWRFlmOXNqSFJNcStGMWFOS3c2emhiOUNNenZYTmNNMnZxaUErdlRoOGF2ZHdGT1ZLNTNLOVJQcU9jWmJrR3g5N09VcVBRZ0ZnSFNUQy9HdFVWWnFteVhRVkY3MHNBdnF2ZWFEbFBseWRGelE1c3BFTnVUckRQdWJSL29wNjFxd2Y2ZVpob3VyVzRod3FKTElTenJ1WTZacTJFOFBtK3BnVzh0QWVxcWtyWFdXOXYyenNQeFNZbWt1MDU2Vm1kVGtISWIxWTBpcWRFbyswUVJudVVhZkVlNVpGWDA4WUQ2Q2JTWW81SnlhQ2Zxa3cxNmZoQjJES0Uyd29rNXpSck5iWVBrVmEwOXFya1NpMi9saU5LL3F0M3N3MjZKekNCem9ER2svWkZ0SUJLdmlHRno0VlQzQ3pqZTBWcTM3YmRiNmJjTkhqUHZoQ0NxMW1ldW1XOFVVK3pQMEtUMkRMVGNvNHFlOG40ck5KcGhsYXg1b1VzZ1NYU1B2T3RXdEkwYzg4NWE3YWUzOWI1MDI0MThhMWZjODQ3MDA2OTJmNDQ0MDkxNGFiNmRlMGQ2YjZiNjI5NGMwN2IwMmI4MGZi' # noqa: E501
356	356	VAULT_V02_CONFIG_DATA = {
357	357	'global': {
358		- 'phrase': DUMMY_PASSPHRASE.decode('utf-8').rstrip('\n'),
	358	+ 'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
359	359	},
360	360	'services': {
361	361	'(meta)': {
...	...	@@ -367,7 +367,7 @@ VAULT_V02_CONFIG_DATA = {
367	367	VAULT_V03_CONFIG = 'sBPBrr8BFHPxSJkV/A53zk9zwDQHFxLe6UIusCVvzFQre103pcj5xxmE11lMTA0U2QTYjkhRXKkH5WegSmYpAnzReuRsYZlWWp6N4kkubf+twZ9C3EeggPm7as2Af4TICHVbX4uXpIHeQJf9y1OtqrO+SRBrgPBzgItoxsIxebxVKgyvh1CZQOSkn7BIzt9xKhDng3ubS4hQ91fB0QCumlldTbUl8tj4Xs5JbvsSlUMxRlVzZ0OgAOrSsoWELXmsp6zXFa9K6wIuZa4wQuMLQFHiA64JO1CR3I+rviWCeMlbTOuJNx6vMB5zotKJqA2hIUpN467TQ9vI4g/QTo40m5LT2EQKbIdTvBQAzcV4lOcpr5Lqt4LHED5mKvm/4YfpuuT3I3XCdWfdG5SB7ciiB4Go+xQdddy3zZMiwm1fEwIB8XjFf2cxoJdccLQ2yxf+9diedBP04EsMHrvxKDhQ7/vHl7xF2MMFTDKl3WFd23vvcjpR1JgNAKYprG/e1p/7' # noqa: E501
368	368	VAULT_V03_CONFIG_DATA = {
369	369	'global': {
370		- 'phrase': DUMMY_PASSPHRASE.decode('utf-8').rstrip('\n'),
	370	+ 'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
371	371	},
372	372	'services': {
373	373	'(meta)': {
...	...	@@ -430,7 +430,7 @@ AAABAAAApIHsBwAAMWFQSwUGAAAAAAUABQDzAAAABAoAAAAA
430	430	"""
431	431	VAULT_STOREROOM_CONFIG_DATA = {
432	432	'global': {
433		- 'phrase': DUMMY_PASSPHRASE.decode('utf-8').rstrip('\n'),
	433	+ 'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
434	434	},
435	435	'services': {
436	436	'(meta)': {
...	...	@@ -486,7 +486,7 @@ AAAApIHIBAAAMWVQSwUGAAAAAAQABADDAAAAoQYAAAAA
486	486	"""
487	487
488	488	CANNOT_LOAD_CRYPTOGRAPHY = (
489		- b'Cannot load the required Python module "cryptography".'
	489	+ 'Cannot load the required Python module "cryptography".'
490	490	)
491	491
492	492	skip_if_no_agent = pytest.mark.skipif(
...	...	@@ -543,7 +543,7 @@ def phrase_from_key(key: bytes) -> bytes:
543	543
544	544	@contextlib.contextmanager
545	545	def isolated_config(
546		- monkeypatch: Any,
	546	+ monkeypatch: pytest.MonkeyPatch,
547	547	runner: click.testing.CliRunner,
548	548	config: Any,
549	549	) -> Iterator[None]:
...	...	@@ -615,7 +615,7 @@ def isolated_vault_exporter_config(
615	615
616	616	def auto_prompt(args: Any, *kwargs: Any) -> str:
617	617	del args, kwargs # Unused.
618		- return DUMMY_PASSPHRASE.decode('UTF-8')
	618	+ return DUMMY_PASSPHRASE
619	619
620	620
621	621	def make_file_readonly(
...	...	@@ -668,3 +668,63 @@ def make_file_readonly(
668	668	finally:
669	669	if isinstance(fname, int):
670	670	os.close(fname)
	671	+
	672	+
	673	+class ReadableResult(NamedTuple):
	674	+ """Helper class for formatting and testing click.testing.Result objects."""
	675	+
	676	+ exception: BaseException \| None
	677	+ exit_code: int
	678	+ output: str
	679	+ stderr: str
	680	+
	681	+ @classmethod
	682	+ def parse(cls, r: click.testing.Result, /) -> Self:
	683	+ try:
	684	+ stderr = r.stderr
	685	+ except ValueError:
	686	+ stderr = r.output
	687	+ return cls(r.exception, r.exit_code, r.output or '', stderr or '')
	688	+
	689	+ def clean_exit(
	690	+ self, *, output: str = '', empty_stderr: bool = False
	691	+ ) -> bool:
	692	+ """Return whether the invocation exited cleanly.
	693	+
	694	+ Args:
	695	+ output:
	696	+ An expected output string.
	697	+
	698	+ """
	699	+ return (
	700	+ (
	701	+ not self.exception
	702	+ or (
	703	+ isinstance(self.exception, SystemExit)
	704	+ and self.exit_code == 0
	705	+ )
	706	+ )
	707	+ and (not output or output in self.output)
	708	+ and (not empty_stderr or not self.stderr)
	709	+ )
	710	+
	711	+ def error_exit(
	712	+ self, *, error: str \| type[BaseException] = BaseException
	713	+ ) -> bool:
	714	+ """Return whether the invocation exited uncleanly.
	715	+
	716	+ Args:
	717	+ error:
	718	+ An expected error message, or an expected numeric error
	719	+ code, or an expected exception type.
	720	+
	721	+ """
	722	+ match error:
	723	+ case str():
	724	+ return (
	725	+ isinstance(self.exception, SystemExit)
	726	+ and self.exit_code > 0
	727	+ and (not error or error in self.stderr)
	728	+ )
	729	+ case _:
	730	+ return isinstance(self.exception, error)

...	...	@@ -115,18 +115,16 @@ class Test002CLI:
115	115	vault_config=tests.VAULT_V03_CONFIG,
116	116	vault_key=tests.VAULT_MASTER_KEY,
117	117	):
118		- result = runner.invoke(
	118	+ _result = runner.invoke(
119	119	cli.derivepassphrase_export,
120	120	['-f', 'INVALID', 'VAULT_PATH'],
121	121	catch_exceptions=False,
122	122	)
123		- assert isinstance(result.exception, SystemExit)
124		- assert result.exit_code
125		- assert result.stderr_bytes
126		- assert b'Invalid value for' in result.stderr_bytes
127		- assert b'-f' in result.stderr_bytes
128		- assert b'--format' in result.stderr_bytes
129		- assert b'INVALID' in result.stderr_bytes
	123	+ result = tests.ReadableResult.parse(_result)
	124	+ for snippet in ('Invalid value for', '-f', '--format', 'INVALID'):
	125	+ assert result.error_exit(
	126	+ error=snippet
	127	+ ), 'expected error exit and known error message'
130	128
131	129	@tests.skip_if_cryptography_support
132	130	@pytest.mark.parametrize(
...	...	@@ -166,12 +164,12 @@ class Test002CLI:
166	164	vault_config=config,
167	165	vault_key=key,
168	166	):
169		- result = runner.invoke(
	167	+ _result = runner.invoke(
170	168	cli.derivepassphrase_export,
171	169	['-f', format, 'VAULT_PATH'],
172	170	catch_exceptions=False,
173	171	)
174		- assert isinstance(result.exception, SystemExit)
175		- assert result.exit_code
176		- assert result.stderr_bytes
177		- assert tests.CANNOT_LOAD_CRYPTOGRAPHY in result.stderr_bytes
	172	+ result = tests.ReadableResult.parse(_result)
	173	+ assert result.error_exit(
	174	+ error=tests.CANNOT_LOAD_CRYPTOGRAPHY
	175	+ ), 'expected error exit and known error message'

...	...	@@ -31,13 +31,13 @@ class TestCLI:
31	31	vault_key=tests.VAULT_MASTER_KEY,
32	32	):
33	33	monkeypatch.setenv('VAULT_KEY', tests.VAULT_MASTER_KEY)
34		- result = runner.invoke(
	34	+ _result = runner.invoke(
35	35	cli.derivepassphrase_export,
36	36	['VAULT_PATH'],
37	37	)
38		- assert not result.exception
39		- assert (result.exit_code, result.stderr_bytes) == (0, b'')
40		- assert json.loads(result.stdout) == tests.VAULT_V03_CONFIG_DATA
	38	+ result = tests.ReadableResult.parse(_result)
	39	+ assert result.clean_exit(empty_stderr=True), 'expected clean exit'
	40	+ assert json.loads(result.output) == tests.VAULT_V03_CONFIG_DATA
41	41
42	42	def test_201_key_parameter(self, monkeypatch: pytest.MonkeyPatch) -> None:
43	43	runner = click.testing.CliRunner(mix_stderr=False)
...	...	@@ -46,13 +46,13 @@ class TestCLI:
46	46	runner=runner,
47	47	vault_config=tests.VAULT_V03_CONFIG,
48	48	):
49		- result = runner.invoke(
	49	+ _result = runner.invoke(
50	50	cli.derivepassphrase_export,
51	51	['-k', tests.VAULT_MASTER_KEY, '.vault'],
52	52	)
53		- assert not result.exception
54		- assert (result.exit_code, result.stderr_bytes) == (0, b'')
55		- assert json.loads(result.stdout) == tests.VAULT_V03_CONFIG_DATA
	53	+ result = tests.ReadableResult.parse(_result)
	54	+ assert result.clean_exit(empty_stderr=True), 'expected clean exit'
	55	+ assert json.loads(result.output) == tests.VAULT_V03_CONFIG_DATA
56	56
57	57	@pytest.mark.parametrize(
58	58	['format', 'config', 'config_data'],
...	...	@@ -90,13 +90,13 @@ class TestCLI:
90	90	runner=runner,
91	91	vault_config=config,
92	92	):
93		- result = runner.invoke(
	93	+ _result = runner.invoke(
94	94	cli.derivepassphrase_export,
95	95	['-f', format, '-k', tests.VAULT_MASTER_KEY, 'VAULT_PATH'],
96	96	)
97		- assert not result.exception
98		- assert (result.exit_code, result.stderr_bytes) == (0, b'')
99		- assert json.loads(result.stdout) == config_data
	97	+ result = tests.ReadableResult.parse(_result)
	98	+ assert result.clean_exit(empty_stderr=True), 'expected clean exit'
	99	+ assert json.loads(result.output) == config_data
100	100
101	101	# test_300_invalid_format is found in
102	102	# tests.test_derivepassphrase_export::Test002CLI
...	...	@@ -112,18 +112,15 @@ class TestCLI:
112	112	vault_config=tests.VAULT_V03_CONFIG,
113	113	vault_key=tests.VAULT_MASTER_KEY,
114	114	):
115		- result = runner.invoke(
	115	+ _result = runner.invoke(
116	116	cli.derivepassphrase_export,
117	117	['does-not-exist.txt'],
118	118	)
119		- assert isinstance(result.exception, SystemExit)
120		- assert result.exit_code
121		- assert result.stderr_bytes
122		- assert (
123		- b"Cannot parse 'does-not-exist.txt' as a valid config"
124		- in result.stderr_bytes
125		- )
126		- assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
	119	+ result = tests.ReadableResult.parse(_result)
	120	+ assert result.error_exit(
	121	+ error="Cannot parse 'does-not-exist.txt' as a valid config"
	122	+ ), 'expected error exit and known error message'
	123	+ assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
127	124
128	125	def test_302_vault_config_invalid(
129	126	self,
...	...	@@ -136,17 +133,15 @@ class TestCLI:
136	133	vault_config='',
137	134	vault_key=tests.VAULT_MASTER_KEY,
138	135	):
139		- result = runner.invoke(
	136	+ _result = runner.invoke(
140	137	cli.derivepassphrase_export,
141	138	['.vault'],
142	139	)
143		- assert isinstance(result.exception, SystemExit)
144		- assert result.exit_code
145		- assert result.stderr_bytes
146		- assert (
147		- b"Cannot parse '.vault' as a valid config." in result.stderr_bytes
148		- )
149		- assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
	140	+ result = tests.ReadableResult.parse(_result)
	141	+ assert result.error_exit(
	142	+ error="Cannot parse '.vault' as a valid config"
	143	+ ), 'expected error exit and known error message'
	144	+ assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
150	145
151	146	def test_403_invalid_vault_config_bad_signature(
152	147	self,
...	...	@@ -159,17 +154,15 @@ class TestCLI:
159	154	vault_config=tests.VAULT_V02_CONFIG,
160	155	vault_key=tests.VAULT_MASTER_KEY,
161	156	):
162		- result = runner.invoke(
	157	+ _result = runner.invoke(
163	158	cli.derivepassphrase_export,
164	159	['-f', 'v0.3', '.vault'],
165	160	)
166		- assert isinstance(result.exception, SystemExit)
167		- assert result.exit_code
168		- assert result.stderr_bytes
169		- assert (
170		- b"Cannot parse '.vault' as a valid config." in result.stderr_bytes
171		- )
172		- assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
	161	+ result = tests.ReadableResult.parse(_result)
	162	+ assert result.error_exit(
	163	+ error="Cannot parse '.vault' as a valid config"
	164	+ ), 'expected error exit and known error message'
	165	+ assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
173	166
174	167	def test_500_vault_config_invalid_internal(
175	168	self,
...	...	@@ -187,15 +180,15 @@ class TestCLI:
187	180	return None
188	181
189	182	monkeypatch.setattr(cli, '_load_data', _load_data)
190		- result = runner.invoke(
	183	+ _result = runner.invoke(
191	184	cli.derivepassphrase_export,
192	185	['.vault'],
193	186	)
194		- assert isinstance(result.exception, SystemExit)
195		- assert result.exit_code
196		- assert result.stderr_bytes
197		- assert b'Invalid vault config: ' in result.stderr_bytes
198		- assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr_bytes
	187	+ result = tests.ReadableResult.parse(_result)
	188	+ assert result.error_exit(
	189	+ error='Invalid vault config: '
	190	+ ), 'expected error exit and known error message'
	191	+ assert tests.CANNOT_LOAD_CRYPTOGRAPHY not in result.stderr
199	192
200	193
201	194	class TestStoreroom:

...	...	@@ -41,7 +41,9 @@ class TestStaticFunctionality:
41	41	keydata == public_key_data
42	42	), "recorded public key data doesn't match"
43	43
44		- def test_200_constructor_no_running_agent(self, monkeypatch: Any) -> None:
	44	+ def test_200_constructor_no_running_agent(
	45	+ self, monkeypatch: pytest.MonkeyPatch
	46	+ ) -> None:
45	47	monkeypatch.delenv('SSH_AUTH_SOCK', raising=False)
46	48	sock = socket.socket(family=socket.AF_UNIX)
47	49	with pytest.raises(
...	...	@@ -268,7 +270,7 @@ class TestAgentInteraction:
268	270
269	271	@pytest.mark.parametrize(['key', 'single'], list(_params()))
270	272	def test_210_ssh_key_selector(
271		- self, monkeypatch: Any, key: bytes, single: bool
	273	+ self, monkeypatch: pytest.MonkeyPatch, key: bytes, single: bool
272	274	) -> None:
273	275	def key_is_suitable(key: bytes) -> bool:
274	276	return key in {
...	...	@@ -308,24 +310,21 @@ class TestAgentInteraction:
308	310	click.echo(base64.standard_b64encode(key).decode('ASCII'))
309	311
310	312	runner = click.testing.CliRunner(mix_stderr=True)
311		- result = runner.invoke(
	313	+ _result = runner.invoke(
312	314	driver,
313	315	[],
314	316	input=('yes\n' if single else f'{index}\n'),
315	317	catch_exceptions=True,
316	318	)
317		- assert result.stdout.startswith(
318		- 'Suitable SSH keys:\n'
319		- ), 'missing expected output'
320		- assert text in result.stdout, 'missing expected output'
321		- assert result.stdout.endswith(
322		- f'\n{b64_key}\n'
323		- ), 'missing expected output'
324		- assert result.exit_code == 0, 'driver program failed?!'
	319	+ result = tests.ReadableResult.parse(_result)
	320	+ for snippet in ('Suitable SSH keys:\n', text, f'\n{b64_key}\n'):
	321	+ assert result.clean_exit(output=snippet), 'expected clean exit'
325	322
326	323	del _params
327	324
328		- def test_300_constructor_bad_running_agent(self, monkeypatch: Any) -> None:
	325	+ def test_300_constructor_bad_running_agent(
	326	+ self, monkeypatch: pytest.MonkeyPatch
	327	+ ) -> None:
329	328	monkeypatch.setenv('SSH_AUTH_SOCK', os.environ['SSH_AUTH_SOCK'] + '~')
330	329	sock = socket.socket(family=socket.AF_UNIX)
331	330	with pytest.raises(OSError): # noqa: PT011
...	...	@@ -339,7 +338,7 @@ class TestAgentInteraction:
339	338	],
340	339	)
341	340	def test_310_truncated_server_response(
342		- self, monkeypatch: Any, response: bytes
	341	+ self, monkeypatch: pytest.MonkeyPatch, response: bytes
343	342	) -> None:
344	343	client = ssh_agent.SSHAgentClient()
345	344	response_stream = io.BytesIO(response)
...	...	@@ -382,7 +381,7 @@ class TestAgentInteraction:
382	381	)
383	382	def test_320_list_keys_error_responses(
384	383	self,
385		- monkeypatch: Any,
	384	+ monkeypatch: pytest.MonkeyPatch,
386	385	response_code: _types.SSH_AGENT,
387	386	response: bytes \| bytearray,
388	387	exc_type: type[Exception],
...	...	@@ -419,7 +418,7 @@ class TestAgentInteraction:
419	418	)
420	419	def test_330_sign_error_responses(
421	420	self,
422		- monkeypatch: Any,
	421	+ monkeypatch: pytest.MonkeyPatch,
423	422	key: bytes \| bytearray,
424	423	check: bool,
425	424	response: tuple[_types.SSH_AGENT, bytes \| bytearray],

...	...	@@ -7,7 +7,6 @@
7	7	from __future__ import annotations
8	8
9	9	import math
10		-from typing import Any
11	10
12	11	import pytest
13	12
...	...	@@ -193,7 +192,10 @@ class TestVault:
193	192	],
194	193	)
195	194	def test_223_hash_length_expansion(
196		- self, monkeypatch: Any, service: str \| bytes, expected: bytes
	195	+ self,
	196	+ monkeypatch: pytest.MonkeyPatch,
	197	+ service: str \| bytes,
	198	+ expected: bytes,
197	199	) -> None:
198	200	v = Vault(phrase=self.phrase)
199	201	monkeypatch.setattr(
200	202