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 copy

9) import errno

10) import json
11) import os

12) import shutil

13) import socket

14) from typing import TYPE_CHECKING

15) 

16) import click.testing

17) import hypothesis

18) import pytest

19) from hypothesis import strategies

20) from typing_extensions import NamedTuple
21) 

22) import tests

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

24) 
25) if TYPE_CHECKING:
26)     from collections.abc import Callable
27) 
28)     from typing_extensions import Any

29) 

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

41) DUMMY_KEY2_B64 = tests.DUMMY_KEY2_B64
42) DUMMY_KEY3 = tests.DUMMY_KEY3
43) DUMMY_KEY3_B64 = tests.DUMMY_KEY3_B64

44) 

45) TEST_CONFIGS = tests.TEST_CONFIGS
46) 

47) 
48) class IncompatibleConfiguration(NamedTuple):
49)     other_options: list[tuple[str, ...]]
50)     needs_service: bool | None

51)     input: str | None

52) 

53) 

54) class SingleConfiguration(NamedTuple):
55)     needs_service: bool | None

56)     input: str | None

57)     check_success: bool
58) 

59) 

60) class OptionCombination(NamedTuple):
61)     options: list[str]
62)     incompatible: bool
63)     needs_service: bool | None

64)     input: str | None

65)     check_success: bool
66) 

67) 

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

69)     ('--phrase',),
70)     ('--key',),
71)     ('--length', '20'),
72)     ('--repeat', '20'),
73)     ('--lower', '1'),
74)     ('--upper', '1'),
75)     ('--number', '1'),
76)     ('--space', '1'),
77)     ('--dash', '1'),
78)     ('--symbol', '1'),

79) ]
80) CONFIGURATION_OPTIONS: list[tuple[str, ...]] = [

81)     ('--notes',),
82)     ('--config',),
83)     ('--delete',),
84)     ('--delete-globals',),
85)     ('--clear',),

86) ]
87) CONFIGURATION_COMMANDS: list[tuple[str, ...]] = [

88)     ('--notes',),
89)     ('--delete',),
90)     ('--delete-globals',),
91)     ('--clear',),

92) ]

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

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

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

97)         True,
98)         DUMMY_PASSPHRASE,
99)     ),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

128)         [
129)             ('--config',),
130)             ('--delete',),
131)             ('--delete-globals',),
132)             ('--clear',),
133)             *STORAGE_OPTIONS,
134)         ],
135)         True,
136)         None,
137)     ),

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

139)         [('--delete',), ('--delete-globals',), ('--clear',), *STORAGE_OPTIONS],
140)         None,
141)         DUMMY_PASSPHRASE,
142)     ),

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

144)         [('--delete-globals',), ('--clear',), *STORAGE_OPTIONS], True, None
145)     ),

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

147)         [('--clear',), *STORAGE_OPTIONS], False, None
148)     ),

149)     ('--clear',): IncompatibleConfiguration(STORAGE_OPTIONS, False, None),
150)     ('--export', '-'): IncompatibleConfiguration(

151)         [('--import', '-')], False, None
152)     ),
153)     ('--import', '-'): IncompatibleConfiguration([], False, None),

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

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

173) }
174) INTERESTING_OPTION_COMBINATIONS: list[OptionCombination] = []

175) config: IncompatibleConfiguration | SingleConfiguration

176) for opt, config in INCOMPATIBLE.items():
177)     for opt2 in config.other_options:
178)         INTERESTING_OPTION_COMBINATIONS.extend([

179)             OptionCombination(
180)                 options=list(opt + opt2),
181)                 incompatible=True,
182)                 needs_service=config.needs_service,
183)                 input=config.input,
184)                 check_success=False,
185)             ),
186)             OptionCombination(
187)                 options=list(opt2 + opt),
188)                 incompatible=True,
189)                 needs_service=config.needs_service,
190)                 input=config.input,
191)                 check_success=False,
192)             ),

193)         ])
194) for opt, config in SINGLES.items():
195)     INTERESTING_OPTION_COMBINATIONS.append(

196)         OptionCombination(
197)             options=list(opt),
198)             incompatible=False,
199)             needs_service=config.needs_service,
200)             input=config.input,
201)             check_success=config.check_success,
202)         )
203)     )

204) 
205) 

206) class TestCLI:

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

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

209)         with tests.isolated_config(
210)             monkeypatch=monkeypatch,
211)             runner=runner,
212)         ):

213)             _result = runner.invoke(

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

215)             )

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

223) 

224)     @pytest.mark.parametrize(
225)         'charset_name', ['lower', 'upper', 'number', 'space', 'dash', 'symbol']
226)     )

227)     def test_201_disable_character_set(

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

229)     ) -> None:
230)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
231)         option = f'--{charset_name}'

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

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

234)         with tests.isolated_config(
235)             monkeypatch=monkeypatch,
236)             runner=runner,
237)         ):

238)             _result = runner.invoke(

239)                 cli.derivepassphrase_vault,

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

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

246)         for c in charset:

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

250) 

251)     def test_202_disable_repetition(
252)         self, monkeypatch: pytest.MonkeyPatch
253)     ) -> None:

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

256)         with tests.isolated_config(
257)             monkeypatch=monkeypatch,
258)             runner=runner,
259)         ):

260)             _result = runner.invoke(

261)                 cli.derivepassphrase_vault,

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

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

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

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

273)                 f'derived password contains repeated character '

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

275)             )

276) 

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

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

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

301)     def test_204a_key_from_config(

302)         self,

303)         monkeypatch: pytest.MonkeyPatch,

304)         config: _types.VaultConfig,

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

307)         with tests.isolated_vault_config(

308)             monkeypatch=monkeypatch, runner=runner, config=config
309)         ):
310)             monkeypatch.setattr(

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

312)             )

313)             _result = runner.invoke(

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

317)             )

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

329) 

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

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

334)         with tests.isolated_vault_config(

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

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

344)             )

345)             _result = runner.invoke(

346)                 cli.derivepassphrase_vault,

347)                 ['-k', DUMMY_SERVICE],

348)                 input='1\n',

349)                 catch_exceptions=False,
350)             )

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

361) 

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)         running_ssh_agent: str,

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

393)         with monkeypatch.context():
394)             monkeypatch.setenv('SSH_AUTH_SOCK', running_ssh_agent)
395)             monkeypatch.setattr(
396)                 ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys

397)             )

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

399)             runner = click.testing.CliRunner(mix_stderr=False)
400)             with tests.isolated_vault_config(
401)                 monkeypatch=monkeypatch, runner=runner, config=config
402)             ):
403)                 _result = runner.invoke(
404)                     cli.derivepassphrase_vault,
405)                     ['-k', DUMMY_SERVICE],
406)                     input=f'{key_index}\n',
407)                 )

408)         result = tests.ReadableResult.parse(_result)
409)         assert result.clean_exit(), 'expected clean exit'
410)         assert result.output, 'expected program output'
411)         assert result.stderr, 'expected stderr'
412)         assert (
413)             'Error:' not in result.stderr
414)         ), 'expected no error messages on stderr'

415) 

416)     def test_205_service_phrase_if_key_in_global_config(

417)         self,

418)         monkeypatch: pytest.MonkeyPatch,

419)         running_ssh_agent: str,

420)     ) -> None:

421)         with monkeypatch.context():
422)             monkeypatch.setenv('SSH_AUTH_SOCK', running_ssh_agent)
423)             monkeypatch.setattr(
424)                 ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys

