derivepassphrase.git

1) # SPDX-FileCopyrightText: 2024 Marco Ricci <software@the13thletter.info>

2) #
3) # SPDX-License-Identifier: MIT
4) 

5) from __future__ import annotations
6) 

7) import base64

8) import contextlib

9) import copy

10) import errno

11) import io

12) import json

13) import logging

14) import os

15) import shlex

16) import shutil

17) import socket

18) import textwrap

19) import warnings

20) from typing import TYPE_CHECKING

21) 

22) import click.testing

23) import hypothesis

24) import pytest

25) from hypothesis import stateful, strategies
26) from typing_extensions import Any, NamedTuple

27) 

28) import tests

29) from derivepassphrase import _types, cli, ssh_agent, vault

30) 
31) if TYPE_CHECKING:

32)     from collections.abc import Callable, Iterable, Iterator
33)     from typing import NoReturn

34) 

35) DUMMY_SERVICE = tests.DUMMY_SERVICE
36) DUMMY_PASSPHRASE = tests.DUMMY_PASSPHRASE
37) DUMMY_CONFIG_SETTINGS = tests.DUMMY_CONFIG_SETTINGS
38) DUMMY_RESULT_PASSPHRASE = tests.DUMMY_RESULT_PASSPHRASE
39) DUMMY_RESULT_KEY1 = tests.DUMMY_RESULT_KEY1
40) DUMMY_PHRASE_FROM_KEY1_RAW = tests.DUMMY_PHRASE_FROM_KEY1_RAW
41) DUMMY_PHRASE_FROM_KEY1 = tests.DUMMY_PHRASE_FROM_KEY1
42) 
43) DUMMY_KEY1 = tests.DUMMY_KEY1
44) DUMMY_KEY1_B64 = tests.DUMMY_KEY1_B64
45) DUMMY_KEY2 = tests.DUMMY_KEY2

46) DUMMY_KEY2_B64 = tests.DUMMY_KEY2_B64
47) DUMMY_KEY3 = tests.DUMMY_KEY3
48) DUMMY_KEY3_B64 = tests.DUMMY_KEY3_B64

49) 

50) TEST_CONFIGS = tests.TEST_CONFIGS
51) 

52) 
53) class IncompatibleConfiguration(NamedTuple):
54)     other_options: list[tuple[str, ...]]
55)     needs_service: bool | None

56)     input: str | None

57) 

58) 

59) class SingleConfiguration(NamedTuple):
60)     needs_service: bool | None

61)     input: str | None

62)     check_success: bool
63) 

64) 

65) class OptionCombination(NamedTuple):
66)     options: list[str]
67)     incompatible: bool
68)     needs_service: bool | None

69)     input: str | None

70)     check_success: bool
71) 

72) 

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

74)     ('--phrase',),
75)     ('--key',),
76)     ('--length', '20'),
77)     ('--repeat', '20'),
78)     ('--lower', '1'),
79)     ('--upper', '1'),
80)     ('--number', '1'),
81)     ('--space', '1'),
82)     ('--dash', '1'),
83)     ('--symbol', '1'),

84) ]
85) CONFIGURATION_OPTIONS: list[tuple[str, ...]] = [

86)     ('--notes',),
87)     ('--config',),
88)     ('--delete',),
89)     ('--delete-globals',),
90)     ('--clear',),

91) ]
92) CONFIGURATION_COMMANDS: list[tuple[str, ...]] = [

93)     ('--notes',),
94)     ('--delete',),
95)     ('--delete-globals',),
96)     ('--clear',),

97) ]

98) STORAGE_OPTIONS: list[tuple[str, ...]] = [('--export', '-'), ('--import', '-')]

99) INCOMPATIBLE: dict[tuple[str, ...], IncompatibleConfiguration] = {
100)     ('--phrase',): IncompatibleConfiguration(

101)         [('--key',), *CONFIGURATION_COMMANDS, *STORAGE_OPTIONS],

102)         True,
103)         DUMMY_PASSPHRASE,
104)     ),

105)     ('--key',): IncompatibleConfiguration(

106)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
107)     ),

108)     ('--length', '20'): IncompatibleConfiguration(

109)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
110)     ),

111)     ('--repeat', '20'): IncompatibleConfiguration(

112)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
113)     ),

114)     ('--lower', '1'): IncompatibleConfiguration(

115)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
116)     ),

117)     ('--upper', '1'): IncompatibleConfiguration(

118)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
119)     ),

120)     ('--number', '1'): IncompatibleConfiguration(

121)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
122)     ),

123)     ('--space', '1'): IncompatibleConfiguration(

124)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
125)     ),

126)     ('--dash', '1'): IncompatibleConfiguration(

127)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
128)     ),

129)     ('--symbol', '1'): IncompatibleConfiguration(

130)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
131)     ),

132)     ('--notes',): IncompatibleConfiguration(

133)         [
134)             ('--config',),
135)             ('--delete',),
136)             ('--delete-globals',),
137)             ('--clear',),
138)             *STORAGE_OPTIONS,
139)         ],
140)         True,
141)         None,
142)     ),

143)     ('--config', '-p'): IncompatibleConfiguration(

144)         [('--delete',), ('--delete-globals',), ('--clear',), *STORAGE_OPTIONS],
145)         None,
146)         DUMMY_PASSPHRASE,
147)     ),

148)     ('--delete',): IncompatibleConfiguration(

149)         [('--delete-globals',), ('--clear',), *STORAGE_OPTIONS], True, None
150)     ),

151)     ('--delete-globals',): IncompatibleConfiguration(

152)         [('--clear',), *STORAGE_OPTIONS], False, None
153)     ),

154)     ('--clear',): IncompatibleConfiguration(STORAGE_OPTIONS, False, None),
155)     ('--export', '-'): IncompatibleConfiguration(

156)         [('--import', '-')], False, None
157)     ),
158)     ('--import', '-'): IncompatibleConfiguration([], False, None),

159) }
160) SINGLES: dict[tuple[str, ...], SingleConfiguration] = {
161)     ('--phrase',): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
162)     ('--key',): SingleConfiguration(True, None, False),
163)     ('--length', '20'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
164)     ('--repeat', '20'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
165)     ('--lower', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
166)     ('--upper', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
167)     ('--number', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
168)     ('--space', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
169)     ('--dash', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
170)     ('--symbol', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
171)     ('--notes',): SingleConfiguration(True, None, False),
172)     ('--config', '-p'): SingleConfiguration(None, DUMMY_PASSPHRASE, False),
173)     ('--delete',): SingleConfiguration(True, None, False),
174)     ('--delete-globals',): SingleConfiguration(False, None, True),
175)     ('--clear',): SingleConfiguration(False, None, True),
176)     ('--export', '-'): SingleConfiguration(False, None, True),

177)     ('--import', '-'): SingleConfiguration(False, '{"services": {}}', True),

178) }
179) INTERESTING_OPTION_COMBINATIONS: list[OptionCombination] = []

180) config: IncompatibleConfiguration | SingleConfiguration

181) for opt, config in INCOMPATIBLE.items():
182)     for opt2 in config.other_options:
183)         INTERESTING_OPTION_COMBINATIONS.extend([

184)             OptionCombination(
185)                 options=list(opt + opt2),
186)                 incompatible=True,
187)                 needs_service=config.needs_service,
188)                 input=config.input,
189)                 check_success=False,
190)             ),
191)             OptionCombination(
192)                 options=list(opt2 + opt),
193)                 incompatible=True,
194)                 needs_service=config.needs_service,
195)                 input=config.input,
196)                 check_success=False,
197)             ),

198)         ])
199) for opt, config in SINGLES.items():
200)     INTERESTING_OPTION_COMBINATIONS.append(

201)         OptionCombination(
202)             options=list(opt),
203)             incompatible=False,
204)             needs_service=config.needs_service,
205)             input=config.input,
206)             check_success=config.check_success,
207)         )
208)     )

209) 
210) 

211) def is_warning_line(line: str) -> bool:
212)     """Return true if the line is a warning line."""
213)     return ' Warning: ' in line or ' Deprecation warning: ' in line
214) 
215) 
216) def is_harmless_config_import_warning(record: tuple[str, int, str]) -> bool:
217)     """Return true if the warning is harmless, during config import."""

218)     possible_warnings = [
219)         'Replacing invalid value ',
220)         'Removing ineffective setting ',
221)         (
222)             'Setting a global passphrase is ineffective '
223)             'because a key is also set.'
224)         ),
225)         (
226)             'Setting a service passphrase is ineffective '

227)             'because a key is also set:'

228)         ),
229)     ]

230)     return any(tests.warning_emitted(w, [record]) for w in possible_warnings)

231) 
232) 

233) def vault_config_exporter_shell_interpreter(  # noqa: C901
234)     script: str | Iterable[str],
235)     /,
236)     *,
237)     prog_name_list: list[str] | None = None,
238)     command: click.BaseCommand | None = None,
239)     runner: click.testing.CliRunner | None = None,
240) ) -> Iterator[click.testing.Result]:
241)     if isinstance(script, str):  # pragma: no cover
242)         script = script.splitlines(False)
243)     if prog_name_list is None:  # pragma: no cover
244)         prog_name_list = ['derivepassphrase', 'vault']
245)     if command is None:  # pragma: no cover
246)         command = cli.derivepassphrase_vault
247)     if runner is None:  # pragma: no cover
248)         runner = click.testing.CliRunner(mix_stderr=False)
249)     n = len(prog_name_list)
250)     it = iter(script)
251)     while True:
252)         try:
253)             raw_line = next(it)
254)         except StopIteration:
255)             break
256)         else:
257)             line = shlex.split(raw_line)
258)         input_buffer: list[str] = []
259)         if line[:n] != prog_name_list:
260)             continue
261)         line[:n] = []
262)         if line and line[-1] == '<<HERE':
263)             # naive HERE document support
264)             while True:
265)                 try:
266)                     raw_line = next(it)
267)                 except StopIteration as exc:  # pragma: no cover
268)                     msg = 'incomplete here document'
269)                     raise EOFError(msg) from exc
270)                 else:
271)                     if raw_line == 'HERE':
272)                         break
273)                     input_buffer.append(raw_line)
274)             line.pop()
275)         yield runner.invoke(
276)             command,
277)             line,
278)             catch_exceptions=False,
279)             input=(''.join(x + '\n' for x in input_buffer) or None),
280)         )
281) 
282) 

283) class TestAllCLI:
284)     @pytest.mark.parametrize(
285)         ['command', 'non_eager_arguments'],
286)         [
287)             ([], []),
288)             ([], ['export']),
289)             (['export'], []),
290)             (['export'], ['vault']),
291)             (['export', 'vault'], []),
292)             (['export', 'vault'], ['--format', 'this-format-doesnt-exist']),
293)             (['vault'], []),
294)             (['vault'], ['--export', './']),
295)         ]
296)     )
297)     @pytest.mark.parametrize('arguments', [['--help'], ['--version']])
298)     def test_200_eager_options(
299)         self,
300)         monkeypatch: pytest.MonkeyPatch,
301)         command: list[str],
302)         arguments: list[str],
303)         non_eager_arguments: list[str],
304)     ) -> None:
305)         runner = click.testing.CliRunner(mix_stderr=False)
306)         with tests.isolated_config(
307)             monkeypatch=monkeypatch,
308)             runner=runner,
309)         ):
310)             _result = runner.invoke(
311)                 cli.derivepassphrase,
312)                 [*command, *arguments, *non_eager_arguments],
313)                 catch_exceptions=False,
314)             )
315)             result = tests.ReadableResult.parse(_result)
316)         assert result.clean_exit(empty_stderr=True), 'expected clean exit'
317) 
318)     @pytest.mark.parametrize('no_color', [False, True])
319)     @pytest.mark.parametrize('force_color', [False, True])
320)     @pytest.mark.parametrize('isatty', [False, True])
321)     @pytest.mark.parametrize(
322)         ['command_line', 'input'],
323)         [
324)             (
325)                 ['vault', '--import', '-'],
326)                 '{"services": {"": {"length": 20}}}',
327)             ),
328)         ]
329)     )
330)     def test_201_no_color_force_color(
331)         self,
332)         monkeypatch: pytest.MonkeyPatch,
333)         no_color: bool,
334)         force_color: bool,
335)         isatty: bool,
336)         command_line: list[str],
337)         input: str | None,
338)     ) -> None:
339)         # Force color on if force_color.  Otherwise force color off if
340)         # no_color.  Otherwise set color if and only if we have a TTY.
341)         color = force_color or not no_color if isatty else force_color
342)         runner = click.testing.CliRunner(mix_stderr=False)
343)         with tests.isolated_config(
344)             monkeypatch=monkeypatch,
345)             runner=runner,
346)         ):
347)             if no_color:
348)                 monkeypatch.setenv('NO_COLOR', 'yes')
349)             if force_color:
350)                 monkeypatch.setenv('FORCE_COLOR', 'yes')
351)             _result = runner.invoke(
352)                 cli.derivepassphrase,
353)                 command_line,
354)                 input=input,
355)                 catch_exceptions=False,
356)                 color=isatty,
357)             )
358)             result = tests.ReadableResult.parse(_result)
359)         assert (
360)             not color
361)             or '\x1b[0m' in result.stderr
362)             or '\x1b[m' in result.stderr
363)         ), 'Expected color, but found no ANSI reset sequence'
364)         assert (
365)             color or '\x1b[' not in result.stderr
366)         ), 'Expected no color, but found an ANSI control sequence'
367) 
368) 

369) class TestCLI:

370)     def test_200_help_output(
371)         self,
372)         monkeypatch: pytest.MonkeyPatch,
373)     ) -> None:

374)         runner = click.testing.CliRunner(mix_stderr=False)

375)         with tests.isolated_config(
376)             monkeypatch=monkeypatch,
377)             runner=runner,
378)         ):

379)             _result = runner.invoke(

380)                 cli.derivepassphrase_vault,
381)                 ['--help'],
382)                 catch_exceptions=False,

383)             )

384)             result = tests.ReadableResult.parse(_result)
385)         assert result.clean_exit(

386)             empty_stderr=True, output='Passphrase generation:\n'

387)         ), 'expected clean exit, and option groups in help text'
388)         assert result.clean_exit(

389)             empty_stderr=True, output='Use $VISUAL or $EDITOR to configure'

390)         ), 'expected clean exit, and option group epilog in help text'

391) 

