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 contextlib

8) import errno

9) import json
10) import os

11) import shutil

12) import socket

13) from typing import TYPE_CHECKING

14) 

15) import click.testing
16) import pytest

17) from typing_extensions import NamedTuple
18) 
19) import derivepassphrase as dpp

20) import tests

21) from derivepassphrase import _types, cli, ssh_agent

22) 
23) if TYPE_CHECKING:
24)     from collections.abc import Callable
25) 
26)     from typing_extensions import Any

27) 

28) DUMMY_SERVICE = tests.DUMMY_SERVICE
29) DUMMY_PASSPHRASE = tests.DUMMY_PASSPHRASE
30) DUMMY_CONFIG_SETTINGS = tests.DUMMY_CONFIG_SETTINGS
31) DUMMY_RESULT_PASSPHRASE = tests.DUMMY_RESULT_PASSPHRASE
32) DUMMY_RESULT_KEY1 = tests.DUMMY_RESULT_KEY1
33) DUMMY_PHRASE_FROM_KEY1_RAW = tests.DUMMY_PHRASE_FROM_KEY1_RAW
34) DUMMY_PHRASE_FROM_KEY1 = tests.DUMMY_PHRASE_FROM_KEY1
35) 
36) DUMMY_KEY1 = tests.DUMMY_KEY1
37) DUMMY_KEY1_B64 = tests.DUMMY_KEY1_B64
38) DUMMY_KEY2 = tests.DUMMY_KEY2

39) DUMMY_KEY2_B64 = tests.DUMMY_KEY2_B64
40) DUMMY_KEY3 = tests.DUMMY_KEY3
41) DUMMY_KEY3_B64 = tests.DUMMY_KEY3_B64

42) 
43) 
44) class IncompatibleConfiguration(NamedTuple):
45)     other_options: list[tuple[str, ...]]
46)     needs_service: bool | None

47)     input: str | None

48) 

49) 

50) class SingleConfiguration(NamedTuple):
51)     needs_service: bool | None

52)     input: str | None

53)     check_success: bool
54) 

55) 

56) class OptionCombination(NamedTuple):
57)     options: list[str]
58)     incompatible: bool
59)     needs_service: bool | None

60)     input: str | None

61)     check_success: bool
62) 

63) 

64) PASSWORD_GENERATION_OPTIONS: list[tuple[str, ...]] = [

65)     ('--phrase',),
66)     ('--key',),
67)     ('--length', '20'),
68)     ('--repeat', '20'),
69)     ('--lower', '1'),
70)     ('--upper', '1'),
71)     ('--number', '1'),
72)     ('--space', '1'),
73)     ('--dash', '1'),
74)     ('--symbol', '1'),

75) ]
76) CONFIGURATION_OPTIONS: list[tuple[str, ...]] = [

77)     ('--notes',),
78)     ('--config',),
79)     ('--delete',),
80)     ('--delete-globals',),
81)     ('--clear',),

82) ]
83) CONFIGURATION_COMMANDS: list[tuple[str, ...]] = [

84)     ('--notes',),
85)     ('--delete',),
86)     ('--delete-globals',),
87)     ('--clear',),

88) ]

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

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

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

93)         True,
94)         DUMMY_PASSPHRASE,
95)     ),

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

97)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
98)     ),

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

100)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
101)     ),

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

103)         CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE
104)     ),

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

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

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

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

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

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

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

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

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

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

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

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

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

124)         [
125)             ('--config',),
126)             ('--delete',),
127)             ('--delete-globals',),
128)             ('--clear',),
129)             *STORAGE_OPTIONS,
130)         ],
131)         True,
132)         None,
133)     ),

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

135)         [('--delete',), ('--delete-globals',), ('--clear',), *STORAGE_OPTIONS],
136)         None,
137)         DUMMY_PASSPHRASE,
138)     ),

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

140)         [('--delete-globals',), ('--clear',), *STORAGE_OPTIONS], True, None
141)     ),

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

143)         [('--clear',), *STORAGE_OPTIONS], False, None
144)     ),

145)     ('--clear',): IncompatibleConfiguration(STORAGE_OPTIONS, False, None),
146)     ('--export', '-'): IncompatibleConfiguration(

147)         [('--import', '-')], False, None
148)     ),
149)     ('--import', '-'): IncompatibleConfiguration([], False, None),

150) }
151) SINGLES: dict[tuple[str, ...], SingleConfiguration] = {
152)     ('--phrase',): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
153)     ('--key',): SingleConfiguration(True, None, False),
154)     ('--length', '20'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
155)     ('--repeat', '20'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
156)     ('--lower', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
157)     ('--upper', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
158)     ('--number', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
159)     ('--space', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
160)     ('--dash', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
161)     ('--symbol', '1'): SingleConfiguration(True, DUMMY_PASSPHRASE, True),
162)     ('--notes',): SingleConfiguration(True, None, False),
163)     ('--config', '-p'): SingleConfiguration(None, DUMMY_PASSPHRASE, False),
164)     ('--delete',): SingleConfiguration(True, None, False),
165)     ('--delete-globals',): SingleConfiguration(False, None, True),
166)     ('--clear',): SingleConfiguration(False, None, True),
167)     ('--export', '-'): SingleConfiguration(False, None, True),

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

169) }
170) INTERESTING_OPTION_COMBINATIONS: list[OptionCombination] = []

171) config: IncompatibleConfiguration | SingleConfiguration

172) for opt, config in INCOMPATIBLE.items():
173)     for opt2 in config.other_options:
174)         INTERESTING_OPTION_COMBINATIONS.extend([

175)             OptionCombination(
176)                 options=list(opt + opt2),
177)                 incompatible=True,
178)                 needs_service=config.needs_service,
179)                 input=config.input,
180)                 check_success=False,
181)             ),
182)             OptionCombination(
183)                 options=list(opt2 + opt),
184)                 incompatible=True,
185)                 needs_service=config.needs_service,
186)                 input=config.input,
187)                 check_success=False,
188)             ),

189)         ])
190) for opt, config in SINGLES.items():
191)     INTERESTING_OPTION_COMBINATIONS.append(

192)         OptionCombination(
193)             options=list(opt),
194)             incompatible=False,
195)             needs_service=config.needs_service,
196)             input=config.input,
197)             check_success=config.check_success,
198)         )
199)     )

200) 
201) 

202) class TestCLI:

203)     def test_200_help_output(self, monkeypatch: pytest.MonkeyPatch) -> None:

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

205)         with tests.isolated_config(
206)             monkeypatch=monkeypatch,
207)             runner=runner,
208)             config={'services': {}},
209)         ):

210)             _result = runner.invoke(

211)                 cli.derivepassphrase_vault, ['--help'], catch_exceptions=False

212)             )

213)             result = tests.ReadableResult.parse(_result)
214)         assert result.clean_exit(
215)             empty_stderr=True, output='Password generation:\n'
216)         ), 'expected clean exit, and option groups in help text'
217)         assert result.clean_exit(
218)             empty_stderr=True, output='Use NUMBER=0, e.g. "--symbol 0"'
219)         ), 'expected clean exit, and option group epilog in help text'