425)             )

426)             monkeypatch.setattr(ssh_agent.SSHAgentClient, 'sign', tests.sign)
427)             runner = click.testing.CliRunner(mix_stderr=False)
428)             with tests.isolated_vault_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_PASSPHRASE
452)         ), 'known false output: phrase-based instead of key-based'

453)         assert (

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

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)         ):
478)             for value in '-42', 'invalid':

479)                 _result = runner.invoke(

480)                     cli.derivepassphrase_vault,

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

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

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

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

497)     )
498)     def test_211_service_needed(

499)         self,

500)         monkeypatch: pytest.MonkeyPatch,

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

503)         input: str | None,

504)         check_success: bool,

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

508)         with tests.isolated_vault_config(

509)             monkeypatch=monkeypatch,
510)             runner=runner,
511)             config={'global': {'phrase': 'abc'}, 'services': {}},
512)         ):

513)             _result = runner.invoke(

514)                 cli.derivepassphrase_vault,

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

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

520)             if service is not None:

521)                 err_msg = (

522)                     ' requires a SERVICE'

523)                     if service

524)                     else ' does not take a SERVICE argument'

525)                 )

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

529)             else:

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

533)         if check_success:

534)             with tests.isolated_vault_config(

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

542)                 _result = runner.invoke(

543)                     cli.derivepassphrase_vault,

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

547)                 )

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

550) 
551)     @pytest.mark.parametrize(

552)         ['options', 'service'],

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

558)     )

559)     def test_212_incompatible_options(

560)         self,

561)         monkeypatch: pytest.MonkeyPatch,

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

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

566)         with tests.isolated_config(
567)             monkeypatch=monkeypatch,
568)             runner=runner,
569)         ):

570)             _result = runner.invoke(

571)                 cli.derivepassphrase_vault,

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

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

580) 

581)     @pytest.mark.parametrize(
582)         'config',
583)         [
584)             conf.config
585)             for conf in tests.TEST_CONFIGS
586)             if tests.is_valid_test_config(conf)
587)         ],
588)     )
589)     def test_213_import_config_success(
590)         self,
591)         monkeypatch: pytest.MonkeyPatch,
592)         config: Any,
593)     ) -> None:
594)         runner = click.testing.CliRunner(mix_stderr=False)
595)         with tests.isolated_vault_config(
596)             monkeypatch=monkeypatch,
597)             runner=runner,
598)             config={'services': {}},
599)         ):
600)             _result = runner.invoke(
601)                 cli.derivepassphrase_vault,
602)                 ['--import', '-'],
603)                 input=json.dumps(config),
604)                 catch_exceptions=False,
605)             )
606)             with open(
607)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
608)             ) as infile:
609)                 config2 = json.load(infile)
610)         result = tests.ReadableResult.parse(_result)
611)         assert result.clean_exit(empty_stderr=True), 'expected clean exit'
612)         assert config2 == config, 'config not imported correctly'
613) 
614)     @hypothesis.given(
615)         conf=tests.smudged_vault_test_config(
616)             strategies.sampled_from(TEST_CONFIGS).filter(
617)                 tests.is_valid_test_config
618)             )
619)         )
620)     )
621)     def test_213a_import_config_success(
622)         self,
623)         conf: tests.VaultTestConfig,
624)     ) -> None:
625)         config = conf.config
626)         config2 = copy.deepcopy(config)
627)         _types.clean_up_falsy_vault_config_values(config2)
628)         runner = click.testing.CliRunner(mix_stderr=False)
629)         with tests.isolated_vault_config(
630)             monkeypatch=pytest.MonkeyPatch(),
631)             runner=runner,
632)             config={'services': {}},
633)         ):
634)             _result = runner.invoke(
635)                 cli.derivepassphrase_vault,
636)                 ['--import', '-'],
637)                 input=json.dumps(config),
638)                 catch_exceptions=False,
639)             )
640)             with open(
641)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
642)             ) as infile:
643)                 config3 = json.load(infile)
644)         result = tests.ReadableResult.parse(_result)
645)         assert result.clean_exit(empty_stderr=True), 'expected clean exit'
646)         assert config3 == config2, 'config not imported correctly'
647) 
648)     def test_213b_import_bad_config_not_vault_config(

649)         self,

650)         monkeypatch: pytest.MonkeyPatch,

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

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

654)             _result = runner.invoke(

655)                 cli.derivepassphrase_vault,

656)                 ['--import', '-'],

657)                 input='null',

658)                 catch_exceptions=False,

659)             )

660)         result = tests.ReadableResult.parse(_result)
661)         assert result.error_exit(
662)             error='Invalid vault config'
663)         ), 'expected error exit and known error message'

664) 

665)     def test_213c_import_bad_config_not_json_data(

666)         self,

667)         monkeypatch: pytest.MonkeyPatch,

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

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

671)             _result = runner.invoke(

672)                 cli.derivepassphrase_vault,

673)                 ['--import', '-'],

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

675)                 catch_exceptions=False,

676)             )

677)         result = tests.ReadableResult.parse(_result)
678)         assert result.error_exit(
679)             error='cannot decode JSON'
680)         ), 'expected error exit and known error message'

681) 

682)     def test_213d_import_bad_config_not_a_file(

683)         self,

684)         monkeypatch: pytest.MonkeyPatch,

685)     ) -> None:
686)         runner = click.testing.CliRunner(mix_stderr=False)

687)         # `isolated_vault_config` validates the configuration.  So, to
688)         # pass an actual broken configuration, we must open the
689)         # configuration file ourselves afterwards, inside the context.
690)         # We also might as well use `isolated_config` instead.
691)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):

692)             with open(

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

694)             ) as outfile:

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

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

697)             _result = runner.invoke(

698)                 cli.derivepassphrase_vault,

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

700)                 catch_exceptions=False,

701)             )

702)         result = tests.ReadableResult.parse(_result)
703)         assert result.error_exit(
704)             error=os.strerror(errno.EISDIR)
705)         ), 'expected error exit and known error message'

706) 
707)     def test_214_export_settings_no_stored_settings(

708)         self,

709)         monkeypatch: pytest.MonkeyPatch,

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

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

713)             with contextlib.suppress(FileNotFoundError):

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

715)             _result = runner.invoke(

716)                 cli.derivepassphrase_vault,
717)                 ['--export', '-'],
718)                 catch_exceptions=False,

719)             )

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

722) 

723)     def test_214a_export_settings_bad_stored_config(

724)         self,

725)         monkeypatch: pytest.MonkeyPatch,

726)     ) -> None:
727)         runner = click.testing.CliRunner(mix_stderr=False)

728)         with tests.isolated_vault_config(

729)             monkeypatch=monkeypatch, runner=runner, config={}
730)         ):

731)             _result = runner.invoke(

732)                 cli.derivepassphrase_vault,

733)                 ['--export', '-'],

734)                 input='null',

735)                 catch_exceptions=False,

736)             )

737)         result = tests.ReadableResult.parse(_result)
738)         assert result.error_exit(
739)             error='Cannot load config'
740)         ), 'expected error exit and known error message'

741) 

742)     def test_214b_export_settings_not_a_file(

743)         self,

744)         monkeypatch: pytest.MonkeyPatch,

745)     ) -> None:
746)         runner = click.testing.CliRunner(mix_stderr=False)

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

748)             with contextlib.suppress(FileNotFoundError):

749)                 os.remove(cli._config_filename(subsystem='vault'))
750)             os.makedirs(cli._config_filename(subsystem='vault'))