392)     def test_200a_version_output(
393)         self,
394)         monkeypatch: pytest.MonkeyPatch,
395)     ) -> None:
396)         runner = click.testing.CliRunner(mix_stderr=False)
397)         with tests.isolated_config(
398)             monkeypatch=monkeypatch,
399)             runner=runner,
400)         ):
401)             _result = runner.invoke(
402)                 cli.derivepassphrase_vault,
403)                 ['--version'],
404)                 catch_exceptions=False,
405)             )
406)             result = tests.ReadableResult.parse(_result)
407)         assert result.clean_exit(
408)             empty_stderr=True, output=cli.PROG_NAME
409)         ), 'expected clean exit, and program name in version text'
410)         assert result.clean_exit(
411)             empty_stderr=True, output=cli.__version__
412)         ), 'expected clean exit, and version in help text'
413) 

414)     @pytest.mark.parametrize(
415)         'charset_name', ['lower', 'upper', 'number', 'space', 'dash', 'symbol']
416)     )

417)     def test_201_disable_character_set(

418)         self, monkeypatch: pytest.MonkeyPatch, charset_name: str

419)     ) -> None:
420)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
421)         option = f'--{charset_name}'

422)         charset = vault.Vault._CHARSETS[charset_name].decode('ascii')

423)         runner = click.testing.CliRunner(mix_stderr=False)

424)         with tests.isolated_config(
425)             monkeypatch=monkeypatch,
426)             runner=runner,
427)         ):

428)             _result = runner.invoke(

429)                 cli.derivepassphrase_vault,

430)                 [option, '0', '-p', '--', DUMMY_SERVICE],

431)                 input=DUMMY_PASSPHRASE,
432)                 catch_exceptions=False,
433)             )

434)             result = tests.ReadableResult.parse(_result)
435)         assert result.clean_exit(empty_stderr=True), 'expected clean exit:'

436)         for c in charset:

437)             assert (
438)                 c not in result.output
439)             ), f'derived password contains forbidden character {c!r}'

440) 

441)     def test_202_disable_repetition(
442)         self, monkeypatch: pytest.MonkeyPatch
443)     ) -> None:

444)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
445)         runner = click.testing.CliRunner(mix_stderr=False)

446)         with tests.isolated_config(
447)             monkeypatch=monkeypatch,
448)             runner=runner,
449)         ):

450)             _result = runner.invoke(

451)                 cli.derivepassphrase_vault,

452)                 ['--repeat', '0', '-p', '--', DUMMY_SERVICE],

453)                 input=DUMMY_PASSPHRASE,
454)                 catch_exceptions=False,
455)             )

456)             result = tests.ReadableResult.parse(_result)
457)         assert result.clean_exit(
458)             empty_stderr=True
459)         ), 'expected clean exit and empty stderr'
460)         passphrase = result.output.rstrip('\r\n')

461)         for i in range(len(passphrase) - 1):

462)             assert passphrase[i : i + 1] != passphrase[i + 1 : i + 2], (

463)                 f'derived password contains repeated character '

464)                 f'at position {i}: {result.output!r}'

465)             )

466) 

467)     @pytest.mark.parametrize(
468)         'config',
469)         [
470)             pytest.param(
471)                 {
472)                     'global': {'key': DUMMY_KEY1_B64},
473)                     'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS},
474)                 },
475)                 id='global',
476)             ),
477)             pytest.param(
478)                 {

479)                     'global': {'phrase': DUMMY_PASSPHRASE.rstrip('\n')},

480)                     'services': {
481)                         DUMMY_SERVICE: {
482)                             'key': DUMMY_KEY1_B64,
483)                             **DUMMY_CONFIG_SETTINGS,
484)                         }
485)                     },
486)                 },
487)                 id='service',
488)             ),
489)         ],
490)     )

491)     def test_204a_key_from_config(

492)         self,

493)         monkeypatch: pytest.MonkeyPatch,

494)         config: _types.VaultConfig,

495)     ) -> None:
496)         runner = click.testing.CliRunner(mix_stderr=False)

497)         with tests.isolated_vault_config(

498)             monkeypatch=monkeypatch, runner=runner, vault_config=config

499)         ):
500)             monkeypatch.setattr(

501)                 vault.Vault, 'phrase_from_key', tests.phrase_from_key

502)             )

503)             _result = runner.invoke(

504)                 cli.derivepassphrase_vault,

505)                 ['--', DUMMY_SERVICE],

506)                 catch_exceptions=False,

507)             )

508)         result = tests.ReadableResult.parse(_result)
509)         assert result.clean_exit(
510)             empty_stderr=True
511)         ), 'expected clean exit and empty stderr'
512)         assert _result.stdout_bytes
513)         assert (
514)             _result.stdout_bytes.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
515)         ), 'known false output: phrase-based instead of key-based'
516)         assert (
517)             _result.stdout_bytes.rstrip(b'\n') == DUMMY_RESULT_KEY1
518)         ), 'expected known output'

519) 

520)     def test_204b_key_from_command_line(
521)         self, monkeypatch: pytest.MonkeyPatch
522)     ) -> None:

523)         runner = click.testing.CliRunner(mix_stderr=False)

524)         with tests.isolated_vault_config(

525)             monkeypatch=monkeypatch,
526)             runner=runner,

527)             vault_config={'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS}},

528)         ):
529)             monkeypatch.setattr(
530)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
531)             )
532)             monkeypatch.setattr(

533)                 vault.Vault, 'phrase_from_key', tests.phrase_from_key

534)             )

535)             _result = runner.invoke(

536)                 cli.derivepassphrase_vault,

537)                 ['-k', '--', DUMMY_SERVICE],

538)                 input='1\n',

539)                 catch_exceptions=False,
540)             )

541)         result = tests.ReadableResult.parse(_result)
542)         assert result.clean_exit(), 'expected clean exit'
543)         assert _result.stdout_bytes, 'expected program output'
544)         last_line = _result.stdout_bytes.splitlines(True)[-1]
545)         assert (
546)             last_line.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
547)         ), 'known false output: phrase-based instead of key-based'
548)         assert (
549)             last_line.rstrip(b'\n') == DUMMY_RESULT_KEY1
550)         ), 'expected known output'

551) 

552)     @pytest.mark.parametrize(
553)         'config',
554)         [
555)             pytest.param(
556)                 {
557)                     'global': {'key': DUMMY_KEY1_B64},
558)                     'services': {DUMMY_SERVICE: {}},
559)                 },
560)                 id='global_config',
561)             ),
562)             pytest.param(
563)                 {'services': {DUMMY_SERVICE: {'key': DUMMY_KEY2_B64}}},
564)                 id='service_config',
565)             ),
566)             pytest.param(
567)                 {
568)                     'global': {'key': DUMMY_KEY1_B64},
569)                     'services': {DUMMY_SERVICE: {'key': DUMMY_KEY2_B64}},
570)                 },
571)                 id='full_config',
572)             ),
573)         ],
574)     )
575)     @pytest.mark.parametrize('key_index', [1, 2, 3], ids=lambda i: f'index{i}')
576)     def test_204c_key_override_on_command_line(
577)         self,

578)         monkeypatch: pytest.MonkeyPatch,

579)         running_ssh_agent: tests.RunningSSHAgentInfo,

580)         config: dict[str, Any],
581)         key_index: int,
582)     ) -> None:

583)         with monkeypatch.context():

584)             monkeypatch.setenv('SSH_AUTH_SOCK', running_ssh_agent.socket)

585)             monkeypatch.setattr(
586)                 ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys

587)             )

588)             monkeypatch.setattr(ssh_agent.SSHAgentClient, 'sign', tests.sign)

589)             runner = click.testing.CliRunner(mix_stderr=False)
590)             with tests.isolated_vault_config(

591)                 monkeypatch=monkeypatch, runner=runner, vault_config=config

592)             ):
593)                 _result = runner.invoke(
594)                     cli.derivepassphrase_vault,

595)                     ['-k', '--', DUMMY_SERVICE],

596)                     input=f'{key_index}\n',
597)                 )

598)         result = tests.ReadableResult.parse(_result)
599)         assert result.clean_exit(), 'expected clean exit'
600)         assert result.output, 'expected program output'
601)         assert result.stderr, 'expected stderr'
602)         assert (
603)             'Error:' not in result.stderr
604)         ), 'expected no error messages on stderr'

605) 

606)     def test_205_service_phrase_if_key_in_global_config(

607)         self,

608)         monkeypatch: pytest.MonkeyPatch,

609)         running_ssh_agent: tests.RunningSSHAgentInfo,

610)     ) -> None:

611)         with monkeypatch.context():

612)             monkeypatch.setenv('SSH_AUTH_SOCK', running_ssh_agent.socket)

613)             monkeypatch.setattr(
614)                 ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys

615)             )

616)             monkeypatch.setattr(ssh_agent.SSHAgentClient, 'sign', tests.sign)
617)             runner = click.testing.CliRunner(mix_stderr=False)
618)             with tests.isolated_vault_config(
619)                 monkeypatch=monkeypatch,
620)                 runner=runner,

621)                 vault_config={

622)                     'global': {'key': DUMMY_KEY1_B64},
623)                     'services': {
624)                         DUMMY_SERVICE: {
625)                             'phrase': DUMMY_PASSPHRASE.rstrip('\n'),
626)                             **DUMMY_CONFIG_SETTINGS,
627)                         }
628)                     },
629)                 },
630)             ):
631)                 _result = runner.invoke(
632)                     cli.derivepassphrase_vault,

633)                     ['--', DUMMY_SERVICE],

634)                     catch_exceptions=False,
635)                 )

636)         result = tests.ReadableResult.parse(_result)
637)         assert result.clean_exit(), 'expected clean exit'
638)         assert _result.stdout_bytes, 'expected program output'
639)         last_line = _result.stdout_bytes.splitlines(True)[-1]
640)         assert (

641)             last_line.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
642)         ), 'known false output: phrase-based instead of key-based'

643)         assert (

644)             last_line.rstrip(b'\n') == DUMMY_RESULT_KEY1

645)         ), 'expected known output'

646) 

647)     @pytest.mark.parametrize(

648)         ['config', 'command_line'],

649)         [

650)             pytest.param(
651)                 {
652)                     'global': {'key': DUMMY_KEY1_B64},
653)                     'services': {},
654)                 },
655)                 ['--config', '-p'],
656)                 id='global',
657)             ),
658)             pytest.param(
659)                 {
660)                     'services': {
661)                         DUMMY_SERVICE: {
662)                             'key': DUMMY_KEY1_B64,
663)                             **DUMMY_CONFIG_SETTINGS,
664)                         },

665)                     },
666)                 },

667)                 ['--config', '-p', '--', DUMMY_SERVICE],
668)                 id='service',
669)             ),
670)             pytest.param(
671)                 {
672)                     'global': {'key': DUMMY_KEY1_B64},
673)                     'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()},
674)                 },
675)                 ['--config', '-p', '--', DUMMY_SERVICE],
676)                 id='service-over-global',
677)             ),

678)         ],
679)     )

680)     def test_206_setting_phrase_thus_overriding_key_in_config(

681)         self,
682)         monkeypatch: pytest.MonkeyPatch,

683)         running_ssh_agent: tests.RunningSSHAgentInfo,

684)         caplog: pytest.LogCaptureFixture,

685)         config: _types.VaultConfig,

686)         command_line: list[str],

687)     ) -> None:
688)         with monkeypatch.context():

689)             monkeypatch.setenv('SSH_AUTH_SOCK', running_ssh_agent.socket)

690)             monkeypatch.setattr(
691)                 ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys
692)             )
693)             monkeypatch.setattr(ssh_agent.SSHAgentClient, 'sign', tests.sign)
694)             runner = click.testing.CliRunner(mix_stderr=False)
695)             with tests.isolated_vault_config(
696)                 monkeypatch=monkeypatch,
697)                 runner=runner,

698)                 vault_config=config,

699)             ):
700)                 _result = runner.invoke(
701)                     cli.derivepassphrase_vault,

702)                     command_line,

703)                     input=DUMMY_PASSPHRASE,
704)                     catch_exceptions=False,
705)                 )
706)         result = tests.ReadableResult.parse(_result)
707)         assert result.clean_exit(), 'expected clean exit'
708)         assert not result.output.strip(), 'expected no program output'
709)         assert result.stderr, 'expected known error output'
710)         err_lines = result.stderr.splitlines(False)
711)         assert err_lines[0].startswith('Passphrase:')

712)         assert tests.warning_emitted(
713)             'Setting a service passphrase is ineffective ',
714)             caplog.record_tuples,

715)         ) or tests.warning_emitted(
716)             'Setting a global passphrase is ineffective ',
717)             caplog.record_tuples,

718)         ), 'expected known warning message'

719)         assert all(map(is_warning_line, result.stderr.splitlines(True)))
720)         assert all(
721)             map(is_harmless_config_import_warning, caplog.record_tuples)

722)         ), 'unexpected error output'
723) 

724)     @pytest.mark.parametrize(
725)         'option',
726)         [
727)             '--lower',
728)             '--upper',
729)             '--number',
730)             '--space',
731)             '--dash',
732)             '--symbol',
733)             '--repeat',
734)             '--length',
735)         ],
736)     )

737)     def test_210_invalid_argument_range(

738)         self, monkeypatch: pytest.MonkeyPatch, option: str

739)     ) -> None:

740)         runner = click.testing.CliRunner(mix_stderr=False)

741)         with tests.isolated_config(
742)             monkeypatch=monkeypatch,
743)             runner=runner,
744)         ):
745)             for value in '-42', 'invalid':

746)                 _result = runner.invoke(

747)                     cli.derivepassphrase_vault,

748)                     [option, value, '-p', '--', DUMMY_SERVICE],

749)                     input=DUMMY_PASSPHRASE,
750)                     catch_exceptions=False,
751)                 )

752)                 result = tests.ReadableResult.parse(_result)
753)                 assert result.error_exit(

754)                     error='Invalid value'

755)                 ), 'expected error exit and known error message'

756) 
757)     @pytest.mark.parametrize(
758)         ['options', 'service', 'input', 'check_success'],

759)         [
760)             (o.options, o.needs_service, o.input, o.check_success)
761)             for o in INTERESTING_OPTION_COMBINATIONS
762)             if not o.incompatible
763)         ],

764)     )
765)     def test_211_service_needed(

766)         self,

767)         monkeypatch: pytest.MonkeyPatch,

768)         options: list[str],
769)         service: bool | None,

770)         input: str | None,

771)         check_success: bool,

772)     ) -> None:
773)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
774)         runner = click.testing.CliRunner(mix_stderr=False)

775)         with tests.isolated_vault_config(

776)             monkeypatch=monkeypatch,
777)             runner=runner,

778)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

779)         ):