220) 

221)     @pytest.mark.parametrize(
222)         'charset_name', ['lower', 'upper', 'number', 'space', 'dash', 'symbol']
223)     )

224)     def test_201_disable_character_set(

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

226)     ) -> None:
227)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
228)         option = f'--{charset_name}'

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

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

231)         with tests.isolated_config(
232)             monkeypatch=monkeypatch,
233)             runner=runner,
234)             config={'services': {}},
235)         ):

236)             _result = runner.invoke(

237)                 cli.derivepassphrase_vault,

238)                 [option, '0', '-p', DUMMY_SERVICE],
239)                 input=DUMMY_PASSPHRASE,
240)                 catch_exceptions=False,
241)             )

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

244)         for c in charset:

245)             assert (
246)                 c not in result.output
247)             ), f'derived password contains forbidden character {c!r}'

248) 

249)     def test_202_disable_repetition(
250)         self, monkeypatch: pytest.MonkeyPatch
251)     ) -> None:

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

254)         with tests.isolated_config(
255)             monkeypatch=monkeypatch,
256)             runner=runner,
257)             config={'services': {}},
258)         ):

259)             _result = runner.invoke(

260)                 cli.derivepassphrase_vault,

261)                 ['--repeat', '0', '-p', DUMMY_SERVICE],
262)                 input=DUMMY_PASSPHRASE,
263)                 catch_exceptions=False,
264)             )

265)             result = tests.ReadableResult.parse(_result)
266)         assert result.clean_exit(
267)             empty_stderr=True
268)         ), 'expected clean exit and empty stderr'
269)         passphrase = result.output.rstrip('\r\n')

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

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

272)                 f'derived password contains repeated character '

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

274)             )

275) 

276)     @pytest.mark.parametrize(
277)         'config',
278)         [
279)             pytest.param(
280)                 {
281)                     'global': {'key': DUMMY_KEY1_B64},
282)                     'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS},
283)                 },
284)                 id='global',
285)             ),
286)             pytest.param(
287)                 {

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

289)                     'services': {
290)                         DUMMY_SERVICE: {
291)                             'key': DUMMY_KEY1_B64,
292)                             **DUMMY_CONFIG_SETTINGS,
293)                         }
294)                     },
295)                 },
296)                 id='service',
297)             ),
298)         ],
299)     )

300)     def test_204a_key_from_config(

301)         self,

302)         monkeypatch: pytest.MonkeyPatch,

303)         config: _types.VaultConfig,

304)     ) -> None:
305)         runner = click.testing.CliRunner(mix_stderr=False)

306)         with tests.isolated_config(
307)             monkeypatch=monkeypatch, runner=runner, config=config
308)         ):
309)             monkeypatch.setattr(

310)                 dpp.vault.Vault, 'phrase_from_key', tests.phrase_from_key

311)             )

312)             _result = runner.invoke(

313)                 cli.derivepassphrase_vault,
314)                 [DUMMY_SERVICE],
315)                 catch_exceptions=False,

316)             )

317)         result = tests.ReadableResult.parse(_result)
318)         assert result.clean_exit(
319)             empty_stderr=True
320)         ), 'expected clean exit and empty stderr'
321)         assert _result.stdout_bytes
322)         assert (
323)             _result.stdout_bytes.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
324)         ), 'known false output: phrase-based instead of key-based'
325)         assert (
326)             _result.stdout_bytes.rstrip(b'\n') == DUMMY_RESULT_KEY1
327)         ), 'expected known output'

328) 

329)     def test_204b_key_from_command_line(
330)         self, monkeypatch: pytest.MonkeyPatch
331)     ) -> None:

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

333)         with tests.isolated_config(
334)             monkeypatch=monkeypatch,
335)             runner=runner,
336)             config={'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS}},
337)         ):
338)             monkeypatch.setattr(
339)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
340)             )
341)             monkeypatch.setattr(

342)                 dpp.vault.Vault, 'phrase_from_key', tests.phrase_from_key

343)             )

344)             _result = runner.invoke(

345)                 cli.derivepassphrase_vault,

346)                 ['-k', DUMMY_SERVICE],

347)                 input='1\n',

348)                 catch_exceptions=False,
349)             )

350)         result = tests.ReadableResult.parse(_result)
351)         assert result.clean_exit(), 'expected clean exit'
352)         assert _result.stdout_bytes, 'expected program output'
353)         last_line = _result.stdout_bytes.splitlines(True)[-1]
354)         assert (
355)             last_line.rstrip(b'\n') != DUMMY_RESULT_PASSPHRASE
356)         ), 'known false output: phrase-based instead of key-based'
357)         assert (
358)             last_line.rstrip(b'\n') == DUMMY_RESULT_KEY1
359)         ), 'expected known output'

360) 

361)     @tests.skip_if_no_agent
362)     @pytest.mark.parametrize(
363)         'config',
364)         [
365)             pytest.param(
366)                 {
367)                     'global': {'key': DUMMY_KEY1_B64},
368)                     'services': {DUMMY_SERVICE: {}},
369)                 },
370)                 id='global_config',
371)             ),
372)             pytest.param(
373)                 {'services': {DUMMY_SERVICE: {'key': DUMMY_KEY2_B64}}},
374)                 id='service_config',
375)             ),
376)             pytest.param(
377)                 {
378)                     'global': {'key': DUMMY_KEY1_B64},
379)                     'services': {DUMMY_SERVICE: {'key': DUMMY_KEY2_B64}},
380)                 },
381)                 id='full_config',
382)             ),
383)         ],
384)     )
385)     @pytest.mark.parametrize('key_index', [1, 2, 3], ids=lambda i: f'index{i}')
386)     def test_204c_key_override_on_command_line(
387)         self,

388)         monkeypatch: pytest.MonkeyPatch,

389)         config: dict[str, Any],
390)         key_index: int,
391)     ) -> None:
392)         def sign(

393)             _: Any, key: bytes | bytearray, message: bytes | bytearray

394)         ) -> bytes:
395)             del message  # Unused.
396)             for value in tests.SUPPORTED_KEYS.values():
397)                 if value['public_key_data'] == key:
398)                     assert value['expected_signature'] is not None
399)                     return value['expected_signature']
400)             raise AssertionError
401) 
402)         monkeypatch.setattr(

403)             ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys

404)         )

405)         monkeypatch.setattr(ssh_agent.SSHAgentClient, 'sign', sign)

406)         runner = click.testing.CliRunner(mix_stderr=False)
407)         with tests.isolated_config(
408)             monkeypatch=monkeypatch, runner=runner, config=config
409)         ):

410)             _result = runner.invoke(

411)                 cli.derivepassphrase_vault,

412)                 ['-k', DUMMY_SERVICE],

413)                 input=f'{key_index}\n',

414)             )

415)         result = tests.ReadableResult.parse(_result)
416)         assert result.clean_exit(), 'expected clean exit'
417)         assert result.output, 'expected program output'
418)         assert result.stderr, 'expected stderr'
419)         assert (
420)             'Error:' not in result.stderr
421)         ), 'expected no error messages on stderr'

422) 