751)             _result = runner.invoke(

752)                 cli.derivepassphrase_vault,

753)                 ['--export', '-'],

754)                 input='null',

755)                 catch_exceptions=False,

756)             )

757)         result = tests.ReadableResult.parse(_result)
758)         assert result.error_exit(
759)             error='Cannot load config'
760)         ), 'expected error exit and known error message'

761) 

762)     def test_214c_export_settings_target_not_a_file(

763)         self,

764)         monkeypatch: pytest.MonkeyPatch,

765)     ) -> None:
766)         runner = click.testing.CliRunner(mix_stderr=False)

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

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

769)             _result = runner.invoke(

770)                 cli.derivepassphrase_vault,

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

772)                 input='null',

773)                 catch_exceptions=False,

774)             )

775)         result = tests.ReadableResult.parse(_result)
776)         assert result.error_exit(
777)             error='Cannot store config'
778)         ), 'expected error exit and known error message'

779) 

780)     def test_214d_export_settings_settings_directory_not_a_directory(
781)         self,

782)         monkeypatch: pytest.MonkeyPatch,

783)     ) -> None:
784)         runner = click.testing.CliRunner(mix_stderr=False)

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

786)             with contextlib.suppress(FileNotFoundError):
787)                 shutil.rmtree('.derivepassphrase')
788)             with open('.derivepassphrase', 'w', encoding='UTF-8') as outfile:
789)                 print('Obstruction!!', file=outfile)

790)             _result = runner.invoke(

791)                 cli.derivepassphrase_vault,

792)                 ['--export', '-'],

793)                 input='null',

794)                 catch_exceptions=False,
795)             )

796)         result = tests.ReadableResult.parse(_result)
797)         assert result.error_exit(
798)             error='Cannot load config'
799)         ), 'expected error exit and known error message'

800) 

801)     def test_220_edit_notes_successfully(
802)         self, monkeypatch: pytest.MonkeyPatch
803)     ) -> None:

804)         edit_result = """

805) 
806) # - - - - - >8 - - - - - >8 - - - - - >8 - - - - - >8 - - - - -
807) contents go here

808) """

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

810)         with tests.isolated_vault_config(

811)             monkeypatch=monkeypatch,
812)             runner=runner,
813)             config={'global': {'phrase': 'abc'}, 'services': {}},
814)         ):
815)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: edit_result)  # noqa: ARG005

816)             _result = runner.invoke(

817)                 cli.derivepassphrase_vault,
818)                 ['--notes', 'sv'],
819)                 catch_exceptions=False,

820)             )

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

823)             with open(
824)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
825)             ) as infile:

826)                 config = json.load(infile)

827)             assert config == {
828)                 'global': {'phrase': 'abc'},
829)                 'services': {'sv': {'notes': 'contents go here'}},
830)             }

831) 

832)     def test_221_edit_notes_noop(
833)         self, monkeypatch: pytest.MonkeyPatch
834)     ) -> None:

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

836)         with tests.isolated_vault_config(

837)             monkeypatch=monkeypatch,
838)             runner=runner,
839)             config={'global': {'phrase': 'abc'}, 'services': {}},
840)         ):
841)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: None)  # noqa: ARG005

842)             _result = runner.invoke(

843)                 cli.derivepassphrase_vault,
844)                 ['--notes', 'sv'],
845)                 catch_exceptions=False,

846)             )

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

849)             with open(
850)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
851)             ) as infile:

852)                 config = json.load(infile)
853)             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
854) 

855)     def test_222_edit_notes_marker_removed(
856)         self, monkeypatch: pytest.MonkeyPatch
857)     ) -> None:

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

859)         with tests.isolated_vault_config(

860)             monkeypatch=monkeypatch,
861)             runner=runner,
862)             config={'global': {'phrase': 'abc'}, 'services': {}},
863)         ):
864)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: 'long\ntext')  # noqa: ARG005

865)             _result = runner.invoke(

866)                 cli.derivepassphrase_vault,
867)                 ['--notes', 'sv'],
868)                 catch_exceptions=False,

869)             )

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

872)             with open(
873)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
874)             ) as infile:

875)                 config = json.load(infile)

876)             assert config == {
877)                 'global': {'phrase': 'abc'},
878)                 'services': {'sv': {'notes': 'long\ntext'}},
879)             }

880) 

881)     def test_223_edit_notes_abort(
882)         self, monkeypatch: pytest.MonkeyPatch
883)     ) -> None:

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

885)         with tests.isolated_vault_config(

886)             monkeypatch=monkeypatch,
887)             runner=runner,
888)             config={'global': {'phrase': 'abc'}, 'services': {}},
889)         ):
890)             monkeypatch.setattr(click, 'edit', lambda *a, **kw: '\n\n')  # noqa: ARG005

891)             _result = runner.invoke(

892)                 cli.derivepassphrase_vault,
893)                 ['--notes', 'sv'],
894)                 catch_exceptions=False,

895)             )

896)             result = tests.ReadableResult.parse(_result)
897)             assert result.error_exit(
898)                 error='user aborted request'
899)             ), 'expected known error message'

900)             with open(
901)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
902)             ) as infile:

903)                 config = json.load(infile)
904)             assert config == {'global': {'phrase': 'abc'}, 'services': {}}
905) 

906)     @pytest.mark.parametrize(
907)         ['command_line', 'input', 'result_config'],
908)         [
909)             (
910)                 ['--phrase'],

911)                 'my passphrase\n',

912)                 {'global': {'phrase': 'my passphrase'}, 'services': {}},
913)             ),
914)             (
915)                 ['--key'],

916)                 '1\n',

917)                 {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
918)             ),
919)             (
920)                 ['--phrase', 'sv'],

921)                 'my passphrase\n',

922)                 {
923)                     'global': {'phrase': 'abc'},
924)                     'services': {'sv': {'phrase': 'my passphrase'}},
925)                 },
926)             ),
927)             (
928)                 ['--key', 'sv'],

929)                 '1\n',

930)                 {
931)                     'global': {'phrase': 'abc'},
932)                     'services': {'sv': {'key': DUMMY_KEY1_B64}},
933)                 },
934)             ),
935)             (
936)                 ['--key', '--length', '15', 'sv'],

937)                 '1\n',

938)                 {
939)                     'global': {'phrase': 'abc'},
940)                     'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
941)                 },
942)             ),
943)         ],
944)     )

945)     def test_224_store_config_good(

946)         self,

947)         monkeypatch: pytest.MonkeyPatch,

948)         command_line: list[str],

949)         input: str,

950)         result_config: Any,
951)     ) -> None:
952)         runner = click.testing.CliRunner(mix_stderr=False)

953)         with tests.isolated_vault_config(

954)             monkeypatch=monkeypatch,
955)             runner=runner,
956)             config={'global': {'phrase': 'abc'}, 'services': {}},
957)         ):
958)             monkeypatch.setattr(
959)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
960)             )

961)             _result = runner.invoke(

962)                 cli.derivepassphrase_vault,

963)                 ['--config', *command_line],
964)                 catch_exceptions=False,
965)                 input=input,
966)             )

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

969)             with open(
970)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
971)             ) as infile:

972)                 config = json.load(infile)

973)             assert (
974)                 config == result_config
975)             ), 'stored config does not match expectation'

976) 

977)     @pytest.mark.parametrize(
978)         ['command_line', 'input', 'err_text'],
979)         [

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

981)             (
982)                 ['sv'],