780)             _result = runner.invoke(

781)                 cli.derivepassphrase_vault,

782)                 options if service else [*options, '--', DUMMY_SERVICE],

783)                 input=input,
784)                 catch_exceptions=False,
785)             )

786)             result = tests.ReadableResult.parse(_result)

787)             if service is not None:

788)                 err_msg = (

789)                     ' requires a SERVICE'

790)                     if service

791)                     else ' does not take a SERVICE argument'

792)                 )

793)                 assert result.error_exit(
794)                     error=err_msg
795)                 ), 'expected error exit and known error message'

796)             else:

797)                 assert result.clean_exit(
798)                     empty_stderr=True
799)                 ), 'expected clean exit'

800)         if check_success:

801)             with tests.isolated_vault_config(

802)                 monkeypatch=monkeypatch,
803)                 runner=runner,

804)                 vault_config={'global': {'phrase': 'abc'}, 'services': {}},

805)             ):
806)                 monkeypatch.setattr(
807)                     cli, '_prompt_for_passphrase', tests.auto_prompt
808)                 )

809)                 _result = runner.invoke(

810)                     cli.derivepassphrase_vault,

811)                     [*options, '--', DUMMY_SERVICE] if service else options,

812)                     input=input,
813)                     catch_exceptions=False,

814)                 )

815)                 result = tests.ReadableResult.parse(_result)
816)             assert result.clean_exit(empty_stderr=True), 'expected clean exit'

817) 

818)     def test_211a_empty_service_name_causes_warning(
819)         self,
820)         monkeypatch: pytest.MonkeyPatch,

821)         caplog: pytest.LogCaptureFixture,

822)     ) -> None:

823)         def is_expected_warning(record: tuple[str, int, str]) -> bool:
824)             return is_harmless_config_import_warning(
825)                 record
826)             ) or tests.warning_emitted(
827)                 'An empty SERVICE is not supported by vault(1)', [record]

828)             )
829) 
830)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
831)         runner = click.testing.CliRunner(mix_stderr=False)
832)         with tests.isolated_vault_config(
833)             monkeypatch=monkeypatch,
834)             runner=runner,

835)             vault_config={'services': {}},

836)         ):
837)             _result = runner.invoke(
838)                 cli.derivepassphrase_vault,
839)                 ['--config', '--length=30', '--', ''],
840)                 catch_exceptions=False,
841)             )
842)             result = tests.ReadableResult.parse(_result)
843)             assert result.clean_exit(empty_stderr=False), 'expected clean exit'
844)             assert result.stderr is not None, 'expected known error output'
845)             assert all(

846)                 map(is_expected_warning, caplog.record_tuples)

847)             ), 'expected known error output'
848)             assert cli._load_config() == {
849)                 'global': {'length': 30},
850)                 'services': {},
851)             }, 'requested configuration change was not applied'

852)             caplog.clear()

853)             _result = runner.invoke(
854)                 cli.derivepassphrase_vault,
855)                 ['--import', '-'],
856)                 input=json.dumps({'services': {'': {'length': 40}}}),
857)                 catch_exceptions=False,
858)             )
859)             result = tests.ReadableResult.parse(_result)
860)             assert result.clean_exit(empty_stderr=False), 'expected clean exit'
861)             assert result.stderr is not None, 'expected known error output'
862)             assert all(

863)                 map(is_expected_warning, caplog.record_tuples)

864)             ), 'expected known error output'
865)             assert cli._load_config() == {
866)                 'global': {'length': 30},
867)                 'services': {'': {'length': 40}},
868)             }, 'requested configuration change was not applied'
869) 

870)     @pytest.mark.parametrize(

871)         ['options', 'service'],

872)         [
873)             (o.options, o.needs_service)
874)             for o in INTERESTING_OPTION_COMBINATIONS
875)             if o.incompatible
876)         ],

877)     )

878)     def test_212_incompatible_options(

879)         self,

880)         monkeypatch: pytest.MonkeyPatch,

881)         options: list[str],
882)         service: bool | None,

883)     ) -> None:
884)         runner = click.testing.CliRunner(mix_stderr=False)

885)         with tests.isolated_config(
886)             monkeypatch=monkeypatch,
887)             runner=runner,
888)         ):

889)             _result = runner.invoke(

890)                 cli.derivepassphrase_vault,

891)                 [*options, '--', DUMMY_SERVICE] if service else options,

892)                 input=DUMMY_PASSPHRASE,
893)                 catch_exceptions=False,
894)             )

895)         result = tests.ReadableResult.parse(_result)
896)         assert result.error_exit(
897)             error='mutually exclusive with '
898)         ), 'expected error exit and known error message'

899) 

900)     @pytest.mark.parametrize(
901)         'config',
902)         [
903)             conf.config

904)             for conf in TEST_CONFIGS

905)             if tests.is_valid_test_config(conf)
906)         ],
907)     )
908)     def test_213_import_config_success(
909)         self,
910)         monkeypatch: pytest.MonkeyPatch,

911)         caplog: pytest.LogCaptureFixture,

912)         config: Any,
913)     ) -> None:
914)         runner = click.testing.CliRunner(mix_stderr=False)
915)         with tests.isolated_vault_config(
916)             monkeypatch=monkeypatch,
917)             runner=runner,

918)             vault_config={'services': {}},

919)         ):
920)             _result = runner.invoke(
921)                 cli.derivepassphrase_vault,
922)                 ['--import', '-'],
923)                 input=json.dumps(config),
924)                 catch_exceptions=False,
925)             )
926)             with open(
927)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
928)             ) as infile:
929)                 config2 = json.load(infile)
930)         result = tests.ReadableResult.parse(_result)

931)         assert result.clean_exit(empty_stderr=False), 'expected clean exit'

932)         assert config2 == config, 'config not imported correctly'

933)         assert not result.stderr or all(  # pragma: no branch

934)             map(is_harmless_config_import_warning, caplog.record_tuples)

935)         ), 'unexpected error output'

936) 

937)     @tests.hypothesis_settings_coverage_compatible_with_caplog

938)     @hypothesis.given(
939)         conf=tests.smudged_vault_test_config(
940)             strategies.sampled_from(TEST_CONFIGS).filter(
941)                 tests.is_valid_test_config
942)             )
943)         )
944)     )
945)     def test_213a_import_config_success(
946)         self,

947)         caplog: pytest.LogCaptureFixture,

948)         conf: tests.VaultTestConfig,
949)     ) -> None:
950)         config = conf.config
951)         config2 = copy.deepcopy(config)
952)         _types.clean_up_falsy_vault_config_values(config2)
953)         runner = click.testing.CliRunner(mix_stderr=False)
954)         with tests.isolated_vault_config(
955)             monkeypatch=pytest.MonkeyPatch(),
956)             runner=runner,

957)             vault_config={'services': {}},

958)         ):
959)             _result = runner.invoke(
960)                 cli.derivepassphrase_vault,
961)                 ['--import', '-'],
962)                 input=json.dumps(config),
963)                 catch_exceptions=False,
964)             )
965)             with open(
966)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
967)             ) as infile:
968)                 config3 = json.load(infile)
969)         result = tests.ReadableResult.parse(_result)

970)         assert result.clean_exit(empty_stderr=False), 'expected clean exit'

971)         assert config3 == config2, 'config not imported correctly'

972)         assert not result.stderr or all(

973)             map(is_harmless_config_import_warning, caplog.record_tuples)

974)         ), 'unexpected error output'

975) 
976)     def test_213b_import_bad_config_not_vault_config(

977)         self,

978)         monkeypatch: pytest.MonkeyPatch,

979)     ) -> None:
980)         runner = click.testing.CliRunner(mix_stderr=False)

981)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

982)             _result = runner.invoke(

983)                 cli.derivepassphrase_vault,

984)                 ['--import', '-'],

985)                 input='null',

986)                 catch_exceptions=False,

987)             )

988)         result = tests.ReadableResult.parse(_result)
989)         assert result.error_exit(
990)             error='Invalid vault config'
991)         ), 'expected error exit and known error message'

992) 

993)     def test_213c_import_bad_config_not_json_data(

994)         self,

995)         monkeypatch: pytest.MonkeyPatch,

996)     ) -> None:
997)         runner = click.testing.CliRunner(mix_stderr=False)

998)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

999)             _result = runner.invoke(

1000)                 cli.derivepassphrase_vault,

1001)                 ['--import', '-'],

1002)                 input='This string is not valid JSON.',

1003)                 catch_exceptions=False,

1004)             )

1005)         result = tests.ReadableResult.parse(_result)
1006)         assert result.error_exit(
1007)             error='cannot decode JSON'
1008)         ), 'expected error exit and known error message'

1009) 

1010)     def test_213d_import_bad_config_not_a_file(

1011)         self,

1012)         monkeypatch: pytest.MonkeyPatch,

1013)     ) -> None:
1014)         runner = click.testing.CliRunner(mix_stderr=False)

1015)         # `isolated_vault_config` validates the configuration.  So, to
1016)         # pass an actual broken configuration, we must open the
1017)         # configuration file ourselves afterwards, inside the context.
1018)         # We also might as well use `isolated_config` instead.
1019)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

1020)             with open(

1021)                 cli._config_filename(subsystem='vault'), 'w', encoding='UTF-8'

1022)             ) as outfile:

1023)                 print('This string is not valid JSON.', file=outfile)

1024)             dname = cli._config_filename(subsystem=None)

1025)             _result = runner.invoke(

1026)                 cli.derivepassphrase_vault,

1027)                 ['--import', os.fsdecode(dname)],

1028)                 catch_exceptions=False,

1029)             )

1030)         result = tests.ReadableResult.parse(_result)
1031)         assert result.error_exit(
1032)             error=os.strerror(errno.EISDIR)
1033)         ), 'expected error exit and known error message'

1034) 

1035)     @pytest.mark.parametrize(
1036)         'export_options',
1037)         [
1038)             [],
1039)             ['--export-as=sh'],
1040)         ],
1041)     )

1042)     def test_214_export_settings_no_stored_settings(

1043)         self,

1044)         monkeypatch: pytest.MonkeyPatch,

1045)         export_options: list[str],

1046)     ) -> None:
1047)         runner = click.testing.CliRunner(mix_stderr=False)

1048)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

1049)             with contextlib.suppress(FileNotFoundError):

1050)                 os.remove(cli._config_filename(subsystem='vault'))

1051)             _result = runner.invoke(

1052)                 # Test parent context navigation by not calling
1053)                 # `cli.derivepassphrase_vault` directly.  Used e.g. in
1054)                 # the `--export-as=sh` section to autoconstruct the
1055)                 # program name correctly.
1056)                 cli.derivepassphrase,
1057)                 ['vault', '--export', '-', *export_options],

1058)                 catch_exceptions=False,

1059)             )

1060)         result = tests.ReadableResult.parse(_result)
1061)         assert result.clean_exit(empty_stderr=True), 'expected clean exit'

1062) 

1063)     @pytest.mark.parametrize(
1064)         'export_options',
1065)         [
1066)             [],
1067)             ['--export-as=sh'],
1068)         ],
1069)     )

1070)     def test_214a_export_settings_bad_stored_config(

1071)         self,

1072)         monkeypatch: pytest.MonkeyPatch,

1073)         export_options: list[str],

1074)     ) -> None:
1075)         runner = click.testing.CliRunner(mix_stderr=False)

1076)         with tests.isolated_vault_config(

1077)             monkeypatch=monkeypatch, runner=runner, vault_config={}

1078)         ):

1079)             _result = runner.invoke(

1080)                 cli.derivepassphrase_vault,

1081)                 ['--export', '-', *export_options],

1082)                 input='null',

1083)                 catch_exceptions=False,

1084)             )

1085)         result = tests.ReadableResult.parse(_result)
1086)         assert result.error_exit(

1087)             error='Cannot load vault settings:'

1088)         ), 'expected error exit and known error message'

1089) 

1090)     @pytest.mark.parametrize(
1091)         'export_options',
1092)         [
1093)             [],
1094)             ['--export-as=sh'],
1095)         ],
1096)     )

1097)     def test_214b_export_settings_not_a_file(

1098)         self,

1099)         monkeypatch: pytest.MonkeyPatch,

1100)         export_options: list[str],

1101)     ) -> None:
1102)         runner = click.testing.CliRunner(mix_stderr=False)

1103)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

1104)             with contextlib.suppress(FileNotFoundError):

1105)                 os.remove(cli._config_filename(subsystem='vault'))
1106)             os.makedirs(cli._config_filename(subsystem='vault'))

1107)             _result = runner.invoke(

1108)                 cli.derivepassphrase_vault,

1109)                 ['--export', '-', *export_options],

1110)                 input='null',

1111)                 catch_exceptions=False,

1112)             )

1113)         result = tests.ReadableResult.parse(_result)
1114)         assert result.error_exit(

1115)             error='Cannot load vault settings:'

1116)         ), 'expected error exit and known error message'

1117) 

1118)     @pytest.mark.parametrize(
1119)         'export_options',
1120)         [
1121)             [],
1122)             ['--export-as=sh'],
1123)         ],
1124)     )

1125)     def test_214c_export_settings_target_not_a_file(

1126)         self,

1127)         monkeypatch: pytest.MonkeyPatch,

1128)         export_options: list[str],

1129)     ) -> None:
1130)         runner = click.testing.CliRunner(mix_stderr=False)

1131)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

1132)             dname = cli._config_filename(subsystem=None)

1133)             _result = runner.invoke(

1134)                 cli.derivepassphrase_vault,

1135)                 ['--export', os.fsdecode(dname), *export_options],

1136)                 input='null',

1137)                 catch_exceptions=False,

1138)             )

1139)         result = tests.ReadableResult.parse(_result)
1140)         assert result.error_exit(

1141)             error='Cannot export vault settings:'

1142)         ), 'expected error exit and known error message'

1143) 

1144)     @pytest.mark.parametrize(
1145)         'export_options',
1146)         [
1147)             [],
1148)             ['--export-as=sh'],
1149)         ],
1150)     )

1151)     def test_214d_export_settings_settings_directory_not_a_directory(
1152)         self,

1153)         monkeypatch: pytest.MonkeyPatch,

1154)         export_options: list[str],

1155)     ) -> None:
1156)         runner = click.testing.CliRunner(mix_stderr=False)

1157)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

1158)             with contextlib.suppress(FileNotFoundError):
1159)                 shutil.rmtree('.derivepassphrase')
1160)             with open('.derivepassphrase', 'w', encoding='UTF-8') as outfile:
1161)                 print('Obstruction!!', file=outfile)

