Coverage for tests / test_derivepassphrase_cli / test_vault_cli_basic_functionality.py: 100.000%

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

2# 

3# SPDX-License-Identifier: Zlib 

4 

5"""Tests for the `derivepassphrase vault` command-line interface: basic functionality.""" 

6 

7from __future__ import annotations (empty)

8 

9import contextlib (empty)

10import json (empty)

11import textwrap (empty)

12import types (empty)

13from typing import TYPE_CHECKING (empty)

14 

15import pytest (empty)

16from typing_extensions import Any, NamedTuple (empty)

17 

18from derivepassphrase import _types, cli, ssh_agent, vault (empty)

19from derivepassphrase._internals import ( (empty)

20 cli_helpers, 

21) 

22from derivepassphrase.ssh_agent import socketprovider (empty)

23from tests import data, machinery (empty)

24from tests.data import callables (empty)

25from tests.machinery import pytest as pytest_machinery (empty)

26 

27if TYPE_CHECKING: (empty)

28 from collections.abc import Generator 

29 from typing import NoReturn 

30 

31DUMMY_SERVICE = data.DUMMY_SERVICE (empty)

32DUMMY_PASSPHRASE = data.DUMMY_PASSPHRASE (empty)

33DUMMY_CONFIG_SETTINGS = data.DUMMY_CONFIG_SETTINGS (empty)

34DUMMY_RESULT_PASSPHRASE = data.DUMMY_RESULT_PASSPHRASE (empty)

35DUMMY_RESULT_KEY1 = data.DUMMY_RESULT_KEY1 (empty)

36 

37DUMMY_KEY1_B64 = data.DUMMY_KEY1_B64 (empty)

38DUMMY_KEY2_B64 = data.DUMMY_KEY2_B64 (empty)

39 

40 

41PROG_NAME = cli.PROG_NAME (empty)

42 

43 

44class IncompatibleConfiguration(NamedTuple): (empty)

45 other_options: list[tuple[str, ...]] (empty)

46 needs_service: bool | None (empty)

47 input: str | None (empty)

48 

49 

50class SingleConfiguration(NamedTuple): (empty)

51 needs_service: bool | None (empty)

52 input: str | None (empty)

53 check_success: bool (empty)

54 

55 

56class OptionCombination(NamedTuple): (empty)

57 options: list[str] (empty)

58 incompatible: bool (empty)

59 needs_service: bool | None (empty)

60 input: str | None (empty)

61 check_success: bool (empty)

62 

63 

64PASSPHRASE_GENERATION_OPTIONS: list[tuple[str, ...]] = [ (empty)

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] 

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

77 ("--notes",), 

78 ("--config",), 

79 ("--delete",), 

80 ("--delete-globals",), 

81 ("--clear",), 

82] 

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

84 ("--delete",), 

85 ("--delete-globals",), 

86 ("--clear",), 

87] 

88STORAGE_OPTIONS: list[tuple[str, ...]] = [("--export", "-"), ("--import", "-")] (empty)