983)                 '',
984)                 'Cannot update service settings without actual settings',

985)             ),

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

988)         ],
989)     )

990)     def test_225_store_config_fail(

991)         self,

992)         monkeypatch: pytest.MonkeyPatch,

993)         command_line: list[str],

994)         input: str,
995)         err_text: str,

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

998)         with tests.isolated_vault_config(

999)             monkeypatch=monkeypatch,
1000)             runner=runner,
1001)             config={'global': {'phrase': 'abc'}, 'services': {}},
1002)         ):
1003)             monkeypatch.setattr(
1004)                 cli, '_get_suitable_ssh_keys', tests.suitable_ssh_keys
1005)             )

1006)             _result = runner.invoke(

1007)                 cli.derivepassphrase_vault,

1008)                 ['--config', *command_line],
1009)                 catch_exceptions=False,
1010)                 input=input,
1011)             )

1012)         result = tests.ReadableResult.parse(_result)
1013)         assert result.error_exit(
1014)             error=err_text
1015)         ), 'expected error exit and known error message'

1016) 
1017)     def test_225a_store_config_fail_manual_no_ssh_key_selection(

1018)         self,

1019)         monkeypatch: pytest.MonkeyPatch,

1020)     ) -> None:
1021)         runner = click.testing.CliRunner(mix_stderr=False)

1022)         with tests.isolated_vault_config(

1023)             monkeypatch=monkeypatch,
1024)             runner=runner,
1025)             config={'global': {'phrase': 'abc'}, 'services': {}},
1026)         ):

1027)             custom_error = 'custom error message'

1028) 

1029)             def raiser() -> None:

1030)                 raise RuntimeError(custom_error)

1031) 

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

1033)             _result = runner.invoke(

1034)                 cli.derivepassphrase_vault,

1035)                 ['--key', '--config'],
1036)                 catch_exceptions=False,
1037)             )

1038)         result = tests.ReadableResult.parse(_result)
1039)         assert result.error_exit(
1040)             error=custom_error
1041)         ), 'expected error exit and known error message'

1042) 

1043)     def test_225b_store_config_fail_manual_no_ssh_agent(
1044)         self,

1045)         monkeypatch: pytest.MonkeyPatch,

1046)         skip_if_no_af_unix_support: None,

1047)     ) -> None:

1048)         del skip_if_no_af_unix_support

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

1050)         with tests.isolated_vault_config(

1051)             monkeypatch=monkeypatch,
1052)             runner=runner,
1053)             config={'global': {'phrase': 'abc'}, 'services': {}},
1054)         ):
1055)             monkeypatch.delenv('SSH_AUTH_SOCK', raising=False)

1056)             _result = runner.invoke(

1057)                 cli.derivepassphrase_vault,

1058)                 ['--key', '--config'],
1059)                 catch_exceptions=False,
1060)             )

1061)         result = tests.ReadableResult.parse(_result)
1062)         assert result.error_exit(
1063)             error='Cannot find running SSH agent'
1064)         ), 'expected error exit and known error message'

1065) 
1066)     def test_225c_store_config_fail_manual_bad_ssh_agent_connection(
1067)         self,

1068)         monkeypatch: pytest.MonkeyPatch,

1069)     ) -> None:
1070)         runner = click.testing.CliRunner(mix_stderr=False)

1071)         with tests.isolated_vault_config(

1072)             monkeypatch=monkeypatch,
1073)             runner=runner,
1074)             config={'global': {'phrase': 'abc'}, 'services': {}},
1075)         ):
1076)             monkeypatch.setenv('SSH_AUTH_SOCK', os.getcwd())

1077)             _result = runner.invoke(

1078)                 cli.derivepassphrase_vault,

1079)                 ['--key', '--config'],
1080)                 catch_exceptions=False,
1081)             )

1082)         result = tests.ReadableResult.parse(_result)
1083)         assert result.error_exit(
1084)             error='Cannot connect to SSH agent'
1085)         ), 'expected error exit and known error message'

1086) 
1087)     @pytest.mark.parametrize('try_race_free_implementation', [True, False])
1088)     def test_225d_store_config_fail_manual_read_only_file(
1089)         self,

1090)         monkeypatch: pytest.MonkeyPatch,

1091)         try_race_free_implementation: bool,
1092)     ) -> None:
1093)         runner = click.testing.CliRunner(mix_stderr=False)

1094)         with tests.isolated_vault_config(

1095)             monkeypatch=monkeypatch,
1096)             runner=runner,
1097)             config={'global': {'phrase': 'abc'}, 'services': {}},
1098)         ):
1099)             tests.make_file_readonly(

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

1101)                 try_race_free_implementation=try_race_free_implementation,
1102)             )

1103)             _result = runner.invoke(

1104)                 cli.derivepassphrase_vault,

1105)                 ['--config', '--length=15', DUMMY_SERVICE],
1106)                 catch_exceptions=False,
1107)             )

1108)         result = tests.ReadableResult.parse(_result)
1109)         assert result.error_exit(
1110)             error='Cannot store config'
1111)         ), 'expected error exit and known error message'

1112) 
1113)     def test_225e_store_config_fail_manual_custom_error(
1114)         self,

1115)         monkeypatch: pytest.MonkeyPatch,

1116)     ) -> None:
1117)         runner = click.testing.CliRunner(mix_stderr=False)

1118)         with tests.isolated_vault_config(

1119)             monkeypatch=monkeypatch,
1120)             runner=runner,
1121)             config={'global': {'phrase': 'abc'}, 'services': {}},
1122)         ):
1123)             custom_error = 'custom error message'
1124) 
1125)             def raiser(config: Any) -> None:
1126)                 del config
1127)                 raise RuntimeError(custom_error)
1128) 
1129)             monkeypatch.setattr(cli, '_save_config', raiser)

1130)             _result = runner.invoke(

1131)                 cli.derivepassphrase_vault,

1132)                 ['--config', '--length=15', DUMMY_SERVICE],
1133)                 catch_exceptions=False,
1134)             )

1135)         result = tests.ReadableResult.parse(_result)
1136)         assert result.error_exit(
1137)             error=custom_error
1138)         ), 'expected error exit and known error message'

1139) 

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

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

1142)         with tests.isolated_config(
1143)             monkeypatch=monkeypatch,
1144)             runner=runner,
1145)         ):

1146)             _result = runner.invoke(

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

1148)             )

1149)         result = tests.ReadableResult.parse(_result)
1150)         assert result.error_exit(
1151)             error='SERVICE is required'
1152)         ), 'expected error exit and known error message'

1153) 

1154)     def test_226a_no_passphrase_or_key(
1155)         self, monkeypatch: pytest.MonkeyPatch
1156)     ) -> None:

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

1158)         with tests.isolated_config(
1159)             monkeypatch=monkeypatch,
1160)             runner=runner,
1161)         ):

1162)             _result = runner.invoke(

1163)                 cli.derivepassphrase_vault,
1164)                 [DUMMY_SERVICE],
1165)                 catch_exceptions=False,

1166)             )

1167)         result = tests.ReadableResult.parse(_result)
1168)         assert result.error_exit(
1169)             error='No passphrase or key given'
1170)         ), 'expected error exit and known error message'

1171) 

1172)     def test_230_config_directory_nonexistant(
1173)         self, monkeypatch: pytest.MonkeyPatch
1174)     ) -> None:

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