1162)             _result = runner.invoke(

1163)                 cli.derivepassphrase_vault,

1164)                 ['--export', '-', *export_options],

1165)                 input='null',

1166)                 catch_exceptions=False,
1167)             )

1168)         result = tests.ReadableResult.parse(_result)
1169)         assert result.error_exit(

1170)             error='Cannot load vault settings:'

1171)         ) or result.error_exit(

1172)             error='Cannot load user config:'

1173)         ), 'expected error exit and known error message'

1174) 

1175)     def test_220_edit_notes_successfully(
1176)         self, monkeypatch: pytest.MonkeyPatch
1177)     ) -> None:

1178)         edit_result = """

1179) 
1180) # - - - - - >8 - - - - - >8 - - - - - >8 - - - - - >8 - - - - -
1181) contents go here

1182) """

1183)         runner = click.testing.CliRunner(mix_stderr=False)

1184)         with tests.isolated_vault_config(

1185)             monkeypatch=monkeypatch,
1186)             runner=runner,

1187)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1188)         ):
1189)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: edit_result)  # noqa: ARG005

1190)             _result = runner.invoke(

1191)                 cli.derivepassphrase_vault,

1192)                 ['--notes', '--', 'sv'],

1193)                 catch_exceptions=False,

1194)             )

1195)             result = tests.ReadableResult.parse(_result)
1196)             assert result.clean_exit(empty_stderr=True), 'expected clean exit'

1197)             with open(
1198)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
1199)             ) as infile:

1200)                 config = json.load(infile)

1201)             assert config == {
1202)                 'global': {'phrase': 'abc'},
1203)                 'services': {'sv': {'notes': 'contents go here'}},
1204)             }

1205) 

1206)     def test_221_edit_notes_noop(
1207)         self, monkeypatch: pytest.MonkeyPatch
1208)     ) -> None:

1209)         runner = click.testing.CliRunner(mix_stderr=False)

1210)         with tests.isolated_vault_config(

1211)             monkeypatch=monkeypatch,
1212)             runner=runner,

1213)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1214)         ):
1215)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: None)  # noqa: ARG005

1216)             _result = runner.invoke(

1217)                 cli.derivepassphrase_vault,

1218)                 ['--notes', '--', 'sv'],

1219)                 catch_exceptions=False,

1220)             )

1221)             result = tests.ReadableResult.parse(_result)
1222)             assert result.clean_exit(empty_stderr=True), 'expected clean exit'

1223)             with open(
1224)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
1225)             ) as infile:

1226)                 config = json.load(infile)
1227)             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
1228) 

1229)     def test_222_edit_notes_marker_removed(
1230)         self, monkeypatch: pytest.MonkeyPatch
1231)     ) -> None:

1232)         runner = click.testing.CliRunner(mix_stderr=False)

1233)         with tests.isolated_vault_config(

1234)             monkeypatch=monkeypatch,
1235)             runner=runner,

1236)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1237)         ):
1238)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: 'long\ntext')  # noqa: ARG005

1239)             _result = runner.invoke(

1240)                 cli.derivepassphrase_vault,

1241)                 ['--notes', '--', 'sv'],

1242)                 catch_exceptions=False,

1243)             )

1244)             result = tests.ReadableResult.parse(_result)
1245)             assert result.clean_exit(empty_stderr=True), 'expected clean exit'

1246)             with open(
1247)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
1248)             ) as infile:

1249)                 config = json.load(infile)

1250)             assert config == {
1251)                 'global': {'phrase': 'abc'},
1252)                 'services': {'sv': {'notes': 'long\ntext'}},
1253)             }

1254) 

1255)     def test_223_edit_notes_abort(
1256)         self, monkeypatch: pytest.MonkeyPatch
1257)     ) -> None:

1258)         runner = click.testing.CliRunner(mix_stderr=False)

1259)         with tests.isolated_vault_config(

1260)             monkeypatch=monkeypatch,
1261)             runner=runner,

1262)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1263)         ):
1264)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: '\n\n')  # noqa: ARG005

1265)             _result = runner.invoke(

1266)                 cli.derivepassphrase_vault,

1267)                 ['--notes', '--', 'sv'],

1268)                 catch_exceptions=False,

1269)             )

1270)             result = tests.ReadableResult.parse(_result)
1271)             assert result.error_exit(

1272)                 error='the user aborted the request'

1273)             ), 'expected known error message'

1274)             with open(
1275)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
1276)             ) as infile:

1277)                 config = json.load(infile)
1278)             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
1279) 

1280)     @pytest.mark.parametrize(
1281)         ['command_line', 'input', 'result_config'],
1282)         [
1283)             (
1284)                 ['--phrase'],

1285)                 'my passphrase\n',

1286)                 {'global': {'phrase': 'my passphrase'}, 'services': {}},
1287)             ),
1288)             (
1289)                 ['--key'],

1290)                 '1\n',

1291)                 {
1292)                     'global': {'key': DUMMY_KEY1_B64, 'phrase': 'abc'},
1293)                     'services': {},
1294)                 },

1295)             ),
1296)             (

1297)                 ['--phrase', '--', 'sv'],

1298)                 'my passphrase\n',

1299)                 {
1300)                     'global': {'phrase': 'abc'},
1301)                     'services': {'sv': {'phrase': 'my passphrase'}},
1302)                 },
1303)             ),
1304)             (

1305)                 ['--key', '--', 'sv'],

1306)                 '1\n',

1307)                 {
1308)                     'global': {'phrase': 'abc'},
1309)                     'services': {'sv': {'key': DUMMY_KEY1_B64}},
1310)                 },
1311)             ),
1312)             (

1313)                 ['--key', '--length', '15', '--', 'sv'],

1314)                 '1\n',

1315)                 {
1316)                     'global': {'phrase': 'abc'},
1317)                     'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
1318)                 },
1319)             ),
1320)         ],
1321)     )

1322)     def test_224_store_config_good(

1323)         self,

1324)         monkeypatch: pytest.MonkeyPatch,

1325)         command_line: list[str],

1326)         input: str,

1327)         result_config: Any,
1328)     ) -> None:
1329)         runner = click.testing.CliRunner(mix_stderr=False)

1330)         with tests.isolated_vault_config(

1331)             monkeypatch=monkeypatch,
1332)             runner=runner,

1333)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1334)         ):
1335)             monkeypatch.setattr(
1336)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
1337)             )

1338)             _result = runner.invoke(

1339)                 cli.derivepassphrase_vault,

1340)                 ['--config', *command_line],
1341)                 catch_exceptions=False,
1342)                 input=input,
1343)             )

1344)             result = tests.ReadableResult.parse(_result)
1345)             assert result.clean_exit(), 'expected clean exit'

1346)             with open(
1347)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
1348)             ) as infile:

1349)                 config = json.load(infile)

1350)             assert (
1351)                 config == result_config
1352)             ), 'stored config does not match expectation'

1353) 

1354)     @pytest.mark.parametrize(
1355)         ['command_line', 'input', 'err_text'],
1356)         [

1357)             (
1358)                 [],
1359)                 '',
1360)                 'Cannot update global settings without any given settings',
1361)             ),

1362)             (

1363)                 ['--', 'sv'],

1364)                 '',

1365)                 'Cannot update service settings without any given settings',

1366)             ),

1367)             (['--phrase', '--', 'sv'], '', 'No passphrase was given'),
1368)             (['--key'], '', 'No SSH key was selected'),

1369)         ],
1370)     )

1371)     def test_225_store_config_fail(

1372)         self,

1373)         monkeypatch: pytest.MonkeyPatch,

1374)         command_line: list[str],

1375)         input: str,
1376)         err_text: str,

1377)     ) -> None:
1378)         runner = click.testing.CliRunner(mix_stderr=False)

1379)         with tests.isolated_vault_config(

1380)             monkeypatch=monkeypatch,
1381)             runner=runner,

1382)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1383)         ):
1384)             monkeypatch.setattr(
1385)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
1386)             )

1387)             _result = runner.invoke(

1388)                 cli.derivepassphrase_vault,

1389)                 ['--config', *command_line],
1390)                 catch_exceptions=False,
1391)                 input=input,
1392)             )

1393)         result = tests.ReadableResult.parse(_result)
1394)         assert result.error_exit(
1395)             error=err_text
1396)         ), 'expected error exit and known error message'

1397) 
1398)     def test_225a_store_config_fail_manual_no_ssh_key_selection(

1399)         self,

1400)         monkeypatch: pytest.MonkeyPatch,

1401)     ) -> None:
1402)         runner = click.testing.CliRunner(mix_stderr=False)

1403)         with tests.isolated_vault_config(

1404)             monkeypatch=monkeypatch,
1405)             runner=runner,

1406)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1407)         ):

1408)             custom_error = 'custom error message'

1409) 

1410)             def raiser(*_args: Any, **_kwargs: Any) -> None:

1411)                 raise RuntimeError(custom_error)

1412) 

1413)             monkeypatch.setattr(cli, '_select_ssh_key', raiser)

1414)             _result = runner.invoke(

1415)                 cli.derivepassphrase_vault,

1416)                 ['--key', '--config'],
1417)                 catch_exceptions=False,
1418)             )

1419)         result = tests.ReadableResult.parse(_result)
1420)         assert result.error_exit(
1421)             error=custom_error
1422)         ), 'expected error exit and known error message'

1423) 

1424)     def test_225b_store_config_fail_manual_no_ssh_agent(
1425)         self,

1426)         monkeypatch: pytest.MonkeyPatch,

1427)         skip_if_no_af_unix_support: None,

1428)     ) -> None:

1429)         del skip_if_no_af_unix_support

1430)         runner = click.testing.CliRunner(mix_stderr=False)

1431)         with tests.isolated_vault_config(

1432)             monkeypatch=monkeypatch,
1433)             runner=runner,

1434)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1435)         ):
1436)             monkeypatch.delenv('SSH_AUTH_SOCK', raising=False)

1437)             _result = runner.invoke(

1438)                 cli.derivepassphrase_vault,

1439)                 ['--key', '--config'],
1440)                 catch_exceptions=False,
1441)             )

1442)         result = tests.ReadableResult.parse(_result)
1443)         assert result.error_exit(

1444)             error='Cannot find any running SSH agent'

1445)         ), 'expected error exit and known error message'

1446) 
1447)     def test_225c_store_config_fail_manual_bad_ssh_agent_connection(
1448)         self,

1449)         monkeypatch: pytest.MonkeyPatch,

1450)     ) -> None:
1451)         runner = click.testing.CliRunner(mix_stderr=False)

1452)         with tests.isolated_vault_config(

1453)             monkeypatch=monkeypatch,
1454)             runner=runner,

1455)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1456)         ):
1457)             monkeypatch.setenv('SSH_AUTH_SOCK', os.getcwd())

1458)             _result = runner.invoke(

1459)                 cli.derivepassphrase_vault,

1460)                 ['--key', '--config'],
1461)                 catch_exceptions=False,
1462)             )

1463)         result = tests.ReadableResult.parse(_result)
1464)         assert result.error_exit(

1465)             error='Cannot connect to the SSH agent'

1466)         ), 'expected error exit and known error message'

1467) 
1468)     @pytest.mark.parametrize('try_race_free_implementation', [True, False])
1469)     def test_225d_store_config_fail_manual_read_only_file(
1470)         self,

1471)         monkeypatch: pytest.MonkeyPatch,

1472)         try_race_free_implementation: bool,
1473)     ) -> None:
1474)         runner = click.testing.CliRunner(mix_stderr=False)

1475)         with tests.isolated_vault_config(

1476)             monkeypatch=monkeypatch,
1477)             runner=runner,

1478)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1479)         ):
1480)             tests.make_file_readonly(

1481)                 cli._config_filename(subsystem='vault'),

1482)                 try_race_free_implementation=try_race_free_implementation,
1483)             )

1484)             _result = runner.invoke(

1485)                 cli.derivepassphrase_vault,

1486)                 ['--config', '--length=15', '--', DUMMY_SERVICE],

1487)                 catch_exceptions=False,
1488)             )

1489)         result = tests.ReadableResult.parse(_result)
1490)         assert result.error_exit(

1491)             error='Cannot store vault settings:'

1492)         ), 'expected error exit and known error message'

1493) 
1494)     def test_225e_store_config_fail_manual_custom_error(
1495)         self,

1496)         monkeypatch: pytest.MonkeyPatch,

1497)     ) -> None:
1498)         runner = click.testing.CliRunner(mix_stderr=False)

1499)         with tests.isolated_vault_config(

1500)             monkeypatch=monkeypatch,
1501)             runner=runner,

1502)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

1503)         ):
1504)             custom_error = 'custom error message'
1505) 
1506)             def raiser(config: Any) -> None:
1507)                 del config
1508)                 raise RuntimeError(custom_error)
1509) 
1510)             monkeypatch.setattr(cli, '_save_config', raiser)

1511)             _result = runner.invoke(

1512)                 cli.derivepassphrase_vault,

1513)                 ['--config', '--length=15', '--', DUMMY_SERVICE],

1514)                 catch_exceptions=False,
1515)             )

1516)         result = tests.ReadableResult.parse(_result)
1517)         assert result.error_exit(
1518)             error=custom_error
1519)         ), 'expected error exit and known error message'

1520) 

1521)     def test_225f_store_config_fail_unset_and_set_same_settings(
1522)         self,
1523)         monkeypatch: pytest.MonkeyPatch,
1524)     ) -> None:
1525)         runner = click.testing.CliRunner(mix_stderr=False)
1526)         with tests.isolated_vault_config(
1527)             monkeypatch=monkeypatch,
1528)             runner=runner,
1529)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},
1530)         ):
1531)             _result = runner.invoke(
1532)                 cli.derivepassphrase_vault,
1533)                 [
1534)                     '--config',
1535)                     '--unset=length',
1536)                     '--length=15',
1537)                     '--',
1538)                     DUMMY_SERVICE,
1539)                 ],
1540)                 catch_exceptions=False,
1541)             )
1542)         result = tests.ReadableResult.parse(_result)
1543)         assert result.error_exit(
1544)             error='Attempted to unset and set --length at the same time.'
1545)         ), 'expected error exit and known error message'
1546) 