423)     def test_205_service_phrase_if_key_in_global_config(

424)         self,

425)         monkeypatch: pytest.MonkeyPatch,

426)     ) -> None:
427)         runner = click.testing.CliRunner(mix_stderr=False)
428)         with tests.isolated_config(

429)             monkeypatch=monkeypatch,
430)             runner=runner,

431)             config={
432)                 'global': {'key': DUMMY_KEY1_B64},
433)                 'services': {
434)                     DUMMY_SERVICE: {

435)                         'phrase': DUMMY_PASSPHRASE.rstrip('\n'),

436)                         **DUMMY_CONFIG_SETTINGS,
437)                     }
438)                 },
439)             },

440)         ):

441)             _result = runner.invoke(

442)                 cli.derivepassphrase_vault,
443)                 [DUMMY_SERVICE],
444)                 catch_exceptions=False,

445)             )

446)         result = tests.ReadableResult.parse(_result)
447)         assert result.clean_exit(), 'expected clean exit'
448)         assert _result.stdout_bytes, 'expected program output'
449)         last_line = _result.stdout_bytes.splitlines(True)[-1]
450)         assert (
451)             last_line.rstrip(b'\n') != DUMMY_RESULT_KEY1
452)         ), 'known false output: key-based instead of phrase-based'
453)         assert (
454)             last_line.rstrip(b'\n') == DUMMY_RESULT_PASSPHRASE
455)         ), 'expected known output'

456) 

457)     @pytest.mark.parametrize(
458)         'option',
459)         [
460)             '--lower',
461)             '--upper',
462)             '--number',
463)             '--space',
464)             '--dash',
465)             '--symbol',
466)             '--repeat',
467)             '--length',
468)         ],
469)     )

470)     def test_210_invalid_argument_range(

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

472)     ) -> None:

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

474)         with tests.isolated_config(
475)             monkeypatch=monkeypatch,
476)             runner=runner,
477)             config={'services': {}},
478)         ):
479)             for value in '-42', 'invalid':

480)                 _result = runner.invoke(

481)                     cli.derivepassphrase_vault,

482)                     [option, value, '-p', DUMMY_SERVICE],
483)                     input=DUMMY_PASSPHRASE,
484)                     catch_exceptions=False,
485)                 )

486)                 result = tests.ReadableResult.parse(_result)
487)                 assert result.error_exit(
488)                     error='Error: Invalid value'
489)                 ), 'expected error exit and known error message'

490) 
491)     @pytest.mark.parametrize(
492)         ['options', 'service', 'input', 'check_success'],

493)         [
494)             (o.options, o.needs_service, o.input, o.check_success)
495)             for o in INTERESTING_OPTION_COMBINATIONS
496)             if not o.incompatible
497)         ],

498)     )
499)     def test_211_service_needed(

500)         self,

501)         monkeypatch: pytest.MonkeyPatch,

502)         options: list[str],
503)         service: bool | None,

504)         input: str | None,

505)         check_success: bool,

506)     ) -> None:
507)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
508)         runner = click.testing.CliRunner(mix_stderr=False)

509)         with tests.isolated_config(
510)             monkeypatch=monkeypatch,
511)             runner=runner,
512)             config={'global': {'phrase': 'abc'}, 'services': {}},
513)         ):

514)             _result = runner.invoke(

515)                 cli.derivepassphrase_vault,

516)                 options if service else [*options, DUMMY_SERVICE],
517)                 input=input,
518)                 catch_exceptions=False,
519)             )

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

521)             if service is not None:

522)                 err_msg = (

523)                     ' requires a SERVICE'

524)                     if service

525)                     else ' does not take a SERVICE argument'

526)                 )

527)                 assert result.error_exit(
528)                     error=err_msg
529)                 ), 'expected error exit and known error message'

530)             else:

531)                 assert result.clean_exit(
532)                     empty_stderr=True
533)                 ), 'expected clean exit'

534)         if check_success:

535)             with tests.isolated_config(
536)                 monkeypatch=monkeypatch,
537)                 runner=runner,
538)                 config={'global': {'phrase': 'abc'}, 'services': {}},
539)             ):
540)                 monkeypatch.setattr(
541)                     cli, '_prompt_for_passphrase', tests.auto_prompt
542)                 )

543)                 _result = runner.invoke(

544)                     cli.derivepassphrase_vault,

545)                     [*options, DUMMY_SERVICE] if service else options,
546)                     input=input,
547)                     catch_exceptions=False,

548)                 )

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

551) 
552)     @pytest.mark.parametrize(

553)         ['options', 'service'],

554)         [
555)             (o.options, o.needs_service)
556)             for o in INTERESTING_OPTION_COMBINATIONS
557)             if o.incompatible
558)         ],

559)     )

560)     def test_212_incompatible_options(

561)         self,

562)         monkeypatch: pytest.MonkeyPatch,

563)         options: list[str],
564)         service: bool | None,

565)     ) -> None:
566)         runner = click.testing.CliRunner(mix_stderr=False)

567)         with tests.isolated_config(
568)             monkeypatch=monkeypatch,
569)             runner=runner,
570)             config={'services': {}},
571)         ):

572)             _result = runner.invoke(

573)                 cli.derivepassphrase_vault,

574)                 [*options, DUMMY_SERVICE] if service else options,
575)                 input=DUMMY_PASSPHRASE,
576)                 catch_exceptions=False,
577)             )

578)         result = tests.ReadableResult.parse(_result)
579)         assert result.error_exit(
580)             error='mutually exclusive with '
581)         ), 'expected error exit and known error message'

582) 

583)     def test_213_import_bad_config_not_vault_config(

584)         self,

585)         monkeypatch: pytest.MonkeyPatch,

586)     ) -> None:
587)         runner = click.testing.CliRunner(mix_stderr=False)

588)         with tests.isolated_config(
589)             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
590)         ):

591)             _result = runner.invoke(

592)                 cli.derivepassphrase_vault,

593)                 ['--import', '-'],

594)                 input='null',

595)                 catch_exceptions=False,

596)             )

597)         result = tests.ReadableResult.parse(_result)
598)         assert result.error_exit(
599)             error='Invalid vault config'
600)         ), 'expected error exit and known error message'

601) 

602)     def test_213a_import_bad_config_not_json_data(

603)         self,

604)         monkeypatch: pytest.MonkeyPatch,

605)     ) -> None:
606)         runner = click.testing.CliRunner(mix_stderr=False)

607)         with tests.isolated_config(
608)             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
609)         ):

610)             _result = runner.invoke(

611)                 cli.derivepassphrase_vault,

612)                 ['--import', '-'],

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

614)                 catch_exceptions=False,

615)             )

616)         result = tests.ReadableResult.parse(_result)
617)         assert result.error_exit(
618)             error='cannot decode JSON'
619)         ), 'expected error exit and known error message'

620) 

621)     def test_213b_import_bad_config_not_a_file(

622)         self,

623)         monkeypatch: pytest.MonkeyPatch,

624)     ) -> None:
625)         runner = click.testing.CliRunner(mix_stderr=False)