1176)         runner = click.testing.CliRunner(mix_stderr=False)
1177)         with tests.isolated_config(
1178)             monkeypatch=monkeypatch,
1179)             runner=runner,
1180)         ):

1181)             shutil.rmtree('.derivepassphrase')

1182)             os_makedirs_called = False
1183)             real_os_makedirs = os.makedirs
1184) 
1185)             def makedirs(*args: Any, **kwargs: Any) -> Any:
1186)                 nonlocal os_makedirs_called
1187)                 os_makedirs_called = True
1188)                 return real_os_makedirs(*args, **kwargs)
1189) 
1190)             monkeypatch.setattr(os, 'makedirs', makedirs)

1191)             _result = runner.invoke(

1192)                 cli.derivepassphrase_vault,

1193)                 ['--config', '-p'],
1194)                 catch_exceptions=False,
1195)                 input='abc\n',
1196)             )

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

1199)             assert (

1200)                 result.stderr == 'Passphrase:'

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

1203)             with open(
1204)                 cli._config_filename(subsystem='vault'), encoding='UTF-8'
1205)             ) as infile:

1206)                 config_readback = json.load(infile)
1207)             assert config_readback == {
1208)                 'global': {'phrase': 'abc'},
1209)                 'services': {},
1210)             }, 'config mismatch'
1211) 

1212)     def test_230a_config_directory_not_a_file(
1213)         self, monkeypatch: pytest.MonkeyPatch
1214)     ) -> None:

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

1216)         runner = click.testing.CliRunner(mix_stderr=False)
1217)         with tests.isolated_config(
1218)             monkeypatch=monkeypatch,
1219)             runner=runner,
1220)         ):
1221)             _save_config = cli._save_config
1222) 
1223)             def obstruct_config_saving(*args: Any, **kwargs: Any) -> Any:
1224)                 with contextlib.suppress(FileNotFoundError):
1225)                     shutil.rmtree('.derivepassphrase')
1226)                 with open(
1227)                     '.derivepassphrase', 'w', encoding='UTF-8'
1228)                 ) as outfile:
1229)                     print('Obstruction!!', file=outfile)
1230)                 monkeypatch.setattr(cli, '_save_config', _save_config)
1231)                 return _save_config(*args, **kwargs)
1232) 
1233)             monkeypatch.setattr(cli, '_save_config', obstruct_config_saving)

1234)             _result = runner.invoke(

1235)                 cli.derivepassphrase_vault,

1236)                 ['--config', '-p'],
1237)                 catch_exceptions=False,
1238)                 input='abc\n',
1239)             )

1240)             result = tests.ReadableResult.parse(_result)
1241)             assert result.error_exit(
1242)                 error='Cannot store config'
1243)             ), 'expected error exit and known error message'

1244) 

1245)     def test_230b_store_config_custom_error(
1246)         self, monkeypatch: pytest.MonkeyPatch
1247)     ) -> None:

1248)         runner = click.testing.CliRunner(mix_stderr=False)
1249)         with tests.isolated_config(
1250)             monkeypatch=monkeypatch,
1251)             runner=runner,
1252)         ):

1253)             custom_error = 'custom error message'

1254) 

1255)             def raiser(config: Any) -> None:
1256)                 del config
1257)                 raise RuntimeError(custom_error)

1258) 

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

1260)             _result = runner.invoke(

1261)                 cli.derivepassphrase_vault,

1262)                 ['--config', '-p'],
1263)                 catch_exceptions=False,
1264)                 input='abc\n',
1265)             )

1266)             result = tests.ReadableResult.parse(_result)
1267)             assert result.error_exit(

1268)                 error=custom_error

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

1270) 

1271)     @pytest.mark.parametrize(

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

1273)         [
1274)             pytest.param(
1275)                 ['--import', '-'],
1276)                 json.dumps({
1277)                     'global': {'phrase': 'Du\u0308sseldorf'},
1278)                     'services': {},
1279)                 }),
1280)                 'the global passphrase is not NFC-normalized',
1281)                 id='global-NFC',
1282)             ),
1283)             pytest.param(
1284)                 ['--import', '-'],
1285)                 json.dumps({
1286)                     'services': {
1287)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1288)                         'weird entry name': {'phrase': 'Du\u0308sseldorf'},
1289)                     }
1290)                 }),
1291)                 (
1292)                     "the services.'weird entry name' passphrase "
1293)                     'is not NFC-normalized'
1294)                 ),
1295)                 id='service-weird-name-NFC',
1296)             ),
1297)             pytest.param(
1298)                 ['--config', '-p', DUMMY_SERVICE],
1299)                 'Du\u0308sseldorf',
1300)                 (
1301)                     f'the services.{DUMMY_SERVICE} passphrase '
1302)                     f'is not NFC-normalized'
1303)                 ),
1304)                 id='config-NFC',
1305)             ),
1306)             pytest.param(
1307)                 ['-p', DUMMY_SERVICE],
1308)                 'Du\u0308sseldorf',
1309)                 'the interactive passphrase is not NFC-normalized',
1310)                 id='direct-input-NFC',
1311)             ),
1312)             pytest.param(
1313)                 ['--import', '-'],
1314)                 json.dumps({
1315)                     'global': {
1316)                         'unicode_normalization_form': 'NFD',
1317)                         'phrase': 'D\u00fcsseldorf',
1318)                     },
1319)                     'services': {},
1320)                 }),
1321)                 'the global passphrase is not NFD-normalized',
1322)                 id='global-NFD',
1323)             ),
1324)             pytest.param(
1325)                 ['--import', '-'],
1326)                 json.dumps({
1327)                     'global': {
1328)                         'unicode_normalization_form': 'NFD',
1329)                     },
1330)                     'services': {
1331)                         DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy(),
1332)                         'weird entry name': {'phrase': 'D\u00fcsseldorf'},

1333)                     },

1334)                 }),
1335)                 (
1336)                     "the services.'weird entry name' passphrase "
1337)                     'is not NFD-normalized'
1338)                 ),
1339)                 id='service-weird-name-NFD',
1340)             ),
1341)         ],
1342)     )
1343)     def test_300_unicode_normalization_form_warning(
1344)         self,

1345)         monkeypatch: pytest.MonkeyPatch,

1346)         command_line: list[str],
1347)         input: str | None,

1348)         warning_message: str,

1349)     ) -> None:
1350)         runner = click.testing.CliRunner(mix_stderr=False)

1351)         with tests.isolated_vault_config(

1352)             monkeypatch=monkeypatch,
1353)             runner=runner,
1354)             config={'services': {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS.copy()}},
1355)         ):

1356)             _result = runner.invoke(

1357)                 cli.derivepassphrase_vault,

1358)                 command_line,
1359)                 catch_exceptions=False,
1360)                 input=input,
1361)             )

1362)         result = tests.ReadableResult.parse(_result)
1363)         assert result.clean_exit(), 'expected clean exit'
1364)         assert (
1365)             warning_message in result.stderr
1366)         ), 'expected known warning message in stderr'

1367) 

1368)     def test_400_missing_af_unix_support(
1369)         self,
1370)         monkeypatch: pytest.MonkeyPatch,
1371)     ) -> None:
1372)         runner = click.testing.CliRunner(mix_stderr=False)
1373)         with tests.isolated_vault_config(
1374)             monkeypatch=monkeypatch,
1375)             runner=runner,
1376)             config={'global': {'phrase': 'abc'}, 'services': {}},
1377)         ):
1378)             monkeypatch.setenv(
1379)                 'SSH_AUTH_SOCK', "the value doesn't even matter"
1380)             )
1381)             monkeypatch.delattr(socket, 'AF_UNIX', raising=False)
1382)             _result = runner.invoke(
1383)                 cli.derivepassphrase_vault,
1384)                 ['--key', '--config'],
1385)                 catch_exceptions=False,
1386)             )
1387)         result = tests.ReadableResult.parse(_result)
1388)         assert result.error_exit(
1389)             error='does not support UNIX domain sockets'
1390)         ), 'expected error exit and known error message'
1391) 