1547)     def test_225g_store_config_fail_manual_ssh_agent_no_keys_loaded(
1548)         self,
1549)         monkeypatch: pytest.MonkeyPatch,
1550)         running_ssh_agent: tests.RunningSSHAgentInfo,
1551)     ) -> None:
1552)         del running_ssh_agent
1553)         runner = click.testing.CliRunner(mix_stderr=False)
1554)         with tests.isolated_vault_config(
1555)             monkeypatch=monkeypatch,
1556)             runner=runner,
1557)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},
1558)         ):
1559)             def func(
1560)                 *_args: Any,
1561)                 **_kwargs: Any,
1562)             ) -> list[_types.KeyCommentPair]:
1563)                 return []
1564) 
1565)             monkeypatch.setattr(ssh_agent.SSHAgentClient, 'list_keys', func)
1566)             _result = runner.invoke(
1567)                 cli.derivepassphrase_vault,
1568)                 ['--key', '--config'],
1569)                 catch_exceptions=False,
1570)             )
1571)         result = tests.ReadableResult.parse(_result)
1572)         assert result.error_exit(
1573)             error='no keys suitable'
1574)         ), 'expected error exit and known error message'
1575) 
1576)     def test_225h_store_config_fail_manual_ssh_agent_runtime_error(
1577)         self,
1578)         monkeypatch: pytest.MonkeyPatch,
1579)         running_ssh_agent: tests.RunningSSHAgentInfo,
1580)     ) -> None:
1581)         del running_ssh_agent
1582)         runner = click.testing.CliRunner(mix_stderr=False)
1583)         with tests.isolated_vault_config(
1584)             monkeypatch=monkeypatch,
1585)             runner=runner,
1586)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},
1587)         ):
1588)             def raiser(*_args: Any, **_kwargs: Any) -> None:
1589)                 raise ssh_agent.TrailingDataError()
1590) 
1591)             monkeypatch.setattr(ssh_agent.SSHAgentClient, 'list_keys', raiser)
1592)             _result = runner.invoke(
1593)                 cli.derivepassphrase_vault,
1594)                 ['--key', '--config'],
1595)                 catch_exceptions=False,
1596)             )
1597)         result = tests.ReadableResult.parse(_result)
1598)         assert result.error_exit(
1599)             error='violates the communications protocol.'
1600)         ), 'expected error exit and known error message'
1601) 
1602)     def test_225i_store_config_fail_manual_ssh_agent_refuses(
1603)         self,
1604)         monkeypatch: pytest.MonkeyPatch,
1605)         running_ssh_agent: tests.RunningSSHAgentInfo,
1606)     ) -> None:
1607)         del running_ssh_agent
1608)         runner = click.testing.CliRunner(mix_stderr=False)
1609)         with tests.isolated_vault_config(
1610)             monkeypatch=monkeypatch,
1611)             runner=runner,
1612)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},
1613)         ):
1614)             def func(*_args: Any, **_kwargs: Any) -> NoReturn:
1615)                 raise ssh_agent.SSHAgentFailedError(
1616)                     _types.SSH_AGENT.FAILURE, b''
1617)                 )
1618) 
1619)             monkeypatch.setattr(ssh_agent.SSHAgentClient, 'list_keys', func)
1620)             _result = runner.invoke(
1621)                 cli.derivepassphrase_vault,
1622)                 ['--key', '--config'],
1623)                 catch_exceptions=False,
1624)             )
1625)         result = tests.ReadableResult.parse(_result)
1626)         assert result.error_exit(
1627)             error='refused to'
1628)         ), 'expected error exit and known error message'
1629) 

1630)     def test_226_no_arguments(self, monkeypatch: pytest.MonkeyPatch) -> None:

1631)         runner = click.testing.CliRunner(mix_stderr=False)

1632)         with tests.isolated_config(
1633)             monkeypatch=monkeypatch,
1634)             runner=runner,
1635)         ):

1636)             _result = runner.invoke(

1637)                 cli.derivepassphrase_vault, [], catch_exceptions=False

1638)             )

1639)         result = tests.ReadableResult.parse(_result)
1640)         assert result.error_exit(

1641)             error='Deriving a passphrase requires a SERVICE'

1642)         ), 'expected error exit and known error message'

1643) 

1644)     def test_226a_no_passphrase_or_key(
1645)         self, monkeypatch: pytest.MonkeyPatch
1646)     ) -> None:

1647)         runner = click.testing.CliRunner(mix_stderr=False)

1648)         with tests.isolated_config(
1649)             monkeypatch=monkeypatch,
1650)             runner=runner,
1651)         ):

1652)             _result = runner.invoke(

1653)                 cli.derivepassphrase_vault,

1654)                 ['--', DUMMY_SERVICE],

1655)                 catch_exceptions=False,

1656)             )

1657)         result = tests.ReadableResult.parse(_result)
1658)         assert result.error_exit(

1659)             error='No passphrase or key was given'

1660)         ), 'expected error exit and known error message'

1661) 

1662)     def test_230_config_directory_nonexistant(
1663)         self, monkeypatch: pytest.MonkeyPatch
1664)     ) -> None:

1665)         """https://github.com/the-13th-letter/derivepassphrase/issues/6"""

1666)         runner = click.testing.CliRunner(mix_stderr=False)
1667)         with tests.isolated_config(
1668)             monkeypatch=monkeypatch,
1669)             runner=runner,
1670)         ):

1671)             shutil.rmtree('.derivepassphrase')

1672)             os_makedirs_called = False
1673)             real_os_makedirs = os.makedirs
1674) 
1675)             def makedirs(*args: Any, **kwargs: Any) -> Any:
1676)                 nonlocal os_makedirs_called
1677)                 os_makedirs_called = True
1678)                 return real_os_makedirs(*args, **kwargs)
1679) 
1680)             monkeypatch.setattr(os, 'makedirs', makedirs)

1681)             _result = runner.invoke(

1682)                 cli.derivepassphrase_vault,

1683)                 ['--config', '-p'],
1684)                 catch_exceptions=False,
1685)                 input='abc\n',
1686)             )

1687)             result = tests.ReadableResult.parse(_result)
1688)             assert result.clean_exit(), 'expected clean exit'

1689)             assert (

1690)                 result.stderr == 'Passphrase:'

1691)             ), 'program unexpectedly failed?!'
1692)             assert os_makedirs_called, 'os.makedirs has not been called?!'

1693)             with open(
1694)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
1695)             ) as infile:

1696)                 config_readback = json.load(infile)
1697)             assert config_readback == {
1698)                 'global': {'phrase': 'abc'},
1699)                 'services': {},
1700)             }, 'config mismatch'
1701) 

1702)     def test_230a_config_directory_not_a_file(
1703)         self, monkeypatch: pytest.MonkeyPatch
1704)     ) -> None:

1705)         """https://github.com/the-13th-letter/derivepassphrase/issues/6"""

1706)         runner = click.testing.CliRunner(mix_stderr=False)
1707)         with tests.isolated_config(
1708)             monkeypatch=monkeypatch,
1709)             runner=runner,
1710)         ):
1711)             _save_config = cli._save_config
1712) 
1713)             def obstruct_config_saving(*args: Any, **kwargs: Any) -> Any:
1714)                 with contextlib.suppress(FileNotFoundError):
1715)                     shutil.rmtree('.derivepassphrase')
1716)                 with open(
1717)                     '.derivepassphrase', 'w', encoding='UTF-8'
1718)                 ) as outfile:
1719)                     print('Obstruction!!', file=outfile)
1720)                 monkeypatch.setattr(cli, '_save_config', _save_config)
1721)                 return _save_config(*args, **kwargs)
1722) 
1723)             monkeypatch.setattr(cli, '_save_config', obstruct_config_saving)

1724)             _result = runner.invoke(

1725)                 cli.derivepassphrase_vault,

1726)                 ['--config', '-p'],
1727)                 catch_exceptions=False,
1728)                 input='abc\n',
1729)             )

1730)             result = tests.ReadableResult.parse(_result)
1731)             assert result.error_exit(

1732)                 error='Cannot store vault settings:'

1733)             ), 'expected error exit and known error message'

1734) 

1735)     def test_230b_store_config_custom_error(
1736)         self, monkeypatch: pytest.MonkeyPatch
1737)     ) -> None:

1738)         runner = click.testing.CliRunner(mix_stderr=False)
1739)         with tests.isolated_config(
1740)             monkeypatch=monkeypatch,
1741)             runner=runner,
1742)         ):

1743)             custom_error = 'custom error message'

1744) 

1745)             def raiser(config: Any) -> None:
1746)                 del config
1747)                 raise RuntimeError(custom_error)

1748) 

1749)             monkeypatch.setattr(cli, '_save_config', raiser)

1750)             _result = runner.invoke(

1751)                 cli.derivepassphrase_vault,

1752)                 ['--config', '-p'],
1753)                 catch_exceptions=False,
1754)                 input='abc\n',
1755)             )

1756)             result = tests.ReadableResult.parse(_result)
1757)             assert result.error_exit(

1758)                 error=custom_error

1759)             ), 'expected error exit and known error message'

1760) 

1761)     @pytest.mark.parametrize(

1762)         ['main_config', 'command_line', 'input', 'warning_message'],

1763)         [
1764)             pytest.param(

1765)                 '',

1766)                 ['--import', '-'],
1767)                 json.dumps({
1768)                     'global': {'phrase': 'Du\u0308sseldorf'},
1769)                     'services': {},
1770)                 }),

1771)                 'The $.global passphrase is not NFC-normalized',

1772)                 id='global-NFC',
1773)             ),
1774)             pytest.param(

1775)                 '',

1776)                 ['--import', '-'],
1777)                 json.dumps({
1778)                     'services': {
1779)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1780)                         'weird entry name': {'phrase': 'Du\u0308sseldorf'},
1781)                     }
1782)                 }),
1783)                 (

1784)                     'The $.services["weird entry name"] passphrase '

1785)                     'is not NFC-normalized'
1786)                 ),
1787)                 id='service-weird-name-NFC',
1788)             ),
1789)             pytest.param(

1790)                 '',

1791)                 ['--config', '-p', '--', DUMMY_SERVICE],

1792)                 'Du\u0308sseldorf',
1793)                 (

1794)                     f'The $.services.{DUMMY_SERVICE} passphrase '

1795)                     f'is not NFC-normalized'
1796)                 ),
1797)                 id='config-NFC',
1798)             ),
1799)             pytest.param(

1800)                 '',

1801)                 ['-p', '--', DUMMY_SERVICE],

1802)                 'Du\u0308sseldorf',

1803)                 'The interactive input passphrase is not NFC-normalized',

1804)                 id='direct-input-NFC',
1805)             ),
1806)             pytest.param(

1807)                 textwrap.dedent(r"""
1808)                 [vault]
1809)                 default-unicode-normalization-form = 'NFD'
1810)                 """),

1811)                 ['--import', '-'],
1812)                 json.dumps({
1813)                     'global': {
1814)                         'phrase': 'D\u00fcsseldorf',
1815)                     },
1816)                     'services': {},
1817)                 }),

1818)                 'The $.global passphrase is not NFD-normalized',

1819)                 id='global-NFD',
1820)             ),
1821)             pytest.param(

1822)                 textwrap.dedent(r"""
1823)                 [vault]
1824)                 default-unicode-normalization-form = 'NFD'
1825)                 """),

1826)                 ['--import', '-'],
1827)                 json.dumps({
1828)                     'services': {
1829)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1830)                         'weird entry name': {'phrase': 'D\u00fcsseldorf'},

1831)                     },

1832)                 }),
1833)                 (

1834)                     'The $.services["weird entry name"] passphrase '

1835)                     'is not NFD-normalized'
1836)                 ),
1837)                 id='service-weird-name-NFD',
1838)             ),

1839)             pytest.param(
1840)                 textwrap.dedent(r"""
1841)                 [vault.unicode-normalization-form]
1842)                 'weird entry name 2' = 'NFKD'
1843)                 """),
1844)                 ['--import', '-'],
1845)                 json.dumps({
1846)                     'services': {
1847)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1848)                         'weird entry name 1': {'phrase': 'D\u00fcsseldorf'},
1849)                         'weird entry name 2': {'phrase': 'D\u00fcsseldorf'},
1850)                     },
1851)                 }),
1852)                 (

1853)                     'The $.services["weird entry name 2"] passphrase '

1854)                     'is not NFKD-normalized'
1855)                 ),
1856)                 id='service-weird-name-2-NFKD',
1857)             ),

1858)         ],
1859)     )
1860)     def test_300_unicode_normalization_form_warning(
1861)         self,

1862)         monkeypatch: pytest.MonkeyPatch,

1863)         caplog: pytest.LogCaptureFixture,

1864)         main_config: str,

1865)         command_line: list[str],
1866)         input: str | None,

1867)         warning_message: str,

1868)     ) -> None:
1869)         runner = click.testing.CliRunner(mix_stderr=False)

1870)         with tests.isolated_vault_config(

1871)             monkeypatch=monkeypatch,
1872)             runner=runner,

1873)             vault_config={
1874)                 'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}
1875)             },

1876)             main_config_str=main_config,

1877)         ):

1878)             _result = runner.invoke(

1879)                 cli.derivepassphrase_vault,

1880)                 ['--debug', *command_line],

1881)                 catch_exceptions=False,
1882)                 input=input,
1883)             )

1884)         result = tests.ReadableResult.parse(_result)
1885)         assert result.clean_exit(), 'expected clean exit'

1886)         assert tests.warning_emitted(
1887)             warning_message, caplog.record_tuples

1888)         ), 'expected known warning message in stderr'

1889) 

1890)     @pytest.mark.parametrize(
1891)         ['main_config', 'command_line', 'input', 'error_message'],
1892)         [
1893)             pytest.param(
1894)                 textwrap.dedent(r"""
1895)                 [vault]
1896)                 default-unicode-normalization-form = 'XXX'
1897)                 """),
1898)                 ['--import', '-'],
1899)                 json.dumps({
1900)                     'services': {
1901)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1902)                         'with_normalization': {'phrase': 'D\u00fcsseldorf'},
1903)                     },
1904)                 }),
1905)                 (
1906)                     "Invalid value 'XXX' for config key "

1907)                     'vault.default-unicode-normalization-form'

1908)                 ),
1909)                 id='global',
1910)             ),
1911)             pytest.param(
1912)                 textwrap.dedent(r"""
1913)                 [vault.unicode-normalization-form]
1914)                 with_normalization = 'XXX'
1915)                 """),
1916)                 ['--import', '-'],
1917)                 json.dumps({
1918)                     'services': {
1919)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1920)                         'with_normalization': {'phrase': 'D\u00fcsseldorf'},
1921)                     },
1922)                 }),
1923)                 (
1924)                     "Invalid value 'XXX' for config key "

1925)                     'vault.with_normalization.unicode-normalization-form'