89INCOMPATIBLE: dict[tuple[str, ...], IncompatibleConfiguration] = { (empty)

90 ("--phrase",): IncompatibleConfiguration( 

91 [("--key",), *CONFIGURATION_COMMANDS, *STORAGE_OPTIONS], 

92 True, 

93 DUMMY_PASSPHRASE, 

94 ), 

95 ("--key",): IncompatibleConfiguration( 

96 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

97 ), 

98 ("--length", "20"): IncompatibleConfiguration( 

99 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

100 ), 

101 ("--repeat", "20"): IncompatibleConfiguration( 

102 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

103 ), 

104 ("--lower", "1"): IncompatibleConfiguration( 

105 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

106 ), 

107 ("--upper", "1"): IncompatibleConfiguration( 

108 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

109 ), 

110 ("--number", "1"): IncompatibleConfiguration( 

111 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

112 ), 

113 ("--space", "1"): IncompatibleConfiguration( 

114 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

115 ), 

116 ("--dash", "1"): IncompatibleConfiguration( 

117 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

118 ), 

119 ("--symbol", "1"): IncompatibleConfiguration( 

120 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, DUMMY_PASSPHRASE 

121 ), 

122 ("--notes",): IncompatibleConfiguration( 

123 CONFIGURATION_COMMANDS + STORAGE_OPTIONS, True, None 

124 ), 

125 ("--config", "-p"): IncompatibleConfiguration( 

126 [("--delete",), ("--delete-globals",), ("--clear",), *STORAGE_OPTIONS], 

127 None, 

128 DUMMY_PASSPHRASE, 

129 ), 

130 ("--delete",): IncompatibleConfiguration( 

131 [("--delete-globals",), ("--clear",), *STORAGE_OPTIONS], True, None 

132 ), 

133 ("--delete-globals",): IncompatibleConfiguration( 

134 [("--clear",), *STORAGE_OPTIONS], False, None 

135 ), 

136 ("--clear",): IncompatibleConfiguration(STORAGE_OPTIONS, False, None), 

137 ("--export", "-"): IncompatibleConfiguration( 

138 [("--import", "-")], False, None 

139 ), 

140 ("--import", "-"): IncompatibleConfiguration([], False, None), 

141} 