626)         # `isolated_config` validates the configuration.  So, to pass an
627)         # actual broken configuration, we must open the configuration file
628)         # ourselves afterwards, inside the context.

629)         with tests.isolated_config(
630)             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
631)         ):
632)             with open(
633)                 cli._config_filename(), 'w', encoding='UTF-8'
634)             ) as outfile:

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

636)             dname = os.path.dirname(cli._config_filename())

637)             _result = runner.invoke(

638)                 cli.derivepassphrase_vault,

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

640)                 catch_exceptions=False,

641)             )

642)         result = tests.ReadableResult.parse(_result)
643)         assert result.error_exit(
644)             error=os.strerror(errno.EISDIR)
645)         ), 'expected error exit and known error message'

646) 
647)     def test_214_export_settings_no_stored_settings(

648)         self,

649)         monkeypatch: pytest.MonkeyPatch,

650)     ) -> None:
651)         runner = click.testing.CliRunner(mix_stderr=False)

652)         with tests.isolated_config(
653)             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
654)         ):

655)             with contextlib.suppress(FileNotFoundError):

656)                 os.remove(cli._config_filename())

657)             _result = runner.invoke(

658)                 cli.derivepassphrase_vault,
659)                 ['--export', '-'],
660)                 catch_exceptions=False,

661)             )

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

664) 

665)     def test_214a_export_settings_bad_stored_config(

666)         self,

667)         monkeypatch: pytest.MonkeyPatch,

668)     ) -> None:
669)         runner = click.testing.CliRunner(mix_stderr=False)

670)         with tests.isolated_config(
671)             monkeypatch=monkeypatch, runner=runner, config={}
672)         ):

673)             _result = runner.invoke(

674)                 cli.derivepassphrase_vault,

675)                 ['--export', '-'],

676)                 input='null',

677)                 catch_exceptions=False,

678)             )

679)         result = tests.ReadableResult.parse(_result)
680)         assert result.error_exit(
681)             error='Cannot load config'
682)         ), 'expected error exit and known error message'

683) 

684)     def test_214b_export_settings_not_a_file(

685)         self,

686)         monkeypatch: pytest.MonkeyPatch,

687)     ) -> None:
688)         runner = click.testing.CliRunner(mix_stderr=False)

689)         with tests.isolated_config(
690)             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
691)         ):

692)             with contextlib.suppress(FileNotFoundError):

693)                 os.remove(cli._config_filename())
694)             os.makedirs(cli._config_filename())

695)             _result = runner.invoke(

696)                 cli.derivepassphrase_vault,

697)                 ['--export', '-'],

698)                 input='null',

699)                 catch_exceptions=False,

700)             )

701)         result = tests.ReadableResult.parse(_result)
702)         assert result.error_exit(
703)             error='Cannot load config'
704)         ), 'expected error exit and known error message'

705) 

706)     def test_214c_export_settings_target_not_a_file(

707)         self,

708)         monkeypatch: pytest.MonkeyPatch,

709)     ) -> None:
710)         runner = click.testing.CliRunner(mix_stderr=False)

711)         with tests.isolated_config(
712)             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
713)         ):

714)             dname = os.path.dirname(cli._config_filename())

715)             _result = runner.invoke(

716)                 cli.derivepassphrase_vault,

717)                 ['--export', os.fsdecode(dname)],

718)                 input='null',

719)                 catch_exceptions=False,

720)             )

721)         result = tests.ReadableResult.parse(_result)
722)         assert result.error_exit(
723)             error='Cannot store config'
724)         ), 'expected error exit and known error message'

725) 

726)     def test_214d_export_settings_settings_directory_not_a_directory(
727)         self,

728)         monkeypatch: pytest.MonkeyPatch,

729)     ) -> None:
730)         runner = click.testing.CliRunner(mix_stderr=False)
731)         with tests.isolated_config(
732)             monkeypatch=monkeypatch, runner=runner, config={'services': {}}
733)         ):
734)             with contextlib.suppress(FileNotFoundError):
735)                 shutil.rmtree('.derivepassphrase')
736)             with open('.derivepassphrase', 'w', encoding='UTF-8') as outfile:
737)                 print('Obstruction!!', file=outfile)

738)             _result = runner.invoke(

739)                 cli.derivepassphrase_vault,

740)                 ['--export', '-'],

741)                 input='null',

742)                 catch_exceptions=False,
743)             )

744)         result = tests.ReadableResult.parse(_result)
745)         assert result.error_exit(
746)             error='Cannot load config'
747)         ), 'expected error exit and known error message'

748) 

749)     def test_220_edit_notes_successfully(
750)         self, monkeypatch: pytest.MonkeyPatch
751)     ) -> None:

752)         edit_result = """

753) 
754) # - - - - - >8 - - - - - >8 - - - - - >8 - - - - - >8 - - - - -
755) contents go here

756) """

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

758)         with tests.isolated_config(
759)             monkeypatch=monkeypatch,
760)             runner=runner,
761)             config={'global': {'phrase': 'abc'}, 'services': {}},
762)         ):
763)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: edit_result)  # noqa: ARG005

764)             _result = runner.invoke(

765)                 cli.derivepassphrase_vault,
766)                 ['--notes', 'sv'],
767)                 catch_exceptions=False,

768)             )

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

771)             with open(cli._config_filename(), encoding='UTF-8') as infile:

772)                 config = json.load(infile)

773)             assert config == {
774)                 'global': {'phrase': 'abc'},
775)                 'services': {'sv': {'notes': 'contents go here'}},
776)             }

777) 

778)     def test_221_edit_notes_noop(
779)         self, monkeypatch: pytest.MonkeyPatch
780)     ) -> None:

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

782)         with tests.isolated_config(
783)             monkeypatch=monkeypatch,
784)             runner=runner,
785)             config={'global': {'phrase': 'abc'}, 'services': {}},
786)         ):
787)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: None)  # noqa: ARG005

788)             _result = runner.invoke(

789)                 cli.derivepassphrase_vault,
790)                 ['--notes', 'sv'],
791)                 catch_exceptions=False,

792)             )

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

795)             with open(cli._config_filename(), encoding='UTF-8') as infile:

796)                 config = json.load(infile)
797)             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
798) 

799)     def test_222_edit_notes_marker_removed(
800)         self, monkeypatch: pytest.MonkeyPatch
801)     ) -> None:

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

803)         with tests.isolated_config(
804)             monkeypatch=monkeypatch,
805)             runner=runner,
806)             config={'global': {'phrase': 'abc'}, 'services': {}},
807)         ):
808)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: 'long\ntext')  # noqa: ARG005

809)             _result = runner.invoke(

810)                 cli.derivepassphrase_vault,
811)                 ['--notes', 'sv'],
812)                 catch_exceptions=False,

813)             )

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

816)             with open(cli._config_filename(), encoding='UTF-8') as infile:

817)                 config = json.load(infile)

818)             assert config == {
819)                 'global': {'phrase': 'abc'},
820)                 'services': {'sv': {'notes': 'long\ntext'}},
821)             }

822) 

823)     def test_223_edit_notes_abort(
824)         self, monkeypatch: pytest.MonkeyPatch
825)     ) -> None:

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