1926)                 ),
1927)                 id='service',
1928)             ),
1929)         ],
1930)     )
1931)     def test_301_unicode_normalization_form_error(
1932)         self,
1933)         monkeypatch: pytest.MonkeyPatch,
1934)         main_config: str,
1935)         command_line: list[str],
1936)         input: str | None,
1937)         error_message: str,
1938)     ) -> None:
1939)         runner = click.testing.CliRunner(mix_stderr=False)
1940)         with tests.isolated_vault_config(
1941)             monkeypatch=monkeypatch,
1942)             runner=runner,
1943)             vault_config={
1944)                 'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}
1945)             },
1946)             main_config_str=main_config,
1947)         ):
1948)             _result = runner.invoke(
1949)                 cli.derivepassphrase_vault,
1950)                 command_line,
1951)                 catch_exceptions=False,
1952)                 input=input,
1953)             )
1954)         result = tests.ReadableResult.parse(_result)
1955)         assert result.error_exit(

1956)             error='The user configuration file is invalid.'

1957)         ), 'expected error exit and known error message'
1958)         assert result.error_exit(
1959)             error=error_message
1960)         ), 'expected error exit and known error message'
1961) 
1962)     @pytest.mark.parametrize(
1963)         'command_line',
1964)         [
1965)             pytest.param(
1966)                 ['--config', '--phrase'],
1967)                 id='configure global passphrase',
1968)             ),
1969)             pytest.param(
1970)                 ['--phrase', '--', DUMMY_SERVICE],
1971)                 id='interactive passphrase',
1972)             ),
1973)         ],
1974)     )
1975)     def test_301a_unicode_normalization_form_error_from_stored_config(
1976)         self,
1977)         monkeypatch: pytest.MonkeyPatch,
1978)         command_line: list[str],
1979)     ) -> None:
1980)         runner = click.testing.CliRunner(mix_stderr=False)
1981)         with tests.isolated_vault_config(
1982)             monkeypatch=monkeypatch,
1983)             runner=runner,
1984)             vault_config={
1985)                 'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}
1986)             },
1987)             main_config_str=textwrap.dedent("""
1988)             [vault]
1989)             default-unicode-normalization-form = 'XXX'
1990)             """),
1991)         ):
1992)             _result = runner.invoke(
1993)                 cli.derivepassphrase_vault,
1994)                 command_line,
1995)                 input=DUMMY_PASSPHRASE,
1996)                 catch_exceptions=False,
1997)             )
1998)             result = tests.ReadableResult.parse(_result)
1999)             assert result.error_exit(

2000)                 error='The user configuration file is invalid.'

2001)             ), 'expected error exit and known error message'
2002)             assert result.error_exit(
2003)                 error=(
2004)                     "Invalid value 'XXX' for config key "

2005)                     'vault.default-unicode-normalization-form'

2006)                 ),
2007)             ), 'expected error exit and known error message'
2008) 
2009)     def test_310_bad_user_config_file(
2010)         self,
2011)         monkeypatch: pytest.MonkeyPatch,
2012)     ) -> None:
2013)         runner = click.testing.CliRunner(mix_stderr=False)
2014)         with tests.isolated_vault_config(
2015)             monkeypatch=monkeypatch,
2016)             runner=runner,
2017)             vault_config={'services': {}},
2018)             main_config_str=textwrap.dedent("""
2019)             This file is not valid TOML.
2020)             """),
2021)         ):
2022)             _result = runner.invoke(
2023)                 cli.derivepassphrase_vault,
2024)                 ['--phrase', '--', DUMMY_SERVICE],
2025)                 input=DUMMY_PASSPHRASE,
2026)                 catch_exceptions=False,
2027)             )
2028)             result = tests.ReadableResult.parse(_result)
2029)             assert result.error_exit(
2030)                 error='Cannot load user config:'
2031)             ), 'expected error exit and known error message'
2032) 

2033)     def test_400_missing_af_unix_support(
2034)         self,
2035)         monkeypatch: pytest.MonkeyPatch,
2036)     ) -> None:
2037)         runner = click.testing.CliRunner(mix_stderr=False)
2038)         with tests.isolated_vault_config(
2039)             monkeypatch=monkeypatch,
2040)             runner=runner,

2041)             vault_config={'global': {'phrase': 'abc'}, 'services': {}},

2042)         ):
2043)             monkeypatch.setenv(
2044)                 'SSH_AUTH_SOCK', "the value doesn't even matter"
2045)             )
2046)             monkeypatch.delattr(socket, 'AF_UNIX', raising=False)
2047)             _result = runner.invoke(
2048)                 cli.derivepassphrase_vault,
2049)                 ['--key', '--config'],
2050)                 catch_exceptions=False,
2051)             )
2052)         result = tests.ReadableResult.parse(_result)
2053)         assert result.error_exit(
2054)             error='does not support UNIX domain sockets'
2055)         ), 'expected error exit and known error message'
2056) 

2057) 

2058) class TestCLIUtils:

2059)     @pytest.mark.parametrize(
2060)         'config',
2061)         [
2062)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
2063)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
2064)             {
2065)                 'global': {'phrase': 'abc'},
2066)                 'services': {'sv': {'phrase': 'my passphrase'}},
2067)             },
2068)             {
2069)                 'global': {'phrase': 'abc'},
2070)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
2071)             },
2072)             {
2073)                 'global': {'phrase': 'abc'},
2074)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
2075)             },
2076)         ],
2077)     )
2078)     def test_100_load_config(
2079)         self, monkeypatch: pytest.MonkeyPatch, config: Any
2080)     ) -> None:
2081)         runner = click.testing.CliRunner()
2082)         with tests.isolated_vault_config(

2083)             monkeypatch=monkeypatch, runner=runner, vault_config=config

2084)         ):
2085)             config_filename = cli._config_filename(subsystem='vault')
2086)             with open(config_filename, encoding='UTF-8') as fileobj:
2087)                 assert json.load(fileobj) == config
2088)             assert cli._load_config() == config
2089) 
2090)     def test_110_save_bad_config(

2091)         self, monkeypatch: pytest.MonkeyPatch
2092)     ) -> None:

2093)         runner = click.testing.CliRunner()

2094)         # Use parenthesized context manager expressions here once Python
2095)         # 3.9 becomes unsupported.
2096)         with contextlib.ExitStack() as stack:
2097)             stack.enter_context(
2098)                 tests.isolated_vault_config(

2099)                     monkeypatch=monkeypatch, runner=runner, vault_config={}

2100)                 )
2101)             )
2102)             stack.enter_context(
2103)                 pytest.raises(ValueError, match='Invalid vault config')
2104)             )

2105)             cli._save_config(None)  # type: ignore[arg-type]

2106) 

2107)     def test_111_prompt_for_selection_multiple(self) -> None:

2108)         @click.command()
2109)         @click.option('--heading', default='Our menu:')
2110)         @click.argument('items', nargs=-1)

2111)         def driver(heading: str, items: list[str]) -> None:

2112)             # from https://montypython.fandom.com/wiki/Spam#The_menu
2113)             items = items or [
2114)                 'Egg and bacon',
2115)                 'Egg, sausage and bacon',
2116)                 'Egg and spam',
2117)                 'Egg, bacon and spam',
2118)                 'Egg, bacon, sausage and spam',
2119)                 'Spam, bacon, sausage and spam',
2120)                 'Spam, egg, spam, spam, bacon and spam',
2121)                 'Spam, spam, spam, egg and spam',

2122)                 (
2123)                     'Spam, spam, spam, spam, spam, spam, baked beans, '
2124)                     'spam, spam, spam and spam'
2125)                 ),
2126)                 (
2127)                     'Lobster thermidor aux crevettes with a mornay sauce '
2128)                     'garnished with truffle paté, brandy '
2129)                     'and a fried egg on top and spam'
2130)                 ),

2131)             ]
2132)             index = cli._prompt_for_selection(items, heading=heading)
2133)             click.echo('A fine choice: ', nl=False)
2134)             click.echo(items[index])
2135)             click.echo('(Note: Vikings strictly optional.)')

2136) 

2137)         runner = click.testing.CliRunner(mix_stderr=True)

2138)         _result = runner.invoke(driver, [], input='9')
2139)         result = tests.ReadableResult.parse(_result)
2140)         assert result.clean_exit(
2141)             output="""\

2142) Our menu:
2143) [1] Egg and bacon
2144) [2] Egg, sausage and bacon
2145) [3] Egg and spam
2146) [4] Egg, bacon and spam
2147) [5] Egg, bacon, sausage and spam
2148) [6] Spam, bacon, sausage and spam
2149) [7] Spam, egg, spam, spam, bacon and spam
2150) [8] Spam, spam, spam, egg and spam
2151) [9] Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
2152) [10] Lobster thermidor aux crevettes with a mornay sauce garnished with truffle paté, brandy and a fried egg on top and spam
2153) Your selection? (1-10, leave empty to abort): 9
2154) A fine choice: Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
2155) (Note: Vikings strictly optional.)

2156) """

2157)         ), 'expected clean exit'
2158)         _result = runner.invoke(

2159)             driver, ['--heading='], input='', catch_exceptions=True
2160)         )

2161)         result = tests.ReadableResult.parse(_result)
2162)         assert result.error_exit(
2163)             error=IndexError
2164)         ), 'expected error exit and known error type'

2165)         assert (

2166)             result.output

2167)             == """\

2168) [1] Egg and bacon
2169) [2] Egg, sausage and bacon
2170) [3] Egg and spam
2171) [4] Egg, bacon and spam
2172) [5] Egg, bacon, sausage and spam
2173) [6] Spam, bacon, sausage and spam
2174) [7] Spam, egg, spam, spam, bacon and spam
2175) [8] Spam, spam, spam, egg and spam
2176) [9] Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
2177) [10] Lobster thermidor aux crevettes with a mornay sauce garnished with truffle paté, brandy and a fried egg on top and spam

2178) Your selection? (1-10, leave empty to abort):\x20

2179) """

2180)         ), 'expected known output'

2181) 

2182)     def test_112_prompt_for_selection_single(self) -> None:

2183)         @click.command()
2184)         @click.option('--item', default='baked beans')
2185)         @click.argument('prompt')

2186)         def driver(item: str, prompt: str) -> None:

2187)             try:

2188)                 cli._prompt_for_selection(
2189)                     [item], heading='', single_choice_prompt=prompt
2190)                 )

2191)             except IndexError:

2192)                 click.echo('Boo.')

2193)                 raise

2194)             else:
2195)                 click.echo('Great!')

2196) 

2197)         runner = click.testing.CliRunner(mix_stderr=True)

2198)         _result = runner.invoke(

2199)             driver, ['Will replace with spam. Confirm, y/n?'], input='y'
2200)         )

2201)         result = tests.ReadableResult.parse(_result)
2202)         assert result.clean_exit(
2203)             output="""\

2204) [1] baked beans
2205) Will replace with spam. Confirm, y/n? y
2206) Great!

2207) """

2208)         ), 'expected clean exit'
2209)         _result = runner.invoke(

2210)             driver,

2211)             ['Will replace with spam, okay? (Please say "y" or "n".)'],

2212)             input='',
2213)         )

2214)         result = tests.ReadableResult.parse(_result)
2215)         assert result.error_exit(
2216)             error=IndexError
2217)         ), 'expected error exit and known error type'

2218)         assert (

2219)             result.output

2220)             == """\

2221) [1] baked beans

2222) Will replace with spam, okay? (Please say "y" or "n".):\x20

2223) Boo.

2224) """

2225)         ), 'expected known output'

2226) 

2227)     def test_113_prompt_for_passphrase(

2228)         self, monkeypatch: pytest.MonkeyPatch
2229)     ) -> None:

2230)         monkeypatch.setattr(
2231)             click,
2232)             'prompt',
2233)             lambda *a, **kw: json.dumps({'args': a, 'kwargs': kw}),
2234)         )

2235)         res = json.loads(cli._prompt_for_passphrase())

2236)         err_msg = 'missing arguments to passphrase prompt'
2237)         assert 'args' in res, err_msg
2238)         assert 'kwargs' in res, err_msg
2239)         assert res['args'][:1] == ['Passphrase'], err_msg
2240)         assert res['kwargs'].get('default') == '', err_msg
2241)         assert not res['kwargs'].get('show_default', True), err_msg
2242)         assert res['kwargs'].get('err'), err_msg
2243)         assert res['kwargs'].get('hide_input'), err_msg

2244) 

2245)     def test_120_standard_logging_context_manager(
2246)         self,
2247)         caplog: pytest.LogCaptureFixture,
2248)         capsys: pytest.CaptureFixture[str],
2249)     ) -> None:
2250)         prog_name = cli.StandardCLILogging.prog_name
2251)         package_name = cli.StandardCLILogging.package_name
2252)         logger = logging.getLogger(package_name)
2253)         deprecation_logger = logging.getLogger(f'{package_name}.deprecation')
2254)         logging_cm = cli.StandardCLILogging.ensure_standard_logging()
2255)         with logging_cm:
2256)             assert (
2257)                 sum(
2258)                     1
2259)                     for h in logger.handlers
2260)                     if h is cli.StandardCLILogging.cli_handler
2261)                 )
2262)                 == 1
2263)             )
2264)             logger.warning('message 1')
2265)             with logging_cm:
2266)                 deprecation_logger.warning('message 2')
2267)                 assert (
2268)                     sum(
2269)                         1
2270)                         for h in logger.handlers
2271)                         if h is cli.StandardCLILogging.cli_handler
2272)                     )
2273)                     == 1
2274)                 )
2275)                 assert capsys.readouterr() == (
2276)                     '',
2277)                     (
2278)                         f'{prog_name}: Warning: message 1\n'
2279)                         f'{prog_name}: Deprecation warning: message 2\n'
2280)                     ),
2281)                 )
2282)             logger.warning('message 3')
2283)             assert (
2284)                 sum(
2285)                     1
2286)                     for h in logger.handlers
2287)                     if h is cli.StandardCLILogging.cli_handler
2288)                 )
2289)                 == 1
2290)             )
2291)             assert capsys.readouterr() == (
2292)                 '',
2293)                 f'{prog_name}: Warning: message 3\n',
2294)             )
2295)             assert caplog.record_tuples == [
2296)                 (package_name, logging.WARNING, 'message 1'),
2297)                 (f'{package_name}.deprecation', logging.WARNING, 'message 2'),
2298)                 (package_name, logging.WARNING, 'message 3'),
2299)             ]
2300) 
2301)     def test_121_standard_logging_warnings_context_manager(
2302)         self,
2303)         caplog: pytest.LogCaptureFixture,
2304)         capsys: pytest.CaptureFixture[str],
2305)     ) -> None:
2306)         warnings_cm = cli.StandardCLILogging.ensure_standard_warnings_logging()
2307)         THE_FUTURE = 'the future will be here sooner than you think'  # noqa: N806
2308)         JUST_TESTING = 'just testing whether warnings work'  # noqa: N806
2309)         with warnings_cm:
2310)             assert (
2311)                 sum(
2312)                     1
2313)                     for h in logging.getLogger('py.warnings').handlers
2314)                     if h is cli.StandardCLILogging.warnings_handler
2315)                 )
2316)                 == 1
2317)             )
2318)             warnings.warn(UserWarning(JUST_TESTING), stacklevel=1)
2319)             with warnings_cm:
2320)                 warnings.warn(FutureWarning(THE_FUTURE), stacklevel=1)
2321)                 _out, err = capsys.readouterr()
2322)                 err_lines = err.splitlines(True)
2323)                 assert any(
2324)                     f'UserWarning: {JUST_TESTING}' in line
2325)                     for line in err_lines
2326)                 )
2327)                 assert any(
2328)                     f'FutureWarning: {THE_FUTURE}' in line
2329)                     for line in err_lines
2330)                 )
2331)             warnings.warn(UserWarning(JUST_TESTING), stacklevel=1)
2332)             _out, err = capsys.readouterr()
2333)             err_lines = err.splitlines(True)
2334)             assert any(
2335)                 f'UserWarning: {JUST_TESTING}' in line for line in err_lines
2336)             )
2337)             assert not any(
2338)                 f'FutureWarning: {THE_FUTURE}' in line for line in err_lines
2339)             )
2340)             record_tuples = caplog.record_tuples
2341)             assert [tup[:2] for tup in record_tuples] == [
2342)                 ('py.warnings', logging.WARNING),
2343)                 ('py.warnings', logging.WARNING),
2344)                 ('py.warnings', logging.WARNING),
2345)             ]
2346)             assert f'UserWarning: {JUST_TESTING}' in record_tuples[0][2]
2347)             assert f'FutureWarning: {THE_FUTURE}' in record_tuples[1][2]
2348)             assert f'UserWarning: {JUST_TESTING}' in record_tuples[2][2]
2349) 