1392) 

1393) class TestCLIUtils:

1394)     @pytest.mark.parametrize(
1395)         'config',
1396)         [
1397)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
1398)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
1399)             {
1400)                 'global': {'phrase': 'abc'},
1401)                 'services': {'sv': {'phrase': 'my passphrase'}},
1402)             },
1403)             {
1404)                 'global': {'phrase': 'abc'},
1405)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
1406)             },
1407)             {
1408)                 'global': {'phrase': 'abc'},
1409)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
1410)             },
1411)         ],
1412)     )
1413)     def test_100_load_config(
1414)         self, monkeypatch: pytest.MonkeyPatch, config: Any
1415)     ) -> None:
1416)         runner = click.testing.CliRunner()
1417)         with tests.isolated_vault_config(
1418)             monkeypatch=monkeypatch, runner=runner, config=config
1419)         ):
1420)             config_filename = cli._config_filename(subsystem='vault')
1421)             with open(config_filename, encoding='UTF-8') as fileobj:
1422)                 assert json.load(fileobj) == config
1423)             assert cli._load_config() == config
1424) 
1425)     def test_110_save_bad_config(

1426)         self, monkeypatch: pytest.MonkeyPatch
1427)     ) -> None:

1428)         runner = click.testing.CliRunner()

1429)         with (

1430)             tests.isolated_vault_config(

1431)                 monkeypatch=monkeypatch, runner=runner, config={}
1432)             ),
1433)             pytest.raises(ValueError, match='Invalid vault config'),

1434)         ):

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

1436) 

1437)     def test_111_prompt_for_selection_multiple(self) -> None:

1438)         @click.command()
1439)         @click.option('--heading', default='Our menu:')
1440)         @click.argument('items', nargs=-1)

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

1442)             # from https://montypython.fandom.com/wiki/Spam#The_menu
1443)             items = items or [
1444)                 'Egg and bacon',
1445)                 'Egg, sausage and bacon',
1446)                 'Egg and spam',
1447)                 'Egg, bacon and spam',
1448)                 'Egg, bacon, sausage and spam',
1449)                 'Spam, bacon, sausage and spam',
1450)                 'Spam, egg, spam, spam, bacon and spam',
1451)                 'Spam, spam, spam, egg and spam',

1452)                 (
1453)                     'Spam, spam, spam, spam, spam, spam, baked beans, '
1454)                     'spam, spam, spam and spam'
1455)                 ),
1456)                 (
1457)                     'Lobster thermidor aux crevettes with a mornay sauce '
1458)                     'garnished with truffle paté, brandy '
1459)                     'and a fried egg on top and spam'
1460)                 ),

1461)             ]
1462)             index = cli._prompt_for_selection(items, heading=heading)
1463)             click.echo('A fine choice: ', nl=False)
1464)             click.echo(items[index])
1465)             click.echo('(Note: Vikings strictly optional.)')

1466) 

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

1468)         _result = runner.invoke(driver, [], input='9')
1469)         result = tests.ReadableResult.parse(_result)
1470)         assert result.clean_exit(
1471)             output="""\

1472) Our menu:
1473) [1] Egg and bacon
1474) [2] Egg, sausage and bacon
1475) [3] Egg and spam
1476) [4] Egg, bacon and spam
1477) [5] Egg, bacon, sausage and spam
1478) [6] Spam, bacon, sausage and spam
1479) [7] Spam, egg, spam, spam, bacon and spam
1480) [8] Spam, spam, spam, egg and spam
1481) [9] Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
1482) [10] Lobster thermidor aux crevettes with a mornay sauce garnished with truffle paté, brandy and a fried egg on top and spam
1483) Your selection? (1-10, leave empty to abort): 9
1484) A fine choice: Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
1485) (Note: Vikings strictly optional.)

1486) """  # noqa: E501

1487)         ), 'expected clean exit'
1488)         _result = runner.invoke(

1489)             driver, ['--heading='], input='', catch_exceptions=True
1490)         )

1491)         result = tests.ReadableResult.parse(_result)
1492)         assert result.error_exit(
1493)             error=IndexError
1494)         ), 'expected error exit and known error type'

1495)         assert (

1496)             result.output

1497)             == """\

1498) [1] Egg and bacon
1499) [2] Egg, sausage and bacon
1500) [3] Egg and spam
1501) [4] Egg, bacon and spam
1502) [5] Egg, bacon, sausage and spam
1503) [6] Spam, bacon, sausage and spam
1504) [7] Spam, egg, spam, spam, bacon and spam
1505) [8] Spam, spam, spam, egg and spam
1506) [9] Spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam and spam
1507) [10] Lobster thermidor aux crevettes with a mornay sauce garnished with truffle paté, brandy and a fried egg on top and spam

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

1510)         ), 'expected known output'

1511) 

1512)     def test_112_prompt_for_selection_single(self) -> None:

1513)         @click.command()
1514)         @click.option('--item', default='baked beans')
1515)         @click.argument('prompt')

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

1517)             try:

1518)                 cli._prompt_for_selection(
1519)                     [item], heading='', single_choice_prompt=prompt
1520)                 )

1521)             except IndexError:

1522)                 click.echo('Boo.')

1523)                 raise

1524)             else:
1525)                 click.echo('Great!')

1526) 

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

1528)         _result = runner.invoke(

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

1531)         result = tests.ReadableResult.parse(_result)
1532)         assert result.clean_exit(
1533)             output="""\

1534) [1] baked beans
1535) Will replace with spam. Confirm, y/n? y
1536) Great!

1537) """

1538)         ), 'expected clean exit'
1539)         _result = runner.invoke(

1540)             driver,
1541)             ['Will replace with spam, okay? ' '(Please say "y" or "n".)'],
1542)             input='',
1543)         )

1544)         result = tests.ReadableResult.parse(_result)
1545)         assert result.error_exit(
1546)             error=IndexError
1547)         ), 'expected error exit and known error type'

1548)         assert (

1549)             result.output

1550)             == """\

1551) [1] baked beans

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

1553) Boo.