827)         with tests.isolated_config(
828)             monkeypatch=monkeypatch,
829)             runner=runner,
830)             config={'global': {'phrase': 'abc'}, 'services': {}},
831)         ):
832)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: '\n\n')  # noqa: ARG005

833)             _result = runner.invoke(

834)                 cli.derivepassphrase_vault,
835)                 ['--notes', 'sv'],
836)                 catch_exceptions=False,

837)             )

838)             result = tests.ReadableResult.parse(_result)
839)             assert result.error_exit(
840)                 error='user aborted request'
841)             ), 'expected known error message'

842)             with open(cli._config_filename(), encoding='UTF-8') as infile:

843)                 config = json.load(infile)
844)             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
845) 

846)     @pytest.mark.parametrize(
847)         ['command_line', 'input', 'result_config'],
848)         [
849)             (
850)                 ['--phrase'],

851)                 'my passphrase\n',

852)                 {'global': {'phrase': 'my passphrase'}, 'services': {}},
853)             ),
854)             (
855)                 ['--key'],

856)                 '1\n',

857)                 {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
858)             ),
859)             (
860)                 ['--phrase', 'sv'],

861)                 'my passphrase\n',

862)                 {
863)                     'global': {'phrase': 'abc'},
864)                     'services': {'sv': {'phrase': 'my passphrase'}},
865)                 },
866)             ),
867)             (
868)                 ['--key', 'sv'],

869)                 '1\n',

870)                 {
871)                     'global': {'phrase': 'abc'},
872)                     'services': {'sv': {'key': DUMMY_KEY1_B64}},
873)                 },
874)             ),
875)             (
876)                 ['--key', '--length', '15', 'sv'],

877)                 '1\n',

878)                 {
879)                     'global': {'phrase': 'abc'},
880)                     'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
881)                 },
882)             ),
883)         ],
884)     )

885)     def test_224_store_config_good(

886)         self,

887)         monkeypatch: pytest.MonkeyPatch,

888)         command_line: list[str],

889)         input: str,

890)         result_config: Any,
891)     ) -> None:
892)         runner = click.testing.CliRunner(mix_stderr=False)

893)         with tests.isolated_config(
894)             monkeypatch=monkeypatch,
895)             runner=runner,
896)             config={'global': {'phrase': 'abc'}, 'services': {}},
897)         ):
898)             monkeypatch.setattr(
899)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
900)             )

901)             _result = runner.invoke(

902)                 cli.derivepassphrase_vault,

903)                 ['--config', *command_line],
904)                 catch_exceptions=False,
905)                 input=input,
906)             )

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

909)             with open(cli._config_filename(), encoding='UTF-8') as infile:

910)                 config = json.load(infile)

911)             assert (
912)                 config == result_config
913)             ), 'stored config does not match expectation'

914) 

915)     @pytest.mark.parametrize(
916)         ['command_line', 'input', 'err_text'],
917)         [

918)             ([], '', 'Cannot update global settings without actual settings'),

919)             (
920)                 ['sv'],

921)                 '',
922)                 'Cannot update service settings without actual settings',

923)             ),

924)             (['--phrase', 'sv'], '', 'No passphrase given'),
925)             (['--key'], '', 'No valid SSH key selected'),

926)         ],
927)     )

928)     def test_225_store_config_fail(

929)         self,

930)         monkeypatch: pytest.MonkeyPatch,

931)         command_line: list[str],

932)         input: str,
933)         err_text: str,

934)     ) -> None:
935)         runner = click.testing.CliRunner(mix_stderr=False)

936)         with tests.isolated_config(
937)             monkeypatch=monkeypatch,
938)             runner=runner,
939)             config={'global': {'phrase': 'abc'}, 'services': {}},
940)         ):
941)             monkeypatch.setattr(
942)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
943)             )

944)             _result = runner.invoke(

945)                 cli.derivepassphrase_vault,

946)                 ['--config', *command_line],
947)                 catch_exceptions=False,
948)                 input=input,
949)             )

950)         result = tests.ReadableResult.parse(_result)
951)         assert result.error_exit(
952)             error=err_text
953)         ), 'expected error exit and known error message'

954) 
955)     def test_225a_store_config_fail_manual_no_ssh_key_selection(

956)         self,

957)         monkeypatch: pytest.MonkeyPatch,

958)     ) -> None:
959)         runner = click.testing.CliRunner(mix_stderr=False)

960)         with tests.isolated_config(
961)             monkeypatch=monkeypatch,
962)             runner=runner,
963)             config={'global': {'phrase': 'abc'}, 'services': {}},
964)         ):

965)             custom_error = 'custom error message'

966) 

967)             def raiser() -> None:

968)                 raise RuntimeError(custom_error)

969) 

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

971)             _result = runner.invoke(

972)                 cli.derivepassphrase_vault,

973)                 ['--key', '--config'],
974)                 catch_exceptions=False,
975)             )

976)         result = tests.ReadableResult.parse(_result)
977)         assert result.error_exit(
978)             error=custom_error
979)         ), 'expected error exit and known error message'

980) 

981)     def test_225b_store_config_fail_manual_no_ssh_agent(
982)         self,

983)         monkeypatch: pytest.MonkeyPatch,

984)     ) -> None:
985)         runner = click.testing.CliRunner(mix_stderr=False)
986)         with tests.isolated_config(
987)             monkeypatch=monkeypatch,
988)             runner=runner,
989)             config={'global': {'phrase': 'abc'}, 'services': {}},
990)         ):
991)             monkeypatch.delenv('SSH_AUTH_SOCK', raising=False)

992)             _result = runner.invoke(

993)                 cli.derivepassphrase_vault,

994)                 ['--key', '--config'],
995)                 catch_exceptions=False,
996)             )

997)         result = tests.ReadableResult.parse(_result)
998)         assert result.error_exit(
999)             error='Cannot find running SSH agent'
1000)         ), 'expected error exit and known error message'

1001) 
1002)     def test_225c_store_config_fail_manual_bad_ssh_agent_connection(
1003)         self,

1004)         monkeypatch: pytest.MonkeyPatch,

1005)     ) -> None:
1006)         runner = click.testing.CliRunner(mix_stderr=False)
1007)         with tests.isolated_config(
1008)             monkeypatch=monkeypatch,
1009)             runner=runner,
1010)             config={'global': {'phrase': 'abc'}, 'services': {}},
1011)         ):
1012)             monkeypatch.setenv('SSH_AUTH_SOCK', os.getcwd())

1013)             _result = runner.invoke(

1014)                 cli.derivepassphrase_vault,

1015)                 ['--key', '--config'],
1016)                 catch_exceptions=False,
1017)             )

1018)         result = tests.ReadableResult.parse(_result)
1019)         assert result.error_exit(
1020)             error='Cannot connect to SSH agent'
1021)         ), 'expected error exit and known error message'

1022) 
1023)     @pytest.mark.parametrize('try_race_free_implementation', [True, False])
1024)     def test_225d_store_config_fail_manual_read_only_file(
1025)         self,

1026)         monkeypatch: pytest.MonkeyPatch,