2350)     def _export_as_sh_helper(
2351)         self,
2352)         config: Any,
2353)     ) -> None:
2354)         prog_name_list = ('derivepassphrase', 'vault')
2355)         with io.StringIO() as outfile:
2356)             cli._print_config_as_sh_script(
2357)                 config, outfile=outfile, prog_name_list=prog_name_list
2358)             )
2359)             script = outfile.getvalue()
2360)         runner = click.testing.CliRunner(mix_stderr=False)
2361)         monkeypatch = pytest.MonkeyPatch()
2362)         with tests.isolated_vault_config(
2363)             runner=runner,
2364)             monkeypatch=monkeypatch,
2365)             vault_config={'services': {}},
2366)         ):
2367)             for _result in vault_config_exporter_shell_interpreter(script):
2368)                 result = tests.ReadableResult.parse(_result)
2369)                 assert result.clean_exit()
2370)             assert cli._load_config() == config
2371) 
2372)     @hypothesis.given(
2373)         global_config_settable=tests.vault_full_service_config(),
2374)         global_config_importable=strategies.fixed_dictionaries(
2375)             {},
2376)             optional={
2377)                 'key': strategies.text(
2378)                     alphabet=strategies.characters(
2379)                         min_codepoint=32,
2380)                         max_codepoint=126,
2381)                     ),
2382)                     max_size=128,
2383)                 ),
2384)                 'phrase': strategies.text(
2385)                     alphabet=strategies.characters(
2386)                         min_codepoint=32,
2387)                         max_codepoint=126,
2388)                     ),
2389)                     max_size=64,
2390)                 ),
2391)             },
2392)         ),
2393)     )
2394)     def test_130a_export_as_sh_global(
2395)         self,
2396)         global_config_settable: _types.VaultConfigServicesSettings,
2397)         global_config_importable: _types.VaultConfigServicesSettings,
2398)     ) -> None:
2399)         config: _types.VaultConfig = {
2400)             'global': global_config_settable | global_config_importable,
2401)             'services': {},
2402)         }
2403)         assert _types.clean_up_falsy_vault_config_values(config) is not None
2404)         assert _types.is_vault_config(config)
2405)         return self._export_as_sh_helper(config)
2406) 
2407)     @hypothesis.given(
2408)         global_config_importable=strategies.fixed_dictionaries(
2409)             {},
2410)             optional={
2411)                 'key': strategies.text(
2412)                     alphabet=strategies.characters(
2413)                         min_codepoint=32,
2414)                         max_codepoint=126,
2415)                     ),
2416)                     max_size=128,
2417)                 ),
2418)                 'phrase': strategies.text(
2419)                     alphabet=strategies.characters(
2420)                         min_codepoint=32,
2421)                         max_codepoint=126,
2422)                     ),
2423)                     max_size=64,
2424)                 ),
2425)             },
2426)         ),
2427)     )
2428)     def test_130b_export_as_sh_global_only_imports(
2429)         self,
2430)         global_config_importable: _types.VaultConfigServicesSettings,
2431)     ) -> None:
2432)         config: _types.VaultConfig = {
2433)             'global': global_config_importable,
2434)             'services': {},
2435)         }
2436)         assert _types.clean_up_falsy_vault_config_values(config) is not None
2437)         assert _types.is_vault_config(config)
2438)         if not config['global']:
2439)             config.pop('global')
2440)         return self._export_as_sh_helper(config)
2441) 
2442)     @hypothesis.given(
2443)         service_name=strategies.text(
2444)             alphabet=strategies.characters(
2445)                 min_codepoint=32,
2446)                 max_codepoint=126,
2447)             ),
2448)             min_size=4,
2449)             max_size=64,
2450)         ),
2451)         service_config_settable=tests.vault_full_service_config(),
2452)         service_config_importable=strategies.fixed_dictionaries(
2453)             {},
2454)             optional={
2455)                 'key': strategies.text(
2456)                     alphabet=strategies.characters(
2457)                         min_codepoint=32,
2458)                         max_codepoint=126,
2459)                     ),
2460)                     max_size=128,
2461)                 ),
2462)                 'phrase': strategies.text(
2463)                     alphabet=strategies.characters(
2464)                         min_codepoint=32,
2465)                         max_codepoint=126,
2466)                     ),
2467)                     max_size=64,
2468)                 ),
2469)                 'notes': strategies.text(
2470)                     alphabet=strategies.characters(
2471)                         min_codepoint=32,
2472)                         max_codepoint=126,
2473)                         include_characters=('\n', '\f', '\t'),
2474)                     ),
2475)                     max_size=256,
2476)                 ),
2477)             },
2478)         ),
2479)     )
2480)     def test_130c_export_as_sh_service(
2481)         self,
2482)         service_name: str,
2483)         service_config_settable: _types.VaultConfigServicesSettings,
2484)         service_config_importable: _types.VaultConfigServicesSettings,
2485)     ) -> None:
2486)         config: _types.VaultConfig = {
2487)             'services': {
2488)                 service_name: (
2489)                     service_config_settable | service_config_importable
2490)                 ),
2491)             },
2492)         }
2493)         assert _types.clean_up_falsy_vault_config_values(config) is not None
2494)         assert _types.is_vault_config(config)
2495)         return self._export_as_sh_helper(config)
2496) 
2497)     @hypothesis.given(
2498)         service_name=strategies.text(
2499)             alphabet=strategies.characters(
2500)                 min_codepoint=32,
2501)                 max_codepoint=126,
2502)             ),
2503)             min_size=4,
2504)             max_size=64,
2505)         ),
2506)         service_config_importable=strategies.fixed_dictionaries(
2507)             {},
2508)             optional={
2509)                 'key': strategies.text(
2510)                     alphabet=strategies.characters(
2511)                         min_codepoint=32,
2512)                         max_codepoint=126,
2513)                     ),
2514)                     max_size=128,
2515)                 ),
2516)                 'phrase': strategies.text(
2517)                     alphabet=strategies.characters(
2518)                         min_codepoint=32,
2519)                         max_codepoint=126,
2520)                     ),
2521)                     max_size=64,
2522)                 ),
2523)                 'notes': strategies.text(
2524)                     alphabet=strategies.characters(
2525)                         min_codepoint=32,
2526)                         max_codepoint=126,
2527)                         include_characters=('\n', '\f', '\t'),
2528)                     ),
2529)                     max_size=256,
2530)                 ),
2531)             },
2532)         ),
2533)     )
2534)     def test_130d_export_as_sh_service_only_imports(
2535)         self,
2536)         service_name: str,
2537)         service_config_importable: _types.VaultConfigServicesSettings,
2538)     ) -> None:
2539)         config: _types.VaultConfig = {
2540)             'services': {
2541)                 service_name: service_config_importable,
2542)             },
2543)         }
2544)         assert _types.clean_up_falsy_vault_config_values(config) is not None
2545)         assert _types.is_vault_config(config)
2546)         return self._export_as_sh_helper(config)
2547) 

2548)     @pytest.mark.parametrize(
2549)         ['command_line', 'config', 'result_config'],
2550)         [
2551)             (
2552)                 ['--delete-globals'],
2553)                 {'global': {'phrase': 'abc'}, 'services': {}},
2554)                 {'services': {}},
2555)             ),
2556)             (

2557)                 ['--delete', '--', DUMMY_SERVICE],

2558)                 {
2559)                     'global': {'phrase': 'abc'},
2560)                     'services': {DUMMY_SERVICE: {'notes': '...'}},
2561)                 },
2562)                 {'global': {'phrase': 'abc'}, 'services': {}},
2563)             ),
2564)             (
2565)                 ['--clear'],
2566)                 {
2567)                     'global': {'phrase': 'abc'},
2568)                     'services': {DUMMY_SERVICE: {'notes': '...'}},
2569)                 },
2570)                 {'services': {}},
2571)             ),
2572)         ],
2573)     )

2574)     def test_203_repeated_config_deletion(

2575)         self,

2576)         monkeypatch: pytest.MonkeyPatch,

2577)         command_line: list[str],

2578)         config: _types.VaultConfig,
2579)         result_config: _types.VaultConfig,

2580)     ) -> None:
2581)         runner = click.testing.CliRunner(mix_stderr=False)
2582)         for start_config in [config, result_config]:

2583)             with tests.isolated_vault_config(

2584)                 monkeypatch=monkeypatch,
2585)                 runner=runner,
2586)                 vault_config=start_config,

2587)             ):

2588)                 _result = runner.invoke(

2589)                     cli.derivepassphrase_vault,
2590)                     command_line,
2591)                     catch_exceptions=False,

2592)                 )

2593)                 result = tests.ReadableResult.parse(_result)
2594)                 assert result.clean_exit(
2595)                     empty_stderr=True
2596)                 ), 'expected clean exit'

2597)                 with open(
2598)                     cli._config_filename(subsystem='vault'), encoding='UTF-8'
2599)                 ) as infile:

2600)                     config_readback = json.load(infile)
2601)                 assert config_readback == result_config
2602) 
2603)     def test_204_phrase_from_key_manually(self) -> None:
2604)         assert (

2605)             vault.Vault(

2606)                 phrase=DUMMY_PHRASE_FROM_KEY1, **DUMMY_CONFIG_SETTINGS
2607)             ).generate(DUMMY_SERVICE)
2608)             == DUMMY_RESULT_KEY1

2609)         )
2610) 

2611)     @pytest.mark.parametrize(
2612)         ['vfunc', 'input'],
2613)         [
2614)             (cli._validate_occurrence_constraint, 20),
2615)             (cli._validate_length, 20),
2616)         ],
2617)     )

2618)     def test_210a_validate_constraints_manually(
2619)         self,
2620)         vfunc: Callable[[click.Context, click.Parameter, Any], int | None],
2621)         input: int,
2622)     ) -> None:

2623)         ctx = cli.derivepassphrase_vault.make_context(cli.PROG_NAME, [])
2624)         param = cli.derivepassphrase_vault.params[0]

2625)         assert vfunc(ctx, param, input) == input
2626) 

2627)     @pytest.mark.parametrize('conn_hint', ['none', 'socket', 'client'])

2628)     def test_227_get_suitable_ssh_keys(

2629)         self,

2630)         monkeypatch: pytest.MonkeyPatch,

2631)         running_ssh_agent: tests.RunningSSHAgentInfo,

2632)         conn_hint: str,

2633)     ) -> None:

2634)         with monkeypatch.context():

2635)             monkeypatch.setenv('SSH_AUTH_SOCK', running_ssh_agent.socket)

2636)             monkeypatch.setattr(
2637)                 ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys
2638)             )
2639)             hint: ssh_agent.SSHAgentClient | socket.socket | None

2640)             # Use match/case here once Python 3.9 becomes unsupported.
2641)             if conn_hint == 'client':
2642)                 hint = ssh_agent.SSHAgentClient()
2643)             elif conn_hint == 'socket':
2644)                 hint = socket.socket(family=socket.AF_UNIX)

2645)                 hint.connect(running_ssh_agent.socket)

2646)             else:
2647)                 assert conn_hint == 'none'
2648)                 hint = None

2649)             exception: Exception | None = None
2650)             try:
2651)                 list(cli._get_suitable_ssh_keys(hint))
2652)             except RuntimeError:  # pragma: no cover
2653)                 pass
2654)             except Exception as e:  # noqa: BLE001 # pragma: no cover
2655)                 exception = e
2656)             finally:
2657)                 assert (
2658)                     exception is None
2659)                 ), 'exception querying suitable SSH keys'

2660) 

2661)     def test_400_key_to_phrase(
2662)         self,
2663)         monkeypatch: pytest.MonkeyPatch,
2664)         skip_if_no_af_unix_support: None,
2665)         ssh_agent_client_with_test_keys_loaded: ssh_agent.SSHAgentClient,
2666)     ) -> None:

2667)         class ErrCallback(BaseException):
2668)             def __init__(self, *args: Any, **kwargs: Any) -> None:
2669)                 super().__init__(*args[:1])
2670)                 self.args = args
2671)                 self.kwargs = kwargs

2672) 
2673)         def err(*args: Any, **_kwargs: Any) -> NoReturn:

2674)             raise ErrCallback(*args, **_kwargs)

2675) 
2676)         def fail(*_args: Any, **_kwargs: Any) -> Any:
2677)             raise ssh_agent.SSHAgentFailedError(
2678)                 _types.SSH_AGENT.FAILURE.value,
2679)                 b'',
2680)             )
2681) 