1554) """

1555)         ), 'expected known output'

1556) 

1557)     def test_113_prompt_for_passphrase(

1558)         self, monkeypatch: pytest.MonkeyPatch
1559)     ) -> None:

1560)         monkeypatch.setattr(
1561)             click,
1562)             'prompt',
1563)             lambda *a, **kw: json.dumps({'args': a, 'kwargs': kw}),
1564)         )

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

1566)         err_msg = 'missing arguments to passphrase prompt'
1567)         assert 'args' in res, err_msg
1568)         assert 'kwargs' in res, err_msg
1569)         assert res['args'][:1] == ['Passphrase'], err_msg
1570)         assert res['kwargs'].get('default') == '', err_msg
1571)         assert not res['kwargs'].get('show_default', True), err_msg
1572)         assert res['kwargs'].get('err'), err_msg
1573)         assert res['kwargs'].get('hide_input'), err_msg

1574) 

1575)     @pytest.mark.parametrize(
1576)         ['command_line', 'config', 'result_config'],
1577)         [
1578)             (
1579)                 ['--delete-globals'],
1580)                 {'global': {'phrase': 'abc'}, 'services': {}},
1581)                 {'services': {}},
1582)             ),
1583)             (
1584)                 ['--delete', DUMMY_SERVICE],
1585)                 {
1586)                     'global': {'phrase': 'abc'},
1587)                     'services': {DUMMY_SERVICE: {'notes': '...'}},
1588)                 },
1589)                 {'global': {'phrase': 'abc'}, 'services': {}},
1590)             ),
1591)             (
1592)                 ['--clear'],
1593)                 {
1594)                     'global': {'phrase': 'abc'},
1595)                     'services': {DUMMY_SERVICE: {'notes': '...'}},
1596)                 },
1597)                 {'services': {}},
1598)             ),
1599)         ],
1600)     )

1601)     def test_203_repeated_config_deletion(

1602)         self,

1603)         monkeypatch: pytest.MonkeyPatch,

1604)         command_line: list[str],

1605)         config: _types.VaultConfig,
1606)         result_config: _types.VaultConfig,

1607)     ) -> None:
1608)         runner = click.testing.CliRunner(mix_stderr=False)
1609)         for start_config in [config, result_config]:

1610)             with tests.isolated_vault_config(

1611)                 monkeypatch=monkeypatch, runner=runner, config=start_config
1612)             ):

1613)                 _result = runner.invoke(

1614)                     cli.derivepassphrase_vault,
1615)                     command_line,
1616)                     catch_exceptions=False,

1617)                 )

1618)                 result = tests.ReadableResult.parse(_result)
1619)                 assert result.clean_exit(
1620)                     empty_stderr=True
1621)                 ), 'expected clean exit'

1622)                 with open(
1623)                     cli._config_filename(subsystem='vault'), encoding='UTF-8'
1624)                 ) as infile:

1625)                     config_readback = json.load(infile)
1626)                 assert config_readback == result_config
1627) 
1628)     def test_204_phrase_from_key_manually(self) -> None:
1629)         assert (

1630)             vault.Vault(

1631)                 phrase=DUMMY_PHRASE_FROM_KEY1, **DUMMY_CONFIG_SETTINGS
1632)             ).generate(DUMMY_SERVICE)
1633)             == DUMMY_RESULT_KEY1

1634)         )
1635) 

1636)     @pytest.mark.parametrize(
1637)         ['vfunc', 'input'],
1638)         [
1639)             (cli._validate_occurrence_constraint, 20),
1640)             (cli._validate_length, 20),
1641)         ],
1642)     )

1643)     def test_210a_validate_constraints_manually(
1644)         self,
1645)         vfunc: Callable[[click.Context, click.Parameter, Any], int | None],
1646)         input: int,
1647)     ) -> None:

1648)         ctx = cli.derivepassphrase_vault.make_context(cli.PROG_NAME, [])
1649)         param = cli.derivepassphrase_vault.params[0]

1650)         assert vfunc(ctx, param, input) == input
1651) 

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

1653)     def test_227_get_suitable_ssh_keys(

1654)         self,

1655)         monkeypatch: pytest.MonkeyPatch,

1656)         running_ssh_agent: str,

1657)         conn_hint: str,

1658)     ) -> None:

1659)         with monkeypatch.context():
1660)             monkeypatch.setenv('SSH_AUTH_SOCK', running_ssh_agent)
1661)             monkeypatch.setattr(
1662)                 ssh_agent.SSHAgentClient, 'list_keys', tests.list_keys
1663)             )
1664)             hint: ssh_agent.SSHAgentClient | socket.socket | None

1665)             # Use match/case here once Python 3.9 becomes unsupported.
1666)             if conn_hint == 'client':
1667)                 hint = ssh_agent.SSHAgentClient()
1668)             elif conn_hint == 'socket':
1669)                 hint = socket.socket(family=socket.AF_UNIX)
1670)                 hint.connect(running_ssh_agent)
1671)             else:
1672)                 assert conn_hint == 'none'
1673)                 hint = None

1674)             exception: Exception | None = None
1675)             try:
1676)                 list(cli._get_suitable_ssh_keys(hint))
1677)             except RuntimeError:  # pragma: no cover
1678)                 pass
1679)             except Exception as e:  # noqa: BLE001 # pragma: no cover
1680)                 exception = e
1681)             finally:
1682)                 assert (
1683)                     exception is None
1684)                 ), 'exception querying suitable SSH keys'

1685) 
1686) 
1687) class TestCLITransition:
1688)     def test_100_help_output(self, monkeypatch: pytest.MonkeyPatch) -> None:
1689)         runner = click.testing.CliRunner(mix_stderr=False)
1690)         with tests.isolated_config(
1691)             monkeypatch=monkeypatch,
1692)             runner=runner,
1693)         ):
1694)             _result = runner.invoke(
1695)                 cli.derivepassphrase, ['--help'], catch_exceptions=False
1696)             )
1697)             result = tests.ReadableResult.parse(_result)
1698)         assert result.clean_exit(
1699)             empty_stderr=True, output='currently implemented subcommands'
1700)         ), 'expected clean exit, and known help text'
1701) 
1702)     def test_101_help_output_export(
1703)         self, monkeypatch: pytest.MonkeyPatch
1704)     ) -> None:
1705)         runner = click.testing.CliRunner(mix_stderr=False)
1706)         with tests.isolated_config(
1707)             monkeypatch=monkeypatch,
1708)             runner=runner,
1709)         ):
1710)             _result = runner.invoke(
1711)                 cli.derivepassphrase,
1712)                 ['export', '--help'],
1713)                 catch_exceptions=False,
1714)             )
1715)             result = tests.ReadableResult.parse(_result)
1716)         assert result.clean_exit(
1717)             empty_stderr=True, output='only available subcommand'
1718)         ), 'expected clean exit, and known help text'
1719) 
1720)     def test_102_help_output_export_vault(
1721)         self, monkeypatch: pytest.MonkeyPatch
1722)     ) -> None:
1723)         runner = click.testing.CliRunner(mix_stderr=False)
1724)         with tests.isolated_config(
1725)             monkeypatch=monkeypatch,
1726)             runner=runner,
1727)         ):
1728)             _result = runner.invoke(
1729)                 cli.derivepassphrase,
1730)                 ['export', 'vault', '--help'],
1731)                 catch_exceptions=False,
1732)             )
1733)             result = tests.ReadableResult.parse(_result)
1734)         assert result.clean_exit(
1735)             empty_stderr=True, output='Read the vault-native configuration'
1736)         ), 'expected clean exit, and known help text'
1737) 
1738)     def test_103_help_output_vault(
1739)         self, monkeypatch: pytest.MonkeyPatch
1740)     ) -> None:
1741)         runner = click.testing.CliRunner(mix_stderr=False)
1742)         with tests.isolated_config(
1743)             monkeypatch=monkeypatch,
1744)             runner=runner,
1745)         ):
1746)             _result = runner.invoke(
1747)                 cli.derivepassphrase,
1748)                 ['vault', '--help'],
1749)                 catch_exceptions=False,
1750)             )
1751)             result = tests.ReadableResult.parse(_result)
1752)         assert result.clean_exit(
1753)             empty_stderr=True, output='Password generation:\n'
1754)         ), 'expected clean exit, and option groups in help text'
1755)         assert result.clean_exit(
1756)             empty_stderr=True, output='Use NUMBER=0, e.g. "--symbol 0"'
1757)         ), 'expected clean exit, and option group epilog in help text'
1758) 

1759)     @pytest.mark.parametrize(
1760)         'config',
1761)         [
1762)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
1763)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
1764)             {
1765)                 'global': {'phrase': 'abc'},
1766)                 'services': {'sv': {'phrase': 'my passphrase'}},
1767)             },
1768)             {
1769)                 'global': {'phrase': 'abc'},
1770)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
1771)             },
1772)             {
1773)                 'global': {'phrase': 'abc'},
1774)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
1775)             },
1776)         ],
1777)     )
1778)     def test_110_load_config_backup(
1779)         self, monkeypatch: pytest.MonkeyPatch, config: Any
1780)     ) -> None:
1781)         runner = click.testing.CliRunner()
1782)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):
1783)             config_filename = cli._config_filename()
1784)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
1785)                 print(json.dumps(config, indent=2), file=fileobj)
1786)             assert cli._migrate_and_load_old_config()[0] == config
1787) 
1788)     @pytest.mark.parametrize(
1789)         'config',
1790)         [
1791)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
1792)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
1793)             {
1794)                 'global': {'phrase': 'abc'},
1795)                 'services': {'sv': {'phrase': 'my passphrase'}},
1796)             },
1797)             {
1798)                 'global': {'phrase': 'abc'},
1799)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
1800)             },
1801)             {
1802)                 'global': {'phrase': 'abc'},
1803)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
1804)             },
1805)         ],
1806)     )
1807)     def test_111_migrate_config(
1808)         self, monkeypatch: pytest.MonkeyPatch, config: Any
1809)     ) -> None:
1810)         runner = click.testing.CliRunner()
1811)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):
1812)             config_filename = cli._config_filename()
1813)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
1814)                 print(json.dumps(config, indent=2), file=fileobj)
1815)             assert cli._migrate_and_load_old_config() == (config, None)
1816) 
1817)     @pytest.mark.parametrize(
1818)         'config',
1819)         [
1820)             {'global': {'phrase': 'my passphrase'}, 'services': {}},
1821)             {'global': {'key': DUMMY_KEY1_B64}, 'services': {}},
1822)             {
1823)                 'global': {'phrase': 'abc'},
1824)                 'services': {'sv': {'phrase': 'my passphrase'}},
1825)             },
1826)             {
1827)                 'global': {'phrase': 'abc'},
1828)                 'services': {'sv': {'key': DUMMY_KEY1_B64}},
1829)             },
1830)             {
1831)                 'global': {'phrase': 'abc'},
1832)                 'services': {'sv': {'key': DUMMY_KEY1_B64, 'length': 15}},
1833)             },
1834)         ],
1835)     )
1836)     def test_112_migrate_config_error(
1837)         self, monkeypatch: pytest.MonkeyPatch, config: Any
1838)     ) -> None:
1839)         runner = click.testing.CliRunner()
1840)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):
1841)             config_filename = cli._config_filename()
1842)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
1843)                 print(json.dumps(config, indent=2), file=fileobj)
1844)             os.mkdir(cli._config_filename(subsystem='vault'))
1845)             config2, err = cli._migrate_and_load_old_config()
1846)             assert config2 == config
1847)             assert isinstance(err, OSError)
1848)             assert err.errno == errno.EISDIR
1849) 
1850)     @pytest.mark.parametrize(
1851)         'config',
1852)         [
1853)             {'global': '', 'services': {}},
1854)             {'global': 0, 'services': {}},
1855)             {
1856)                 'global': {'phrase': 'abc'},
1857)                 'services': False,
1858)             },
1859)             {
1860)                 'global': {'phrase': 'abc'},
1861)                 'services': True,
1862)             },
1863)             {
1864)                 'global': {'phrase': 'abc'},
1865)                 'services': None,
1866)             },
1867)         ],
1868)     )
1869)     def test_113_migrate_config_error_bad_config_value(
1870)         self, monkeypatch: pytest.MonkeyPatch, config: Any
1871)     ) -> None:
1872)         runner = click.testing.CliRunner()
1873)         with tests.isolated_config(monkeypatch=monkeypatch, runner=runner):
1874)             config_filename = cli._config_filename()
1875)             with open(config_filename, 'w', encoding='UTF-8') as fileobj:
1876)                 print(json.dumps(config, indent=2), file=fileobj)
1877)             with pytest.raises(ValueError, match=cli._INVALID_VAULT_CONFIG):
1878)                 cli._migrate_and_load_old_config()
1879) 

1880)     def test_200_forward_export_vault_path_parameter(
1881)         self, monkeypatch: pytest.MonkeyPatch
1882)     ) -> None:
1883)         pytest.importorskip('cryptography', minversion='38.0')
1884)         runner = click.testing.CliRunner(mix_stderr=False)
1885)         with tests.isolated_vault_exporter_config(
1886)             monkeypatch=monkeypatch,
1887)             runner=runner,
1888)             vault_config=tests.VAULT_V03_CONFIG,
1889)             vault_key=tests.VAULT_MASTER_KEY,
1890)         ):
1891)             monkeypatch.setenv('VAULT_KEY', tests.VAULT_MASTER_KEY)
1892)             _result = runner.invoke(
1893)                 cli.derivepassphrase,
1894)                 ['export', 'VAULT_PATH'],
1895)             )
1896)         result = tests.ReadableResult.parse(_result)
1897)         assert result.clean_exit(empty_stderr=False), 'expected clean exit'

1898)         assert (
1899)             result.stderr
1900)             == f"""\