1027)         try_race_free_implementation: bool,
1028)     ) -> None:
1029)         runner = click.testing.CliRunner(mix_stderr=False)
1030)         with tests.isolated_config(
1031)             monkeypatch=monkeypatch,
1032)             runner=runner,
1033)             config={'global': {'phrase': 'abc'}, 'services': {}},
1034)         ):
1035)             tests.make_file_readonly(
1036)                 cli._config_filename(),
1037)                 try_race_free_implementation=try_race_free_implementation,
1038)             )

1039)             _result = runner.invoke(

1040)                 cli.derivepassphrase_vault,

1041)                 ['--config', '--length=15', DUMMY_SERVICE],
1042)                 catch_exceptions=False,
1043)             )

1044)         result = tests.ReadableResult.parse(_result)
1045)         assert result.error_exit(
1046)             error='Cannot store config'
1047)         ), 'expected error exit and known error message'

1048) 
1049)     def test_225e_store_config_fail_manual_custom_error(
1050)         self,

1051)         monkeypatch: pytest.MonkeyPatch,

1052)     ) -> None:
1053)         runner = click.testing.CliRunner(mix_stderr=False)
1054)         with tests.isolated_config(
1055)             monkeypatch=monkeypatch,
1056)             runner=runner,
1057)             config={'global': {'phrase': 'abc'}, 'services': {}},
1058)         ):
1059)             custom_error = 'custom error message'
1060) 
1061)             def raiser(config: Any) -> None:
1062)                 del config
1063)                 raise RuntimeError(custom_error)
1064) 
1065)             monkeypatch.setattr(cli, '_save_config', raiser)

1066)             _result = runner.invoke(

1067)                 cli.derivepassphrase_vault,

1068)                 ['--config', '--length=15', DUMMY_SERVICE],
1069)                 catch_exceptions=False,
1070)             )

1071)         result = tests.ReadableResult.parse(_result)
1072)         assert result.error_exit(
1073)             error=custom_error
1074)         ), 'expected error exit and known error message'

1075) 

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

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

1078)         with tests.isolated_config(
1079)             monkeypatch=monkeypatch,
1080)             runner=runner,
1081)             config={'services': {}},
1082)         ):

1083)             _result = runner.invoke(

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

1085)             )

1086)         result = tests.ReadableResult.parse(_result)
1087)         assert result.error_exit(
1088)             error='SERVICE is required'
1089)         ), 'expected error exit and known error message'

1090) 

1091)     def test_226a_no_passphrase_or_key(
1092)         self, monkeypatch: pytest.MonkeyPatch
1093)     ) -> None:

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

1095)         with tests.isolated_config(
1096)             monkeypatch=monkeypatch,
1097)             runner=runner,
1098)             config={'services': {}},
1099)         ):

1100)             _result = runner.invoke(

1101)                 cli.derivepassphrase_vault,
1102)                 [DUMMY_SERVICE],
1103)                 catch_exceptions=False,

1104)             )

1105)         result = tests.ReadableResult.parse(_result)
1106)         assert result.error_exit(
1107)             error='No passphrase or key given'
1108)         ), 'expected error exit and known error message'

1109) 

1110)     def test_230_config_directory_nonexistant(
1111)         self, monkeypatch: pytest.MonkeyPatch
1112)     ) -> None:

1113)         """the-13th-letter/derivepassphrase#6"""
1114)         runner = click.testing.CliRunner(mix_stderr=False)
1115)         with tests.isolated_config(
1116)             monkeypatch=monkeypatch,
1117)             runner=runner,
1118)             config={'services': {}},
1119)         ):
1120)             os.remove('.derivepassphrase/settings.json')
1121)             os.rmdir('.derivepassphrase')
1122)             os_makedirs_called = False
1123)             real_os_makedirs = os.makedirs
1124) 
1125)             def makedirs(*args: Any, **kwargs: Any) -> Any:
1126)                 nonlocal os_makedirs_called
1127)                 os_makedirs_called = True
1128)                 return real_os_makedirs(*args, **kwargs)
1129) 
1130)             monkeypatch.setattr(os, 'makedirs', makedirs)

1131)             _result = runner.invoke(

1132)                 cli.derivepassphrase_vault,

1133)                 ['--config', '-p'],
1134)                 catch_exceptions=False,
1135)                 input='abc\n',
1136)             )

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

1139)             assert (

1140)                 result.stderr == 'Passphrase:'

1141)             ), 'program unexpectedly failed?!'
1142)             assert os_makedirs_called, 'os.makedirs has not been called?!'
1143)             with open(cli._config_filename(), encoding='UTF-8') as infile:
1144)                 config_readback = json.load(infile)
1145)             assert config_readback == {
1146)                 'global': {'phrase': 'abc'},
1147)                 'services': {},
1148)             }, 'config mismatch'
1149) 

1150)     def test_230a_config_directory_not_a_file(
1151)         self, monkeypatch: pytest.MonkeyPatch
1152)     ) -> None:

1153)         """the-13th-letter/derivepassphrase#6"""
1154)         runner = click.testing.CliRunner(mix_stderr=False)
1155)         with tests.isolated_config(
1156)             monkeypatch=monkeypatch,
1157)             runner=runner,
1158)             config={'services': {}},
1159)         ):
1160)             _save_config = cli._save_config
1161) 
1162)             def obstruct_config_saving(*args: Any, **kwargs: Any) -> Any:
1163)                 with contextlib.suppress(FileNotFoundError):
1164)                     shutil.rmtree('.derivepassphrase')
1165)                 with open(
1166)                     '.derivepassphrase', 'w', encoding='UTF-8'
1167)                 ) as outfile:
1168)                     print('Obstruction!!', file=outfile)
1169)                 monkeypatch.setattr(cli, '_save_config', _save_config)
1170)                 return _save_config(*args, **kwargs)
1171) 
1172)             monkeypatch.setattr(cli, '_save_config', obstruct_config_saving)

1173)             _result = runner.invoke(

1174)                 cli.derivepassphrase_vault,

1175)                 ['--config', '-p'],
1176)                 catch_exceptions=False,
1177)                 input='abc\n',
1178)             )

1179)             result = tests.ReadableResult.parse(_result)
1180)             assert result.error_exit(
1181)                 error='Cannot store config'
1182)             ), 'expected error exit and known error message'

1183) 

1184)     def test_230b_store_config_custom_error(
1185)         self, monkeypatch: pytest.MonkeyPatch
1186)     ) -> None:

1187)         runner = click.testing.CliRunner(mix_stderr=False)
1188)         with tests.isolated_config(
1189)             monkeypatch=monkeypatch,
1190)             runner=runner,
1191)             config={'services': {}},
1192)         ):
1193)             _save_config = cli._save_config
1194) 
1195)             def obstruct_config_saving(*args: Any, **kwargs: Any) -> Any:
1196)                 with contextlib.suppress(FileNotFoundError):
1197)                     shutil.rmtree('.derivepassphrase')
1198)                 with open(
1199)                     '.derivepassphrase', 'w', encoding='UTF-8'
1200)                 ) as outfile:
1201)                     print('Obstruction!!', file=outfile)
1202)                 monkeypatch.setattr(cli, '_save_config', _save_config)
1203)                 return _save_config(*args, **kwargs)
1204) 
1205)             monkeypatch.setattr(cli, '_save_config', obstruct_config_saving)