2682)         def fail_runtime(*_args: Any, **_kwargs: Any) -> Any:
2683)             raise ssh_agent.TrailingDataError()
2684) 

2685)         del skip_if_no_af_unix_support
2686)         monkeypatch.setattr(ssh_agent.SSHAgentClient, 'sign', fail)
2687)         loaded_keys = list(ssh_agent_client_with_test_keys_loaded.list_keys())
2688)         loaded_key = base64.standard_b64encode(loaded_keys[0][0])
2689)         with monkeypatch.context() as mp:
2690)             mp.setattr(
2691)                 ssh_agent.SSHAgentClient,
2692)                 'list_keys',
2693)                 lambda *_a, **_kw: [],
2694)             )

2695)             with pytest.raises(ErrCallback, match='not loaded into the agent'):

2696)                 cli._key_to_phrase(loaded_key, error_callback=err)
2697)         with monkeypatch.context() as mp:
2698)             mp.setattr(ssh_agent.SSHAgentClient, 'list_keys', fail)
2699)             with pytest.raises(

2700)                 ErrCallback, match='SSH agent failed to or refused to'

2701)             ):
2702)                 cli._key_to_phrase(loaded_key, error_callback=err)
2703)         with monkeypatch.context() as mp:

2704)             mp.setattr(ssh_agent.SSHAgentClient, 'list_keys', fail_runtime)

2705)             with pytest.raises(

2706)                 ErrCallback, match='SSH agent failed to or refused to'

2707)             ) as excinfo:
2708)                 cli._key_to_phrase(loaded_key, error_callback=err)

2709)             assert excinfo.value.kwargs
2710)             assert isinstance(
2711)                 excinfo.value.kwargs['exc_info'],
2712)                 ssh_agent.SSHAgentFailedError,
2713)             )
2714)             assert excinfo.value.kwargs['exc_info'].__context__ is not None

2715)             assert isinstance(

2716)                 excinfo.value.kwargs['exc_info'].__context__,
2717)                 ssh_agent.TrailingDataError,

2718)             )
2719)         with monkeypatch.context() as mp:
2720)             mp.delenv('SSH_AUTH_SOCK', raising=True)
2721)             with pytest.raises(

2722)                 ErrCallback, match='Cannot find any running SSH agent'

2723)             ):
2724)                 cli._key_to_phrase(loaded_key, error_callback=err)
2725)         with monkeypatch.context() as mp:

2726)             mp.setenv('SSH_AUTH_SOCK', os.environ['SSH_AUTH_SOCK'] + '~')

2727)             with pytest.raises(

2728)                 ErrCallback, match='Cannot connect to the SSH agent'

2729)             ):
2730)                 cli._key_to_phrase(loaded_key, error_callback=err)
2731)         with monkeypatch.context() as mp:
2732)             mp.delattr(socket, 'AF_UNIX', raising=True)
2733)             with pytest.raises(

2734)                 ErrCallback, match='does not support UNIX domain sockets'
2735)             ):
2736)                 cli._key_to_phrase(loaded_key, error_callback=err)
2737)         with monkeypatch.context() as mp:
2738)             mp.setattr(ssh_agent.SSHAgentClient, 'sign', fail_runtime)
2739)             with pytest.raises(
2740)                 ErrCallback, match='violates the communications protocol'

2741)             ):
2742)                 cli._key_to_phrase(loaded_key, error_callback=err)
2743) 

2744) 
2745) class TestCLITransition:
2746)     def test_100_help_output(self, monkeypatch: pytest.MonkeyPatch) -> None:
2747)         runner = click.testing.CliRunner(mix_stderr=False)
2748)         with tests.isolated_config(
2749)             monkeypatch=monkeypatch,
2750)             runner=runner,
2751)         ):
2752)             _result = runner.invoke(
2753)                 cli.derivepassphrase, ['--help'], catch_exceptions=False
2754)             )
2755)             result = tests.ReadableResult.parse(_result)
2756)         assert result.clean_exit(
2757)             empty_stderr=True, output='currently implemented subcommands'
2758)         ), 'expected clean exit, and known help text'
2759) 
2760)     def test_101_help_output_export(
2761)         self, monkeypatch: pytest.MonkeyPatch
2762)     ) -> None:
2763)         runner = click.testing.CliRunner(mix_stderr=False)
2764)         with tests.isolated_config(
2765)             monkeypatch=monkeypatch,
2766)             runner=runner,
2767)         ):
2768)             _result = runner.invoke(
2769)                 cli.derivepassphrase,
2770)                 ['export', '--help'],
2771)                 catch_exceptions=False,
2772)             )
2773)             result = tests.ReadableResult.parse(_result)
2774)         assert result.clean_exit(
2775)             empty_stderr=True, output='only available subcommand'
2776)         ), 'expected clean exit, and known help text'
2777) 
2778)     def test_102_help_output_export_vault(
2779)         self, monkeypatch: pytest.MonkeyPatch
2780)     ) -> None:
2781)         runner = click.testing.CliRunner(mix_stderr=False)
2782)         with tests.isolated_config(
2783)             monkeypatch=monkeypatch,
2784)             runner=runner,
2785)         ):
2786)             _result = runner.invoke(
2787)                 cli.derivepassphrase,
2788)                 ['export', 'vault', '--help'],
2789)                 catch_exceptions=False,
2790)             )
2791)             result = tests.ReadableResult.parse(_result)
2792)         assert result.clean_exit(

2793)             empty_stderr=True, output='Export a vault-native configuration'

2794)         ), 'expected clean exit, and known help text'
2795) 
2796)     def test_103_help_output_vault(
2797)         self, monkeypatch: pytest.MonkeyPatch
2798)     ) -> None:
2799)         runner = click.testing.CliRunner(mix_stderr=False)
2800)         with tests.isolated_config(
2801)             monkeypatch=monkeypatch,
2802)             runner=runner,
2803)         ):
2804)             _result = runner.invoke(
2805)                 cli.derivepassphrase,
2806)                 ['vault', '--help'],
2807)                 catch_exceptions=False,
2808)             )
2809)             result = tests.ReadableResult.parse(_result)
2810)         assert result.clean_exit(

2811)             empty_stderr=True, output='Passphrase generation:\n'

2812)         ), 'expected clean exit, and option groups in help text'
2813)         assert result.clean_exit(

2814)             empty_stderr=True, output='Use $VISUAL or $EDITOR to configure'

2815)         ), 'expected clean exit, and option group epilog in help text'
2816) 

2817)     @pytest.mark.parametrize(
2818)         'config',
2819)         [
2820)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
2821)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
2822)             {
2823)                 'global': {'phrase': 'abc'},
2824)                 'services': {'sv': {'phrase': 'my passphrase'}},
2825)             },
2826)             {
2827)                 'global': {'phrase': 'abc'},
2828)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
2829)             },
2830)             {
2831)                 'global': {'phrase': 'abc'},
2832)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
2833)             },
2834)         ],
2835)     )
2836)     def test_110_load_config_backup(
2837)         self, monkeypatch: pytest.MonkeyPatch, config: Any
2838)     ) -> None:
2839)         runner = click.testing.CliRunner()
2840)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

2841)             config_filename = cli._config_filename(
2842)                 subsystem='old settings.json'
2843)             )

2844)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
2845)                 print(json.dumps(config, indent=2), file=fileobj)
2846)             assert cli._migrate_and_load_old_config()[0] == config
2847) 
2848)     @pytest.mark.parametrize(
2849)         'config',
2850)         [
2851)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
2852)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
2853)             {
2854)                 'global': {'phrase': 'abc'},
2855)                 'services': {'sv': {'phrase': 'my passphrase'}},
2856)             },
2857)             {
2858)                 'global': {'phrase': 'abc'},
2859)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
2860)             },
2861)             {
2862)                 'global': {'phrase': 'abc'},
2863)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
2864)             },
2865)         ],
2866)     )
2867)     def test_111_migrate_config(
2868)         self, monkeypatch: pytest.MonkeyPatch, config: Any
2869)     ) -> None:
2870)         runner = click.testing.CliRunner()
2871)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

2872)             config_filename = cli._config_filename(
2873)                 subsystem='old settings.json'
2874)             )

2875)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
2876)                 print(json.dumps(config, indent=2), file=fileobj)
2877)             assert cli._migrate_and_load_old_config() == (config, None)
2878) 
2879)     @pytest.mark.parametrize(
2880)         'config',
2881)         [
2882)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
2883)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
2884)             {
2885)                 'global': {'phrase': 'abc'},
2886)                 'services': {'sv': {'phrase': 'my passphrase'}},
2887)             },
2888)             {
2889)                 'global': {'phrase': 'abc'},
2890)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
2891)             },
2892)             {
2893)                 'global': {'phrase': 'abc'},
2894)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
2895)             },
2896)         ],
2897)     )
2898)     def test_112_migrate_config_error(
2899)         self, monkeypatch: pytest.MonkeyPatch, config: Any
2900)     ) -> None:
2901)         runner = click.testing.CliRunner()
2902)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

2903)             config_filename = cli._config_filename(
2904)                 subsystem='old settings.json'
2905)             )

2906)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
2907)                 print(json.dumps(config, indent=2), file=fileobj)
2908)             os.mkdir(cli._config_filename(subsystem='vault'))
2909)             config2, err = cli._migrate_and_load_old_config()
2910)             assert config2 == config
2911)             assert isinstance(err, OSError)
2912)             assert err.errno == errno.EISDIR
2913) 
2914)     @pytest.mark.parametrize(
2915)         'config',
2916)         [
2917)             {'global': '', 'services': {}},
2918)             {'global': 0, 'services': {}},
2919)             {
2920)                 'global': {'phrase': 'abc'},
2921)                 'services': False,
2922)             },
2923)             {
2924)                 'global': {'phrase': 'abc'},
2925)                 'services': True,
2926)             },
2927)             {
2928)                 'global': {'phrase': 'abc'},
2929)                 'services': None,
2930)             },
2931)         ],
2932)     )
2933)     def test_113_migrate_config_error_bad_config_value(
2934)         self, monkeypatch: pytest.MonkeyPatch, config: Any
2935)     ) -> None:
2936)         runner = click.testing.CliRunner()
2937)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

2938)             config_filename = cli._config_filename(
2939)                 subsystem='old settings.json'
2940)             )

2941)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
2942)                 print(json.dumps(config, indent=2), file=fileobj)
2943)             with pytest.raises(ValueError, match=cli._INVALID_VAULT_CONFIG):
2944)                 cli._migrate_and_load_old_config()
2945) 

2946)     def test_200_forward_export_vault_path_parameter(

2947)         self,
2948)         monkeypatch: pytest.MonkeyPatch,
2949)         caplog: pytest.LogCaptureFixture,

2950)     ) -> None:
2951)         pytest.importorskip('cryptography', minversion='38.0')
2952)         runner = click.testing.CliRunner(mix_stderr=False)
2953)         with tests.isolated_vault_exporter_config(
2954)             monkeypatch=monkeypatch,
2955)             runner=runner,
2956)             vault_config=tests.VAULT_V03_CONFIG,
2957)             vault_key=tests.VAULT_MASTER_KEY,
2958)         ):
2959)             monkeypatch.setenv('VAULT_KEY', tests.VAULT_MASTER_KEY)
2960)             _result = runner.invoke(
2961)                 cli.derivepassphrase,
2962)                 ['export', 'VAULT_PATH'],
2963)             )
2964)         result = tests.ReadableResult.parse(_result)
2965)         assert result.clean_exit(empty_stderr=False), 'expected clean exit'

2966)         assert tests.deprecation_warning_emitted(

2967)             'A subcommand will be required here in v1.0', caplog.record_tuples

2968)         )

2969)         assert tests.deprecation_warning_emitted(

2970)             'Defaulting to subcommand "vault"', caplog.record_tuples

2971)         )

2972)         assert json.loads(result.output) == tests.VAULT_V03_CONFIG_DATA
2973) 

2974)     def test_201_forward_export_vault_empty_commandline(
2975)         self,
2976)         monkeypatch: pytest.MonkeyPatch,
2977)         caplog: pytest.LogCaptureFixture,
2978)     ) -> None:
2979)         pytest.importorskip('cryptography', minversion='38.0')
2980)         runner = click.testing.CliRunner(mix_stderr=False)
2981)         with tests.isolated_config(
2982)             monkeypatch=monkeypatch,
2983)             runner=runner,
2984)         ):
2985)             _result = runner.invoke(
2986)                 cli.derivepassphrase,
2987)                 ['export'],
2988)             )
2989)         result = tests.ReadableResult.parse(_result)

2990)         assert tests.deprecation_warning_emitted(

2991)             'A subcommand will be required here in v1.0', caplog.record_tuples

2992)         )

2993)         assert tests.deprecation_warning_emitted(

2994)             'Defaulting to subcommand "vault"', caplog.record_tuples
2995)         )

2996)         assert result.error_exit(
2997)             error="Missing argument 'PATH'"
2998)         ), 'expected error exit and known error type'
2999) 

3000)     @pytest.mark.parametrize(
3001)         'charset_name', ['lower', 'upper', 'number', 'space', 'dash', 'symbol']
3002)     )
3003)     def test_210_forward_vault_disable_character_set(

3004)         self,
3005)         monkeypatch: pytest.MonkeyPatch,
3006)         caplog: pytest.LogCaptureFixture,
3007)         charset_name: str,

3008)     ) -> None:
3009)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
3010)         option = f'--{charset_name}'

3011)         charset = vault.Vault._CHARSETS[charset_name].decode('ascii')

3012)         runner = click.testing.CliRunner(mix_stderr=False)
3013)         with tests.isolated_config(
3014)             monkeypatch=monkeypatch,
3015)             runner=runner,
3016)         ):
3017)             _result = runner.invoke(
3018)                 cli.derivepassphrase,

3019)                 [option, '0', '-p', '--', DUMMY_SERVICE],

3020)                 input=DUMMY_PASSPHRASE,
3021)                 catch_exceptions=False,
3022)             )
3023)             result = tests.ReadableResult.parse(_result)
3024)         assert result.clean_exit(empty_stderr=False), 'expected clean exit'

3025)         assert tests.deprecation_warning_emitted(

3026)             'A subcommand will be required here in v1.0', caplog.record_tuples

3027)         )

3028)         assert tests.deprecation_warning_emitted(

3029)             'Defaulting to subcommand "vault"', caplog.record_tuples

3030)         )

3031)         for c in charset:
3032)             assert (
3033)                 c not in result.output
3034)             ), f'derived password contains forbidden character {c!r}'

3035)