1901) {cli.PROG_NAME}: Deprecation warning: A subcommand will be required in v1.0. See --help for available subcommands.
1902) {cli.PROG_NAME}: Warning: Defaulting to subcommand "vault".
1903) """  # noqa: E501

1904)         )

1905)         assert json.loads(result.output) == tests.VAULT_V03_CONFIG_DATA
1906) 
1907)     @pytest.mark.parametrize(
1908)         'charset_name', ['lower', 'upper', 'number', 'space', 'dash', 'symbol']
1909)     )
1910)     def test_210_forward_vault_disable_character_set(
1911)         self, monkeypatch: pytest.MonkeyPatch, charset_name: str
1912)     ) -> None:
1913)         monkeypatch.setattr(cli, '_prompt_for_passphrase', tests.auto_prompt)
1914)         option = f'--{charset_name}'

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

1916)         runner = click.testing.CliRunner(mix_stderr=False)
1917)         with tests.isolated_config(
1918)             monkeypatch=monkeypatch,
1919)             runner=runner,
1920)         ):
1921)             _result = runner.invoke(
1922)                 cli.derivepassphrase,
1923)                 [option, '0', '-p', DUMMY_SERVICE],
1924)                 input=DUMMY_PASSPHRASE,
1925)                 catch_exceptions=False,
1926)             )
1927)             result = tests.ReadableResult.parse(_result)
1928)         assert result.clean_exit(empty_stderr=False), 'expected clean exit'

1929)         assert (
1930)             result.stderr
1931)             == f"""\

1932) {cli.PROG_NAME}: Deprecation warning: A subcommand will be required in v1.0. See --help for available subcommands.
1933) {cli.PROG_NAME}: Warning: Defaulting to subcommand "vault".
1934) """  # noqa: E501

1935)         )

1936)         for c in charset:
1937)             assert (
1938)                 c not in result.output
1939)             ), f'derived password contains forbidden character {c!r}'