1206)             _result = runner.invoke(

1207)                 cli.derivepassphrase_vault,

1208)                 ['--config', '-p'],
1209)                 catch_exceptions=False,
1210)                 input='abc\n',
1211)             )

1212)             result = tests.ReadableResult.parse(_result)
1213)             assert result.error_exit(
1214)                 error='Cannot store config'
1215)             ), 'expected error exit and known error message'

1216) 

1217)     @pytest.mark.parametrize(

1218)         ['command_line', 'input', 'warning_message'],

1219)         [
1220)             pytest.param(
1221)                 ['--import', '-'],
1222)                 json.dumps({
1223)                     'global': {'phrase': 'Du\u0308sseldorf'},
1224)                     'services': {},
1225)                 }),
1226)                 'the global passphrase is not NFC-normalized',
1227)                 id='global-NFC',
1228)             ),
1229)             pytest.param(
1230)                 ['--import', '-'],
1231)                 json.dumps({
1232)                     'services': {
1233)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1234)                         'weird entry name': {'phrase': 'Du\u0308sseldorf'},
1235)                     }
1236)                 }),
1237)                 (
1238)                     "the services.'weird entry name' passphrase "
1239)                     'is not NFC-normalized'
1240)                 ),
1241)                 id='service-weird-name-NFC',
1242)             ),
1243)             pytest.param(
1244)                 ['--config', '-p', DUMMY_SERVICE],
1245)                 'Du\u0308sseldorf',
1246)                 (
1247)                     f'the services.{DUMMY_SERVICE} passphrase '
1248)                     f'is not NFC-normalized'
1249)                 ),
1250)                 id='config-NFC',
1251)             ),
1252)             pytest.param(
1253)                 ['-p', DUMMY_SERVICE],
1254)                 'Du\u0308sseldorf',
1255)                 'the interactive passphrase is not NFC-normalized',
1256)                 id='direct-input-NFC',
1257)             ),
1258)             pytest.param(
1259)                 ['--import', '-'],
1260)                 json.dumps({
1261)                     'global': {
1262)                         'unicode_normalization_form': 'NFD',
1263)                         'phrase': 'D\u00fcsseldorf',
1264)                     },
1265)                     'services': {},
1266)                 }),
1267)                 'the global passphrase is not NFD-normalized',
1268)                 id='global-NFD',
1269)             ),
1270)             pytest.param(
1271)                 ['--import', '-'],
1272)                 json.dumps({
1273)                     'global': {
1274)                         'unicode_normalization_form': 'NFD',
1275)                     },
1276)                     'services': {
1277)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1278)                         'weird entry name': {'phrase': 'D\u00fcsseldorf'},

1279)                     },

1280)                 }),
1281)                 (
1282)                     "the services.'weird entry name' passphrase "
1283)                     'is not NFD-normalized'
1284)                 ),
1285)                 id='service-weird-name-NFD',
1286)             ),
1287)         ],
1288)     )
1289)     def test_300_unicode_normalization_form_warning(
1290)         self,

1291)         monkeypatch: pytest.MonkeyPatch,

1292)         command_line: list[str],
1293)         input: str | None,

1294)         warning_message: str,

1295)     ) -> None:
1296)         runner = click.testing.CliRunner(mix_stderr=False)
1297)         with tests.isolated_config(
1298)             monkeypatch=monkeypatch,
1299)             runner=runner,
1300)             config={'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}},
1301)         ):

1302)             _result = runner.invoke(

1303)                 cli.derivepassphrase_vault,

1304)                 command_line,
1305)                 catch_exceptions=False,
1306)                 input=input,
1307)             )

1308)         result = tests.ReadableResult.parse(_result)
1309)         assert result.clean_exit(), 'expected clean exit'
1310)         assert (
1311)             warning_message in result.stderr
1312)         ), 'expected known warning message in stderr'

1313) 

1314) 

1315) class TestCLIUtils:

1316)     def test_100_save_bad_config(
1317)         self, monkeypatch: pytest.MonkeyPatch
1318)     ) -> None:

1319)         runner = click.testing.CliRunner()

1320)         with (

1321)             tests.isolated_config(
1322)                 monkeypatch=monkeypatch, runner=runner, config={}
1323)             ),
1324)             pytest.raises(ValueError, match='Invalid vault config'),

1325)         ):

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

1327) 

1328)     def test_101_prompt_for_selection_multiple(self) -> None:

1329)         @click.command()
1330)         @click.option('--heading', default='Our menu:')
1331)         @click.argument('items', nargs=-1)

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

1333)             # from https://montypython.fandom.com/wiki/Spam#The_menu
1334)             items = items or [
1335)                 'Egg and bacon',
1336)                 'Egg, sausage and bacon',
1337)                 'Egg and spam',
1338)                 'Egg, bacon and spam',
1339)                 'Egg, bacon, sausage and spam',
1340)                 'Spam, bacon, sausage and spam',
1341)                 'Spam, egg, spam, spam, bacon and spam',
1342)                 'Spam, spam, spam, egg and spam',

1343)                 (
1344)                     'Spam, spam, spam, spam, spam, spam, baked beans, '
1345)                     'spam, spam, spam and spam'
1346)                 ),
1347)                 (
1348)                     'Lobster thermidor aux crevettes with a mornay sauce '
1349)                     'garnished with truffle paté, brandy '
1350)                     'and a fried egg on top and spam'
1351)                 ),

1352)             ]
1353)             index = cli._prompt_for_selection(items, heading=heading)
1354)             click.echo('A fine choice: ', nl=False)
1355)             click.echo(items[index])
1356)             click.echo('(Note: Vikings strictly optional.)')

1357) 

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

1359)         _result = runner.invoke(driver, [], input='9')
1360)         result = tests.ReadableResult.parse(_result)
1361)         assert result.clean_exit(
1362)             output="""\

1363) Our menu:
1364) [1] Egg and bacon
1365) [2] Egg, sausage and bacon
1366) [3] Egg and spam
1367) [4] Egg, bacon and spam
1368) [5] Egg, bacon, sausage and spam
1369) [6] Spam, bacon, sausage and spam
1370) [7] Spam, egg, spam, spam, bacon and spam
1371) [8] Spam, spam, spam, egg and spam
1372) [9] Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
1373) [10] Lobster thermidor aux crevettes with a mornay sauce garnished with truffle paté, brandy and a fried egg on top and spam
1374) Your selection? (1-10, leave empty to abort): 9
1375) A fine choice: Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
1376) (Note: Vikings strictly optional.)

1377) """  # noqa: E501

1378)         ), 'expected clean exit'
1379)         _result = runner.invoke(

1380)             driver, ['--heading='], input='', catch_exceptions=True
1381)         )

1382)         result = tests.ReadableResult.parse(_result)
1383)         assert result.error_exit(
1384)             error=IndexError
1385)         ), 'expected error exit and known error type'