142SINGLES: dict[tuple[str, ...], SingleConfiguration] = { (empty)

143 ("--phrase",): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

144 ("--key",): SingleConfiguration(True, None, False), 

145 ("--length", "20"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

146 ("--repeat", "20"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

147 ("--lower", "1"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

148 ("--upper", "1"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

149 ("--number", "1"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

150 ("--space", "1"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

151 ("--dash", "1"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

152 ("--symbol", "1"): SingleConfiguration(True, DUMMY_PASSPHRASE, True), 

153 ("--notes",): SingleConfiguration(True, None, False), 

154 ("--config", "-p"): SingleConfiguration(None, DUMMY_PASSPHRASE, False), 

155 ("--delete",): SingleConfiguration(True, None, False), 

156 ("--delete-globals",): SingleConfiguration(False, None, True), 

157 ("--clear",): SingleConfiguration(False, None, True), 

158 ("--export", "-"): SingleConfiguration(False, None, True), 

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

160} 

161INTERESTING_OPTION_COMBINATIONS: list[OptionCombination] = [] (empty)

162config: IncompatibleConfiguration | SingleConfiguration (empty)

163for opt, config in INCOMPATIBLE.items(): (empty)

164 for opt2 in config.other_options: (empty)

165 INTERESTING_OPTION_COMBINATIONS.extend([ (empty)

166 OptionCombination( 

167 options=list(opt + opt2), 

168 incompatible=True, 

169 needs_service=config.needs_service, 

170 input=config.input, 

171 check_success=False, 

172 ), 

173 OptionCombination( 

174 options=list(opt2 + opt), 

175 incompatible=True, 

176 needs_service=config.needs_service, 

177 input=config.input, 

178 check_success=False, 

179 ), 

180 ]) 

181for opt, config in SINGLES.items(): (empty)

182 INTERESTING_OPTION_COMBINATIONS.append( (empty)

183 OptionCombination( 

184 options=list(opt), 

185 incompatible=False, 

186 needs_service=config.needs_service, 

187 input=config.input, 

188 check_success=config.check_success, 

189 ) 

190 ) 

191 

192 

193def is_warning_line(line: str) -> bool: (empty)

194 """Return true if the line is a warning line.""" 

195 return line.startswith(( 1 ctx1c

196 f"{PROG_NAME}: Warning: ", 

197 f"{PROG_NAME}: Deprecation warning: ", 

198 )) 

199 

200 

201def is_harmless_config_import_warning(record: tuple[str, int, str]) -> bool: (empty)

202 """Return true if the warning is harmless, during config import.""" 

203 possible_warnings = [ 2 ctx1bc

204 "Replacing invalid value ", 

205 "Removing ineffective setting ", 

206 ( 

207 "Setting a global passphrase is ineffective " 

208 "because a key is also set." 

209 ), 

210 ( 

211 "Setting a service passphrase is ineffective " 

212 "because a key is also set:" 

213 ), 

214 ] 

215 return any( 2 ctx1bc

216 machinery.warning_emitted(w, [record]) for w in possible_warnings 

217 ) 

218 

219 

220class Parametrize(types.SimpleNamespace): (empty)

221 """Common test parametrizations.""" 

222 

223 AUTO_PROMPT = pytest.mark.parametrize( (empty)

224 "auto_prompt", [False, True], ids=["normal_prompt", "auto_prompt"] 

225 ) 

226 CHARSET_NAME = pytest.mark.parametrize( (empty)

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

228 ) 

229 BASE_CONFIG_WITH_KEY_VARIATIONS = pytest.mark.parametrize( (empty)

230 "config", 

231 [ 

232 pytest.param( 

233 { 

234 "global": {"key": DUMMY_KEY1_B64}, 

235 "services": {DUMMY_SERVICE: {}}, 

236 }, 

237 id="global_config", 

238 ), 

239 pytest.param( 

240 {"services": {DUMMY_SERVICE: {"key": DUMMY_KEY2_B64}}}, 

241 id="service_config", 

242 ), 

243 pytest.param( 

244 { 

245 "global": {"key": DUMMY_KEY1_B64}, 

246 "services": {DUMMY_SERVICE: {"key": DUMMY_KEY2_B64}}, 

247 }, 

248 id="full_config", 

249 ), 

250 ], 

251 ) 

252 CONFIG_WITH_KEY = pytest.mark.parametrize( (empty)

253 "config", 

254 [ 

255 pytest.param( 

256 { 

257 "global": {"key": DUMMY_KEY1_B64}, 

258 "services": {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS}, 

259 }, 

260 id="global", 

261 ), 

262 pytest.param( 

263 { 

264 "global": {"phrase": DUMMY_PASSPHRASE.rstrip("\n")}, 

265 "services": { 

266 DUMMY_SERVICE: { 

267 "key": DUMMY_KEY1_B64, 

268 **DUMMY_CONFIG_SETTINGS, 

269 } 

270 }, 

271 }, 

272 id="service", 

273 ), 

274 ], 

275 ) 

276 CONFIG_WITH_PHRASE = pytest.mark.parametrize( (empty)

277 "config", 

278 [ 

279 pytest.param( 

280 { 

281 "global": {"phrase": DUMMY_PASSPHRASE.rstrip("\n")}, 

282 "services": {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS}, 

283 }, 

284 id="global", 

285 ), 

286 pytest.param( 

287 { 

288 "global": { 

289 "phrase": DUMMY_PASSPHRASE.rstrip("\n") 

290 + "XXX" 

291 + DUMMY_PASSPHRASE.rstrip("\n") 

292 }, 

293 "services": { 

294 DUMMY_SERVICE: { 

295 "phrase": DUMMY_PASSPHRASE.rstrip("\n"), 

296 **DUMMY_CONFIG_SETTINGS, 

297 } 

298 }, 

299 }, 

300 id="service", 

301 ), 

302 ], 

303 ) 

304 KEY_OVERRIDING_IN_CONFIG = pytest.mark.parametrize( (empty)

305 ["config", "command_line"], 

306 [ 

307 pytest.param( 

308 { 

309 "global": {"key": DUMMY_KEY1_B64}, 

310 "services": {}, 

311 }, 

312 ["--config", "-p"], 

313 id="global", 

314 ), 

315 pytest.param( 

316 { 

317 "services": { 

318 DUMMY_SERVICE: { 

319 "key": DUMMY_KEY1_B64, 

320 **DUMMY_CONFIG_SETTINGS, 

321 }, 

322 }, 

323 }, 

324 ["--config", "-p", "--", DUMMY_SERVICE], 

325 id="service", 

326 ), 

327 pytest.param( 

328 { 

329 "global": {"key": DUMMY_KEY1_B64}, 

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

331 }, 

332 ["--config", "-p", "--", DUMMY_SERVICE], 

333 id="service-over-global", 

334 ), 

335 ], 

336 ) 

337 KEY_INDEX = pytest.mark.parametrize( (empty)

338 "key_index", 

339 [ 

340 i 

341 for i, x in enumerate(data.ALL_KEYS.values(), start=1) 

342 if x.is_suitable() 

343 ], 

344 ids=lambda i: f"index{i}", 

345 ) 

346 EXPLICIT_SSH_AGENT_SOCKET_PROVIDER = pytest.mark.parametrize( (empty)

347 ["on_command_line", "in_config"], 

348 [ 

349 pytest.param(False, True, id="configuration_only"), 

350 pytest.param(True, False, id="command_line_only"), 

351 pytest.param( 

352 True, True, id="command_line_overrides_configuration" 

353 ), 

354 ], 

355 ) 

356 VAULT_CHARSET_OPTION = pytest.mark.parametrize( (empty)

357 "option", 

358 [ 

359 "--lower", 

360 "--upper", 

361 "--number", 

362 "--space", 

363 "--dash", 

364 "--symbol", 

365 "--repeat", 

366 "--length", 

367 ], 

368 ) 

369 OPTION_COMBINATIONS_INCOMPATIBLE = pytest.mark.parametrize( (empty)

370 ["options", "service"], 

371 [ 

372 pytest.param(o.options, o.needs_service, id=" ".join(o.options)) 

373 for o in INTERESTING_OPTION_COMBINATIONS 

374 if o.incompatible 

375 ], 

376 ) 

377 OPTION_COMBINATIONS_SERVICE_NEEDED = pytest.mark.parametrize( (empty)

378 ["options", "needs_service", "input", "check_success"], 

379 [ 

380 pytest.param( 

381 o.options, 

382 o.needs_service, 

383 o.input, 

384 o.check_success, 

385 id=" ".join(o.options), 

386 ) 

387 for o in INTERESTING_OPTION_COMBINATIONS 

388 if not o.incompatible 

389 ], 

390 ) 

391 

392 

393class TestHelp: (empty)

394 """Tests related to help output.""" 

395 

396 def test_help_output( (empty)

397 self, 

398 ) -> None: 

399 """The `--help` option emits help text.""" 

400 runner = machinery.CliRunner(mix_stderr=False) 1 ctx1s

401 # TODO(the-13th-letter): Rewrite using parenthesized 

402 # with-statements. 

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

404 with contextlib.ExitStack() as stack: 1 ctx1s

405 monkeypatch = stack.enter_context(pytest.MonkeyPatch.context()) 1 ctx1s

406 stack.enter_context( 1 ctx1s

407 pytest_machinery.isolated_config( 

408 monkeypatch=monkeypatch, 

409 runner=runner, 

410 ) 

411 ) 

412 result = runner.invoke( 1 ctx1s

413 cli.derivepassphrase_vault, 

414 ["--help"], 

415 catch_exceptions=False, 

416 ) 

417 assert result.clean_exit( 1 ctx1s

418 empty_stderr=True, output="Passphrase generation:\n" 

419 ), "expected clean exit, and option groups in help text" 

420 assert result.clean_exit( 1 ctx1s

421 empty_stderr=True, output="Use $VISUAL or $EDITOR to configure" 

422 ), "expected clean exit, and option group epilog in help text" 

423 

424 

425class TestDerivedPassphraseConstraints: (empty)

426 """Tests for (derived) passphrase constraints.""" 

427 

428 def _test(self, command_line: list[str]) -> machinery.ReadableResult: (empty)

429 runner = machinery.CliRunner(mix_stderr=False) 2 ctx1mq

430 # TODO(the-13th-letter): Rewrite using parenthesized 

431 # with-statements. 

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

433 with contextlib.ExitStack() as stack: 2 ctx1mq

434 monkeypatch = stack.enter_context(pytest.MonkeyPatch.context()) 2 ctx1mq

435 stack.enter_context( 2 ctx1mq

436 pytest_machinery.isolated_config( 

437 monkeypatch=monkeypatch, 

438 runner=runner, 

439 ) 

440 ) 

441 monkeypatch.setattr( 2 ctx1mq

442 cli_helpers, 

443 "prompt_for_passphrase", 

444 callables.auto_prompt, 

445 ) 

446 return runner.invoke( 2 ctx1mq

447 cli.derivepassphrase_vault, 

448 command_line, 

449 input=DUMMY_PASSPHRASE, 

450 catch_exceptions=False, 

451 ) 

452 

453 @Parametrize.CHARSET_NAME (empty)

454 def test_disable_character_set( (empty)

455 self, 

456 charset_name: str, 

457 ) -> None: 

458 """Named character classes can be disabled on the command-line.""" 

459 option = f"--{charset_name}" 1 ctx1m

460 charset = vault.Vault.CHARSETS[charset_name].decode("ascii") 1 ctx1m

461 result = self._test([option, "0", "-p", "--", DUMMY_SERVICE]) 1 ctx1m

462 assert result.clean_exit(empty_stderr=True), "expected clean exit:" 1 ctx1m

463 for c in charset: 1 ctx1m

464 assert c not in result.stdout, ( 1 ctx1m

465 f"derived password contains forbidden character {c!r}" 

466 ) 

467 

468 def test_disable_repetition( (empty)

469 self, 

470 ) -> None: 

471 """Character repetition can be disabled on the command-line.""" 

472 result = self._test(["--repeat", "0", "-p", "--", DUMMY_SERVICE]) 1 ctx1q

473 assert result.clean_exit(empty_stderr=True), ( 1 ctx1q

474 "expected clean exit and empty stderr" 

475 ) 

476 passphrase = result.stdout.rstrip("\r\n") 1 ctx1q

477 for i in range(len(passphrase) - 1): 1 ctx1q

478 assert passphrase[i : i + 1] != passphrase[i + 1 : i + 2], ( 1 ctx1q

479 f"derived password contains repeated character " 

480 f"at position {i}: {result.stdout!r}" 

481 ) 

482 

483 

484class TestPhraseBasic: (empty)

485 """Tests for master passphrase configuration: basic.""" 

486 

487 def _test( (empty)

488 self, 

489 command_line: list[str], 

490 /, 

491 *, 

492 config: _types.VaultConfig = { # noqa: B006 

493 "services": {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS} 

494 }, 

495 auto_prompt: bool = False, 

496 multiline: bool = False, 

497 ) -> None: 

498 runner = machinery.CliRunner(mix_stderr=False) 2 ctx1ik

499 # TODO(the-13th-letter): Rewrite using parenthesized 

500 # with-statements. 

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

502 with contextlib.ExitStack() as stack: 2 ctx1ik

503 monkeypatch = stack.enter_context(pytest.MonkeyPatch.context()) 2 ctx1ik

504 stack.enter_context( 2 ctx1ik

505 pytest_machinery.isolated_vault_config( 

506 monkeypatch=monkeypatch, 

507 runner=runner, 

508 vault_config=config, 

509 ) 

510 ) 

511 

512 def phrase_from_key(*_args: Any, **_kwargs: Any) -> NoReturn: 2 ctx1ik

513 pytest.fail("Attempted to use a key in a phrase-based test!") 

514 

515 monkeypatch.setattr( 2 ctx1ik

516 vault.Vault, "phrase_from_key", phrase_from_key 

517 ) 

518 if auto_prompt: 2 ctx1ik

519 monkeypatch.setattr( 1 ctx1i

520 cli_helpers, 

521 "prompt_for_passphrase", 

522 callables.auto_prompt, 

523 ) 

524 result = runner.invoke( 2 ctx1ik

525 cli.derivepassphrase_vault, 

526 command_line, 

527 input=None if auto_prompt else DUMMY_PASSPHRASE, 

528 catch_exceptions=False, 

529 ) 

530 if multiline: 2 ctx1ik

531 assert result.clean_exit(), "expected clean exit" 1 ctx1i

532 else: 

533 assert result.clean_exit(empty_stderr=True), ( 1 ctx1k

534 "expected clean exit and empty stderr" 

535 ) 

536 assert result.stdout, "expected program output" 2 ctx1ik

537 last_line = ( 2 ctx1ik

538 result.stdout.splitlines(keepends=True)[-1] 

539 if multiline 

540 else result.stdout 

541 ) 

542 assert ( 2 ctx1ik

543 last_line.rstrip("\n").encode("UTF-8") == DUMMY_RESULT_PASSPHRASE 

544 ), "expected known output" 

545 

546 @Parametrize.CONFIG_WITH_PHRASE (empty)

547 def test_phrase_from_config( (empty)

548 self, 

549 config: _types.VaultConfig, 

550 ) -> None: 

551 """A stored configured master passphrase will be used.""" 

552 self._test(["--", DUMMY_SERVICE], config=config) 1 ctx1k

553 

554 @Parametrize.AUTO_PROMPT (empty)

555 def test_phrase_from_command_line( (empty)

556 self, 

557 auto_prompt: bool, 

558 ) -> None: 

559 """A master passphrase requested on the command-line will be used.""" 

560 self._test( 1 ctx1i

561 ["-p", "--", DUMMY_SERVICE], 

562 auto_prompt=auto_prompt, 

563 multiline=True, 

564 ) 

565 

566 

567class TestKeyBasic: (empty)

568 """Tests for SSH key configuration: basic.""" 

569 

570 @contextlib.contextmanager (empty)

571 def _setup_environment( (empty)

572 self, 

573 /, 

574 *, 

575 config: _types.VaultConfig = { # noqa: B006 

576 "services": { 

577 DUMMY_SERVICE: {**DUMMY_CONFIG_SETTINGS}, 

578 }, 

579 }, 

580 main_config_str: str | None = None, 

581 registry: dict[str, _types.SSHAgentSocketProvider | str | None] 

582 | None = None, 

583 ) -> Generator[machinery.CliRunner, None, None]: 

584 runner = machinery.CliRunner(mix_stderr=False) 4 ctx1efdh

585 # TODO(the-13th-letter): Rewrite using parenthesized 

586 # with-statements. 

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

588 with contextlib.ExitStack() as stack: 4 ctx1efdh

589 monkeypatch = stack.enter_context(pytest.MonkeyPatch.context()) 4 ctx1efdh

590 stack.enter_context( 4 ctx1efdh

591 pytest_machinery.isolated_vault_config( 

592 monkeypatch=monkeypatch, 

593 runner=runner, 

594 vault_config=config, 

595 main_config_str=main_config_str, 

596 ) 

597 ) 

598 monkeypatch.setattr( 4 ctx1efdh

599 cli_helpers, 

600 "get_suitable_ssh_keys", 

601 callables.suitable_ssh_keys, 

602 ) 

603 monkeypatch.setattr( 4 ctx1efdh

604 vault.Vault, 

605 "phrase_from_key", 

606 callables.phrase_from_key, 

607 ) 

608 if registry is not None: 4 ctx1efdh

609 monkeypatch.setattr( 2 ctx1dh

610 socketprovider.SocketProvider, "registry", registry 

611 ) 

612 monkeypatch.setattr( 2 ctx1dh

613 ssh_agent.SSHAgentClient, 

614 "SOCKET_PROVIDERS", 

615 ("incorrect",), 

616 ) 

617 yield runner 4 ctx1efdh

618 

619 def _check_result( (empty)

620 self, result: machinery.ReadableResult, /, *, multiline: bool = False 

621 ) -> None: 

622 if multiline: 3 ctx1efd

623 assert result.clean_exit(), "expected clean exit" 1 ctx1e

624 else: 

625 assert result.clean_exit(empty_stderr=True), ( 2 ctx1fd

626 "expected clean exit and empty stderr" 

627 ) 

628 assert result.stdout, "expected program output" 3 ctx1efd

629 last_line = ( 3 ctx1efd

630 result.stdout.splitlines(keepends=True)[-1] 

631 if multiline 

632 else result.stdout 

633 ) 

634 assert ( 3 ctx1efd

635 last_line.rstrip("\n").encode("UTF-8") != DUMMY_RESULT_PASSPHRASE 

636 ), "known false output: phrase-based instead of key-based" 

637 assert last_line.rstrip("\n").encode("UTF-8") == DUMMY_RESULT_KEY1, ( 3 ctx1efd

638 "expected known output" 

639 ) 

640 

641 def _test( (empty)

642 self, 

643 command_line: list[str], 

644 /, 

645 *, 

646 config: _types.VaultConfig = { # noqa: B006 

647 "services": {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS} 

648 }, 

649 main_config_str: str | None = None, 

650 registry: dict[str, _types.SSHAgentSocketProvider | str | None] 

651 | None = None, 

652 multiline: bool = False, 

653 input: str | bytes | None = None, 

654 ) -> None: 

655 with self._setup_environment( 3 ctx1efd

656 config=config, main_config_str=main_config_str, registry=registry 

657 ) as runner: 

658 result = runner.invoke( 3 ctx1efd

659 cli.derivepassphrase_vault, 

660 command_line, 

661 input=input, 

662 catch_exceptions=False, 

663 ) 

664 self._check_result(result, multiline=multiline) 3 ctx1efd

665 

666 @Parametrize.CONFIG_WITH_KEY (empty)

667 def test_key_from_config( (empty)

668 self, 

669 running_ssh_agent: data.RunningSSHAgentInfo, 

670 config: _types.VaultConfig, 

671 ) -> None: 

672 """A stored configured SSH key will be used.""" 

673 del running_ssh_agent 1 ctx1f

674 self._test(["--", DUMMY_SERVICE], config=config) 1 ctx1f

675 

676 def test_key_from_command_line( (empty)

677 self, 

678 running_ssh_agent: data.RunningSSHAgentInfo, 

679 ) -> None: 

680 """An SSH key requested on the command-line will be used.""" 

681 del running_ssh_agent 1 ctx1e

682 self._test(["-k", "--", DUMMY_SERVICE], input="1\n", multiline=True) 1 ctx1e

683 

684 

685@pytest.fixture (empty)

686def provider_registry() -> dict[ (empty)

687 str, _types.SSHAgentSocketProvider | str | None 

688]: 

689 """Set up a controlled SSH agent socket provider registry.""" 

690 

691 def err() -> _types.SSHAgentSocket: (empty)

692 pytest.fail("Attempting to use the wrong SSH agent socket provider!") 

693 

694 return { (empty)

695 "correct": machinery.StubbedSSHAgentSocket, 

696 "incorrect": err, 

697 } 

698 

699 

700# TODO(the-13th-letter): Rewrite the parametrization to be somewhat more 

701# transparent, but keep it this high-level if possible. 

702class TestKeyExplicitSSHAgentSocketProvider(TestKeyBasic): (empty)

703 """Tests for SSH key configuration: explicit SSH agent socket providers.""" 

704 

705 ARG = "--ssh-agent-socket-provider=correct" (empty)

706 ARG_NONEXISTANT = "--ssh-agent-socket-provider=nonexistant" (empty)

707 MAIN_CONFIG_STR = textwrap.dedent(r""" (empty)

708 [vault] 

709 ssh-agent-socket-provider = "correct" 

710 """) 

711 WRONG_CONFIG_STR = textwrap.dedent(r""" (empty)

712 [vault] 

713 ssh-agent-socket-provider = "incorrect" 

714 """) 

715 NONEXISTANT_CONFIG_STR = textwrap.dedent(r""" (empty)

716 [vault] 

717 ssh-agent-socket-provider = "nonexistant" 

718 """) 

719 

720 @Parametrize.EXPLICIT_SSH_AGENT_SOCKET_PROVIDER (empty)

721 @Parametrize.CONFIG_WITH_KEY (empty)

722 def test_explicit_ssh_agent_socket_provider( (empty)

723 self, 

724 provider_registry: dict[ 

725 str, _types.SSHAgentSocketProvider | str | None 

726 ], 

727 config: _types.VaultConfig, 

728 on_command_line: bool, 

729 in_config: bool, 

730 ) -> None: 

731 args = [self.ARG] if on_command_line else [] 1 ctx1d

732 main_config_str = ( 1 ctx1d

733 self.WRONG_CONFIG_STR 

734 if in_config and on_command_line 

735 else self.MAIN_CONFIG_STR 

736 if in_config 

737 else None 

738 ) 

739 self._test( 1 ctx1d

740 [*args, "--", DUMMY_SERVICE], 

741 config=config, 

742 registry=provider_registry, 

743 main_config_str=main_config_str, 

744 ) 

745 

746 @Parametrize.EXPLICIT_SSH_AGENT_SOCKET_PROVIDER (empty)

747 @Parametrize.CONFIG_WITH_KEY (empty)

748 def test_explicit_ssh_agent_socket_provider_not_found( (empty)

749 self, 

750 provider_registry: dict[ 

751 str, _types.SSHAgentSocketProvider | str | None 

752 ], 

753 config: _types.VaultConfig, 

754 on_command_line: bool, 

755 in_config: bool, 

756 ) -> None: 

757 assert "nonexistant" not in provider_registry, ( 1 ctx1h

758 '"nonexistant" name actually found in registry?!' 

759 ) 

760 args = [self.ARG_NONEXISTANT] if on_command_line else [] 1 ctx1h

761 main_config_str = ( 1 ctx1h

762 self.MAIN_CONFIG_STR 

763 if in_config and on_command_line 

764 else self.NONEXISTANT_CONFIG_STR 

765 if in_config 

766 else None 

767 ) 

768 with self._setup_environment( 1 ctx1h

769 config=config, 

770 registry=provider_registry, 

771 main_config_str=main_config_str, 

772 ) as runner: 

773 result = runner.invoke( 1 ctx1h

774 cli.derivepassphrase_vault, 

775 [*args, "--", DUMMY_SERVICE], 

776 catch_exceptions=False, 

777 ) 

778 assert result.error_exit( 1 ctx1h

779 error=" is not in derivepassphrase's provider registry." 

780 ) 

781 

782 

783class TestPhraseAndKeyOverriding: (empty)

784 """Tests for master passphrase and SSH key configuration: overriding.""" 

785 

786 def _test( (empty)

787 self, 

788 command_line: list[str], 

789 /, 

790 *, 

791 config: _types.VaultConfig = { # noqa: B006 

792 "services": {DUMMY_SERVICE: DUMMY_CONFIG_SETTINGS} 

793 }, 

794 input: str | bytes | None = None, 

795 ) -> machinery.ReadableResult: 

796 runner = machinery.CliRunner(mix_stderr=False) 3 ctx1ljc

797 # TODO(the-13th-letter): Rewrite using parenthesized 

798 # with-statements. 

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

800 with contextlib.ExitStack() as stack: 3 ctx1ljc

801 monkeypatch = stack.enter_context(pytest.MonkeyPatch.context()) 3 ctx1ljc