1386)         assert (

1387)             result.output

1388)             == """\

1389) [1] Egg and bacon
1390) [2] Egg, sausage and bacon
1391) [3] Egg and spam
1392) [4] Egg, bacon and spam
1393) [5] Egg, bacon, sausage and spam
1394) [6] Spam, bacon, sausage and spam
1395) [7] Spam, egg, spam, spam, bacon and spam
1396) [8] Spam, spam, spam, egg and spam
1397) [9] Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
1398) [10] Lobster thermidor aux crevettes with a mornay sauce garnished with truffle paté, brandy and a fried egg on top and spam

1399) Your selection? (1-10, leave empty to abort):\x20
1400) """  # noqa: E501

1401)         ), 'expected known output'

1402) 

1403)     def test_102_prompt_for_selection_single(self) -> None:

1404)         @click.command()
1405)         @click.option('--item', default='baked beans')
1406)         @click.argument('prompt')

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

1408)             try:

1409)                 cli._prompt_for_selection(
1410)                     [item], heading='', single_choice_prompt=prompt
1411)                 )

1412)             except IndexError:

1413)                 click.echo('Boo.')

1414)                 raise

1415)             else:
1416)                 click.echo('Great!')

1417) 

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

1419)         _result = runner.invoke(

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

1422)         result = tests.ReadableResult.parse(_result)
1423)         assert result.clean_exit(
1424)             output="""\

1425) [1] baked beans
1426) Will replace with spam. Confirm, y/n? y
1427) Great!

1428) """

1429)         ), 'expected clean exit'
1430)         _result = runner.invoke(

1431)             driver,
1432)             ['Will replace with spam, okay? ' '(Please say "y" or "n".)'],
1433)             input='',
1434)         )

1435)         result = tests.ReadableResult.parse(_result)
1436)         assert result.error_exit(
1437)             error=IndexError
1438)         ), 'expected error exit and known error type'

1439)         assert (

1440)             result.output

1441)             == """\

1442) [1] baked beans

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

1444) Boo.

1445) """

1446)         ), 'expected known output'

1447) 

1448)     def test_103_prompt_for_passphrase(
1449)         self, monkeypatch: pytest.MonkeyPatch
1450)     ) -> None:

1451)         monkeypatch.setattr(
1452)             click,
1453)             'prompt',
1454)             lambda *a, **kw: json.dumps({'args': a, 'kwargs': kw}),
1455)         )

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

1457)         err_msg = 'missing arguments to passphrase prompt'
1458)         assert 'args' in res, err_msg
1459)         assert 'kwargs' in res, err_msg
1460)         assert res['args'][:1] == ['Passphrase'], err_msg
1461)         assert res['kwargs'].get('default') == '', err_msg
1462)         assert not res['kwargs'].get('show_default', True), err_msg
1463)         assert res['kwargs'].get('err'), err_msg
1464)         assert res['kwargs'].get('hide_input'), err_msg

1465) 

1466)     @pytest.mark.parametrize(
1467)         ['command_line', 'config', 'result_config'],
1468)         [
1469)             (
1470)                 ['--delete-globals'],
1471)                 {'global': {'phrase': 'abc'}, 'services': {}},
1472)                 {'services': {}},
1473)             ),
1474)             (
1475)                 ['--delete', DUMMY_SERVICE],
1476)                 {
1477)                     'global': {'phrase': 'abc'},
1478)                     'services': {DUMMY_SERVICE: {'notes': '...'}},
1479)                 },
1480)                 {'global': {'phrase': 'abc'}, 'services': {}},
1481)             ),
1482)             (
1483)                 ['--clear'],
1484)                 {
1485)                     'global': {'phrase': 'abc'},
1486)                     'services': {DUMMY_SERVICE: {'notes': '...'}},
1487)                 },
1488)                 {'services': {}},
1489)             ),
1490)         ],
1491)     )

1492)     def test_203_repeated_config_deletion(

1493)         self,

1494)         monkeypatch: pytest.MonkeyPatch,

1495)         command_line: list[str],

1496)         config: _types.VaultConfig,
1497)         result_config: _types.VaultConfig,

1498)     ) -> None:
1499)         runner = click.testing.CliRunner(mix_stderr=False)
1500)         for start_config in [config, result_config]:

1501)             with tests.isolated_config(
1502)                 monkeypatch=monkeypatch, runner=runner, config=start_config
1503)             ):

1504)                 _result = runner.invoke(

1505)                     cli.derivepassphrase_vault,
1506)                     command_line,
1507)                     catch_exceptions=False,

1508)                 )

1509)                 result = tests.ReadableResult.parse(_result)
1510)                 assert result.clean_exit(
1511)                     empty_stderr=True
1512)                 ), 'expected clean exit'

1513)                 with open(cli._config_filename(), encoding='UTF-8') as infile:

1514)                     config_readback = json.load(infile)
1515)                 assert config_readback == result_config
1516) 
1517)     def test_204_phrase_from_key_manually(self) -> None:
1518)         assert (

1519)             dpp.vault.Vault(

1520)                 phrase=DUMMY_PHRASE_FROM_KEY1, **DUMMY_CONFIG_SETTINGS
1521)             ).generate(DUMMY_SERVICE)
1522)             == DUMMY_RESULT_KEY1

1523)         )
1524) 

1525)     @pytest.mark.parametrize(
1526)         ['vfunc', 'input'],
1527)         [
1528)             (cli._validate_occurrence_constraint, 20),
1529)             (cli._validate_length, 20),
1530)         ],
1531)     )

1532)     def test_210a_validate_constraints_manually(
1533)         self,
1534)         vfunc: Callable[[click.Context, click.Parameter, Any], int | None],
1535)         input: int,
1536)     ) -> None:

1537)         ctx = cli.derivepassphrase_vault.make_context(cli.PROG_NAME, [])
1538)         param = cli.derivepassphrase_vault.params[0]

1539)         assert vfunc(ctx, param, input) == input
1540) 
1541)     @tests.skip_if_no_agent

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

1543)     def test_227_get_suitable_ssh_keys(

1544)         self,

1545)         monkeypatch: pytest.MonkeyPatch,

1546)         conn_hint: str,

1547)     ) -> None:

1548)         monkeypatch.setattr(

1549)             ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys

1550)         )

1551)         hint: ssh_agent.SSHAgentClient | socket.socket | None

1552)         match conn_hint:
1553)             case 'client':

1554)                 hint = ssh_agent.SSHAgentClient()

1555)             case 'socket':
1556)                 hint = socket.socket(family=socket.AF_UNIX)
1557)                 hint.connect(os.environ['SSH_AUTH_SOCK'])
1558)             case _:
1559)                 assert conn_hint == 'none'
1560)                 hint = None
1561)         exception: Exception | None = None
1562)         try:
1563)             list(cli._get_suitable_ssh_keys(hint))
1564)         except RuntimeError:  # pragma: no cover
1565)             pass

1566)         except Exception as e:  # noqa: BLE001 # pragma: no cover

1567)             exception = e
1568)         finally:

1569)             assert exception is None, 'exception querying suitable SSH keys'