From 68f28e67646e1275b88f1b8a0807ba74eaa5a7be Mon Sep 17 00:00:00 2001 From: ai-bot Date: Sun, 4 Oct 2026 11:29:33 +0000 Subject: [PATCH] Cover the address path comparison, the settings, the rotation and the acknowledgement validation (section 25.7) --- tests/test_validation.py | 635 ++++++++++++++++++++++++++++++++------- 1 file changed, 527 insertions(+), 108 deletions(-) diff --git a/tests/test_validation.py b/tests/test_validation.py index 740d0f5..2c308b3 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -5,23 +5,32 @@ import unittest from validation import ( ValidationError, next_check_due, + validate_acknowledgement, validate_health_check, + validate_key_settings, validate_key_setup, + validate_rotation, + validate_wallet_software, ) +# The address path the keys are configured with (section 25.1). +ADDRESS_PATH = "m/48'/0'/0'/2'" KEYS = ( - {"id": 1, "key_number": 1, "name": "SeedSigner", "type": "hardware"}, - {"id": 2, "key_number": 2, "name": "Blockstream Jade", "type": "hardware"}, - {"id": 3, "key_number": 3, "name": "Nunchuk", "type": "cloud"}, + {"id": 1, "key_number": 1, "name": "SeedSigner", "type": "hardware", "address_path": ADDRESS_PATH}, + {"id": 2, "key_number": 2, "name": "Blockstream Jade", "type": "hardware", "address_path": ADDRESS_PATH}, + {"id": 3, "key_number": 3, "name": "Nunchuk", "type": "cloud", "address_path": ADDRESS_PATH}, ) -# A setup with the cloud key in the first slot and a renamed hardware key, to -# show that the type decides the checks and never the key number. +# A setup with the cloud key in the first slot, renamed hardware keys, and a +# different address path per key, to show that the comparison is per key and that +# the type decides the checks and never the key number. RENAMED_KEYS = ( - {"id": 1, "key_number": 1, "name": "Coinbase", "type": "cloud"}, - {"id": 2, "key_number": 2, "name": "ColdCard", "type": "hardware"}, - {"id": 3, "key_number": 3, "name": "Jade", "type": "hardware"}, + {"id": 1, "key_number": 1, "name": "Coinbase", "type": "cloud", "address_path": ADDRESS_PATH}, + {"id": 2, "key_number": 2, "name": "ColdCard", "type": "hardware", "address_path": "m/48'/1'/0'/2'"}, + {"id": 3, "key_number": 3, "name": "Jade", "type": "hardware", "address_path": "m/48'/2'/0'/2'"}, ) +# The wallet software list the settings hold (section 25.4). +SOFTWARE_NAMES = ("Sparrow Wallet",) def key_for(key_number, keys=KEYS): @@ -29,27 +38,43 @@ def key_for(key_number, keys=KEYS): return next(entry for entry in keys if entry["key_number"] == key_number) -def sample_payload(key_number=1, wallet_software=None, keys=KEYS): - """Return a valid single-key payload for the given key number.""" +def entry(key_number, name, key_type, address_path=ADDRESS_PATH): + """Return one key of a setup payload.""" + return { + "key_number": key_number, + "name": name, + "type": key_type, + "address_path": address_path, + } + + +def validate(payload, keys=KEYS, software_names=SOFTWARE_NAMES): + """Return a validated payload, with the settings list the app passes.""" + return validate_health_check(payload, keys, software_names) + + +def sample_payload(key_number=1, wallet_software=None, keys=KEYS, address_path=None): + """Return a valid single-key payload for the given key number. + + The recorded address path matches the stored one unless a test asks for + another one (section 25.1). + """ key = key_for(key_number, keys) if wallet_software is None: wallet_software = key["name"] if key["type"] == "cloud" else "Sparrow Wallet" labels = list(dict.fromkeys((key["name"], wallet_software))) - entry = { + entry_payload = { "key_id": key["id"], "available": 1, - "address_path_verified": "OK", - "address_path": "m/48'/0'/0'/2'/0/0", + "address_path": address_path if address_path is not None else key["address_path"], "comments": "", } if key["type"] == "hardware": - entry.update({ + entry_payload.update({ "hardware_works": 1, "firmware_version": "1.0.0", "seed_backup_verified": "OK", }) - else: - entry.update({"cloud_health_status": "OK", "cloud_provider_operational": 1}) return { "checked_at": "2026-10-01", "wallet_software": wallet_software, @@ -58,7 +83,7 @@ def sample_payload(key_number=1, wallet_software=None, keys=KEYS): "software_comments": "", "contact_info_verified": "Confirmed current", "comments": "Annual review", - "key_check": entry, + "key_check": entry_payload, "ai_security_checks": [ {"provider": label, "status": "SECURE", "comments": ""} for label in labels ], @@ -68,98 +93,114 @@ def sample_payload(key_number=1, wallet_software=None, keys=KEYS): def unavailable_payload(key_number=1, keys=KEYS): """Return the payload the form sends for a key that was not available.""" key = key_for(key_number, keys) - entry = { - "key_id": key["id"], - "available": 0, - "comments": "Key is with the third holder", - } - if key["type"] == "cloud": - # The form derives these from availability alone (section 20). - entry.update({"cloud_health_status": "PROBLEM", "cloud_provider_operational": 0}) return { "checked_at": "2026-10-01", "wallet_software": None, "software_compatibility_status": "NOT_ASSESSED", "contact_info_verified": "Needs external update", "comments": "Annual review", - "key_check": entry, + "key_check": { + "key_id": key["id"], + "available": 0, + "comments": "Key is with the third holder", + }, "ai_security_checks": [], } +def mismatch_payload(key_number=1, address_path="m/48'/9'/0'/2'", keys=KEYS): + """Return the minimal payload the form sends when the path does not match. + + Everything else about the key is left out, because the key could not be + checked (section 25.1). + """ + key = key_for(key_number, keys) + return { + "checked_at": "2026-10-01", + "contact_info_verified": "Confirmed current", + "comments": "Annual review", + "key_check": { + "key_id": key["id"], + "available": 1, + "address_path": address_path, + "comments": "Path read from the device", + }, + } + + class KeySetupTests(unittest.TestCase): def test_a_valid_setup_is_normalized_and_sorted(self): result = validate_key_setup({"keys": [ - {"key_number": 3, "name": " Nunchuk ", "type": "cloud"}, - {"key_number": 1, "name": "ColdCard", "type": "hardware"}, - {"key_number": 2, "name": "Jade", "type": "hardware"}, + entry(3, " Nunchuk ", "cloud"), + entry(1, "ColdCard", "hardware"), + entry(2, "Jade", "hardware"), ]}) self.assertEqual( result, [ - {"key_number": 1, "name": "ColdCard", "type": "hardware"}, - {"key_number": 2, "name": "Jade", "type": "hardware"}, - {"key_number": 3, "name": "Nunchuk", "type": "cloud"}, + entry(1, "ColdCard", "hardware"), + entry(2, "Jade", "hardware"), + entry(3, "Nunchuk", "cloud"), ], ) def test_all_three_keys_may_be_cloud_keys(self): result = validate_key_setup({"keys": [ - {"key_number": 1, "name": "Provider one", "type": "cloud"}, - {"key_number": 2, "name": "Provider two", "type": "cloud"}, - {"key_number": 3, "name": "Provider three", "type": "cloud"}, + entry(1, "Provider one", "cloud"), + entry(2, "Provider two", "cloud"), + entry(3, "Provider three", "cloud"), ]}) - self.assertEqual([entry["type"] for entry in result], ["cloud"] * 3) + self.assertEqual([item["type"] for item in result], ["cloud"] * 3) def test_duplicate_names_are_rejected_without_regard_to_case(self): for names in (("Jade", "Jade"), ("Jade", "jade"), ("Jade", " JADE ")): with self.assertRaises(ValidationError): validate_key_setup({"keys": [ - {"key_number": 1, "name": names[0], "type": "hardware"}, - {"key_number": 2, "name": names[1], "type": "hardware"}, - {"key_number": 3, "name": "Nunchuk", "type": "cloud"}, + entry(1, names[0], "hardware"), + entry(2, names[1], "hardware"), + entry(3, "Nunchuk", "cloud"), ]}) def test_an_empty_or_non_text_name_is_rejected(self): for name in ("", " ", None, 12): with self.assertRaises(ValidationError): validate_key_setup({"keys": [ - {"key_number": 1, "name": name, "type": "hardware"}, - {"key_number": 2, "name": "Jade", "type": "hardware"}, - {"key_number": 3, "name": "Nunchuk", "type": "cloud"}, + entry(1, name, "hardware"), + entry(2, "Jade", "hardware"), + entry(3, "Nunchuk", "cloud"), ]}) def test_an_over_long_name_is_rejected(self): with self.assertRaises(ValidationError): validate_key_setup({"keys": [ - {"key_number": 1, "name": "x" * 61, "type": "hardware"}, - {"key_number": 2, "name": "Jade", "type": "hardware"}, - {"key_number": 3, "name": "Nunchuk", "type": "cloud"}, + entry(1, "x" * 61, "hardware"), + entry(2, "Jade", "hardware"), + entry(3, "Nunchuk", "cloud"), ]}) def test_an_unknown_type_is_rejected(self): for key_type in ("", "hardware ", "cloudy", None): with self.assertRaises(ValidationError): validate_key_setup({"keys": [ - {"key_number": 1, "name": "ColdCard", "type": key_type}, - {"key_number": 2, "name": "Jade", "type": "hardware"}, - {"key_number": 3, "name": "Nunchuk", "type": "cloud"}, + entry(1, "ColdCard", key_type), + entry(2, "Jade", "hardware"), + entry(3, "Nunchuk", "cloud"), ]}) def test_a_repeated_or_unknown_key_number_is_rejected(self): for numbers in ((1, 1, 3), (1, 2, 4), (0, 2, 3), (1, 2, None), (1, 2, True)): with self.assertRaises(ValidationError): validate_key_setup({"keys": [ - {"key_number": numbers[0], "name": "ColdCard", "type": "hardware"}, - {"key_number": numbers[1], "name": "Jade", "type": "hardware"}, - {"key_number": numbers[2], "name": "Nunchuk", "type": "cloud"}, + entry(numbers[0], "ColdCard", "hardware"), + entry(numbers[1], "Jade", "hardware"), + entry(numbers[2], "Nunchuk", "cloud"), ]}) def test_the_wrong_number_of_keys_is_rejected(self): - entry = {"key_number": 1, "name": "ColdCard", "type": "hardware"} - for entries in ([], [entry], [entry, entry], [entry] * 4): + single = entry(1, "ColdCard", "hardware") + for entries in ([], [single], [single, single], [single] * 4): with self.assertRaises(ValidationError): validate_key_setup({"keys": entries}) @@ -168,10 +209,38 @@ class KeySetupTests(unittest.TestCase): with self.assertRaises(ValidationError): validate_key_setup(payload) + def test_the_address_path_is_required_for_every_key(self): + for value in ("", " ", None, 12): + with self.assertRaises(ValidationError): + validate_key_setup({"keys": [ + entry(1, "ColdCard", "hardware", value), + entry(2, "Jade", "hardware"), + entry(3, "Nunchuk", "cloud"), + ]}) + + def test_an_over_long_address_path_is_rejected(self): + with self.assertRaises(ValidationError): + validate_key_setup({"keys": [ + entry(1, "ColdCard", "hardware", "m/" + "x" * 200), + entry(2, "Jade", "hardware"), + entry(3, "Nunchuk", "cloud"), + ]}) + + def test_two_keys_may_share_an_address_path(self): + # The three keys of one multisig setup normally share their derivation + # path, so the path is not unique (section 25.1). + result = validate_key_setup({"keys": [ + entry(1, "ColdCard", "hardware"), + entry(2, "Jade", "hardware"), + entry(3, "Nunchuk", "cloud"), + ]}) + + self.assertEqual([item["address_path"] for item in result], [ADDRESS_PATH] * 3) + class ValidationTests(unittest.TestCase): def test_valid_payload_is_normalized(self): - result = validate_health_check(sample_payload(), KEYS) + result = validate(sample_payload()) self.assertEqual(result["checked_at"], "2026-10-01") self.assertEqual(result["comments"], "Annual review") @@ -180,19 +249,19 @@ class ValidationTests(unittest.TestCase): self.assertEqual(len(result["ai_security_checks"]), 2) def test_the_configured_name_is_the_product_label(self): - result = validate_health_check(sample_payload(key_number=2, keys=RENAMED_KEYS), RENAMED_KEYS) + result = validate(sample_payload(key_number=2, keys=RENAMED_KEYS), RENAMED_KEYS) self.assertEqual(result["wallet_software"], "Sparrow Wallet") self.assertEqual( - [entry["provider"] for entry in result["ai_security_checks"]], + [item["provider"] for item in result["ai_security_checks"]], ["ColdCard", "Sparrow Wallet"], ) def test_a_cloud_key_records_its_own_name_once(self): - result = validate_health_check(sample_payload(key_number=1, keys=RENAMED_KEYS), RENAMED_KEYS) + result = validate(sample_payload(key_number=1, keys=RENAMED_KEYS), RENAMED_KEYS) self.assertEqual(result["wallet_software"], "Coinbase") - self.assertEqual([entry["provider"] for entry in result["ai_security_checks"]], ["Coinbase"]) + self.assertEqual([item["provider"] for item in result["ai_security_checks"]], ["Coinbase"]) self.assertIsNone(result["key_check"]["hardware_works"]) self.assertIsNone(result["key_check"]["seed_backup_verified"]) @@ -204,11 +273,11 @@ class ValidationTests(unittest.TestCase): for label in ("ColdCard", "Coinbase") ] - result = validate_health_check(payload, RENAMED_KEYS) + result = validate(payload, RENAMED_KEYS) self.assertEqual(result["wallet_software"], "Coinbase") self.assertEqual( - [entry["provider"] for entry in result["ai_security_checks"]], + [item["provider"] for item in result["ai_security_checks"]], ["ColdCard", "Coinbase"], ) @@ -218,20 +287,36 @@ class ValidationTests(unittest.TestCase): payload["wallet_software"] = "Jade" with self.assertRaises(ValidationError): - validate_health_check(payload, RENAMED_KEYS) + validate(payload, RENAMED_KEYS) + + def test_the_wallet_software_choices_are_the_settings_list_and_the_cloud_keys(self): + # A name from the settings list is a choice for a hardware key, and a + # name that is in neither is not (section 25.4). + payload = sample_payload() + payload["wallet_software"] = "BlueWallet" + payload["ai_security_checks"] = [ + {"provider": label, "status": "SECURE", "comments": ""} + for label in ("SeedSigner", "BlueWallet") + ] + + result = validate(payload, KEYS, ("BlueWallet",)) + self.assertEqual(result["wallet_software"], "BlueWallet") + + with self.assertRaises(ValidationError): + validate(payload) def test_a_cloud_key_rejects_another_wallet_software(self): for value in ("Sparrow Wallet", "ColdCard"): payload = sample_payload(key_number=1, keys=RENAMED_KEYS) payload["wallet_software"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, RENAMED_KEYS) + validate(payload, RENAMED_KEYS) def test_next_check_due_is_derived_on_the_server(self): payload = sample_payload() payload["next_check_due"] = "1999-01-01" - result = validate_health_check(payload, KEYS) + result = validate(payload) self.assertEqual(result["next_check_due"], "2027-10-01") @@ -243,7 +328,7 @@ class ValidationTests(unittest.TestCase): payload = sample_payload() payload["software_version"] = " " - result = validate_health_check(payload, KEYS) + result = validate(payload) self.assertIsNone(result["software_version"]) @@ -252,14 +337,14 @@ class ValidationTests(unittest.TestCase): payload = sample_payload() payload["checked_at"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_unsupported_status_is_rejected(self): payload = sample_payload() payload["software_compatibility_status"] = "MAYBE" with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_compatibility_status_requires_an_explicit_choice(self): # "not assessed" is no longer submittable for a new registration @@ -268,14 +353,14 @@ class ValidationTests(unittest.TestCase): payload = sample_payload() payload["software_compatibility_status"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_compatibility_status_accepts_ok_and_problem(self): for value in ("OK", "PROBLEM"): payload = sample_payload() payload["software_compatibility_status"] = value self.assertEqual( - validate_health_check(payload, KEYS)["software_compatibility_status"], + validate(payload)["software_compatibility_status"], value, ) @@ -283,7 +368,7 @@ class ValidationTests(unittest.TestCase): payload = sample_payload(key_number=3) payload["software_compatibility_status"] = "OK" self.assertEqual( - validate_health_check(payload, KEYS)["software_compatibility_status"], + validate(payload)["software_compatibility_status"], "OK", ) @@ -291,29 +376,27 @@ class ValidationTests(unittest.TestCase): payload = sample_payload(key_number=3) payload["software_compatibility_status"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_unavailable_key_keeps_the_derived_compatibility(self): payload = unavailable_payload() payload["software_compatibility_status"] = "NOT_ASSESSED" self.assertEqual( - validate_health_check(payload, KEYS)["software_compatibility_status"], + validate(payload)["software_compatibility_status"], "NOT_ASSESSED", ) payload["software_compatibility_status"] = "OK" with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_not_assessed_is_only_the_derived_compatibility(self): - # No other field offers or accepts NOT_ASSESSED (section 24.1). The - # cloud health result is derived from availability, so it is only ever - # OK or PROBLEM. - payload = sample_payload(key_number=3) - payload["key_check"]["cloud_health_status"] = "NOT_ASSESSED" + # No other field offers or accepts NOT_ASSESSED (section 24.1). + payload = sample_payload() + payload["key_check"]["seed_backup_verified"] = "NOT_ASSESSED" with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_hardware_works_is_required_for_an_available_hardware_key(self): # Hardware works requires an active Yes or No (section 24.1). @@ -321,19 +404,19 @@ class ValidationTests(unittest.TestCase): payload = sample_payload() payload["key_check"]["hardware_works"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) payload = sample_payload() del payload["key_check"]["hardware_works"] with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_hardware_works_accepts_yes_and_no(self): for value in (1, 0): payload = sample_payload() payload["key_check"]["hardware_works"] = value self.assertEqual( - validate_health_check(payload, KEYS)["key_check"]["hardware_works"], + validate(payload)["key_check"]["hardware_works"], value, ) @@ -342,7 +425,7 @@ class ValidationTests(unittest.TestCase): payload = sample_payload() payload["contact_info_verified"] = value self.assertEqual( - validate_health_check(payload, KEYS)["contact_info_verified"], value + validate(payload)["contact_info_verified"], value ) def test_contact_status_is_required_and_never_a_flag(self): @@ -352,24 +435,24 @@ class ValidationTests(unittest.TestCase): for value in ("", None): payload["contact_info_verified"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) del payload["contact_info_verified"] with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) # The old 0/1 flag is no longer a valid value (section 23.1). for value in (1, 0, True, "yes"): payload = sample_payload() payload["contact_info_verified"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_security_status_must_use_the_four_english_values(self): for value in ("TRYGG", "UNKNOWN", ""): payload = sample_payload() payload["ai_security_checks"][0]["status"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_security_labels_are_specific_to_the_selected_key(self): payload = sample_payload(key_number=1) @@ -380,42 +463,127 @@ class ValidationTests(unittest.TestCase): ] with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_unknown_key_id_is_rejected(self): payload = sample_payload() payload["key_check"]["key_id"] = 99 with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_missing_key_check_is_rejected(self): payload = sample_payload() del payload["key_check"] with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) + + def test_the_server_sets_the_address_path_verification(self): + result = validate(sample_payload()) + + self.assertEqual(result["key_check"]["address_path"], ADDRESS_PATH) + self.assertEqual(result["key_check"]["address_path_verified"], "OK") + + def test_the_address_path_is_compared_after_stripping(self): + payload = sample_payload() + payload["key_check"]["address_path"] = f" {ADDRESS_PATH} " + + result = validate(payload) + + self.assertEqual(result["key_check"]["address_path"], ADDRESS_PATH) + self.assertEqual(result["key_check"]["address_path_verified"], "OK") + + def test_a_different_address_path_makes_the_key_uncheckable(self): + result = validate(mismatch_payload(1, "m/48'/9'/0'/2'")) + key_check = result["key_check"] + + # The recorded path and the key note are kept, while the rest of the + # check is empty and the compatibility stays not assessed + # (section 25.1). + self.assertEqual(key_check["address_path"], "m/48'/9'/0'/2'") + self.assertEqual(key_check["address_path_verified"], "PROBLEM") + self.assertEqual(key_check["comments"], "Path read from the device") + self.assertEqual(key_check["available"], 1) + self.assertIsNone(key_check["hardware_works"]) + self.assertIsNone(key_check["firmware_version"]) + self.assertIsNone(key_check["seed_backup_verified"]) + self.assertIsNone(result["wallet_software"]) + self.assertEqual(result["software_compatibility_status"], "NOT_ASSESSED") + self.assertEqual(result["ai_security_checks"], []) + self.assertEqual(result["contact_info_verified"], "Confirmed current") + self.assertEqual(result["comments"], "Annual review") + + def test_a_mismatched_submission_rejects_recorded_results(self): + recorded = ( + ("wallet_software", "Sparrow Wallet"), + ("ai_security_checks", [ + {"provider": "SeedSigner", "status": "SECURE", "comments": ""} + ]), + ("software_compatibility_status", "OK"), + ) + for field, value in recorded: + payload = mismatch_payload() + payload[field] = value + with self.assertRaises(ValidationError): + validate(payload) + + def test_the_path_of_another_key_does_not_match(self): + # The comparison uses the selected key's own path (section 25.1). + with self.assertRaises(ValidationError): + validate(mismatch_payload(2, ADDRESS_PATH, RENAMED_KEYS), RENAMED_KEYS) + + result = validate( + mismatch_payload(2, "m/48'/1'/0'/2'", RENAMED_KEYS), RENAMED_KEYS + ) + self.assertEqual(result["key_check"]["address_path_verified"], "OK") + + def test_a_submitted_verification_result_is_ignored(self): + # The client never sends the result, and the server overrules it anyway + # (section 25.1). + payload = mismatch_payload() + payload["key_check"]["address_path_verified"] = "OK" + self.assertEqual(validate(payload)["key_check"]["address_path_verified"], "PROBLEM") + + payload = sample_payload() + payload["key_check"]["address_path_verified"] = "PROBLEM" + self.assertEqual(validate(payload)["key_check"]["address_path_verified"], "OK") + + def test_an_unavailable_key_never_reports_a_mismatch(self): + # A key that was not available records no path at all, so nothing is + # compared (sections 22 and 25.1). + result = validate(unavailable_payload()) + + self.assertIsNone(result["key_check"]["address_path"]) + self.assertIsNone(result["key_check"]["address_path_verified"]) + + def test_a_missing_address_path_does_not_match_a_stored_one(self): + payload = mismatch_payload() + del payload["key_check"]["address_path"] + + result = validate(payload) + + self.assertEqual(result["key_check"]["address_path_verified"], "PROBLEM") def test_verification_status_is_required_when_the_key_is_available(self): - for field in ("seed_backup_verified", "address_path_verified"): - payload = sample_payload() - payload["key_check"][field] = "" - with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + payload = sample_payload() + payload["key_check"]["seed_backup_verified"] = "" + with self.assertRaises(ValidationError): + validate(payload) def test_verification_status_rejects_not_assessed(self): payload = sample_payload() payload["key_check"]["seed_backup_verified"] = "NOT_ASSESSED" with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_availability_is_required(self): for value in ("", None): payload = sample_payload() payload["key_check"]["available"] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_a_minimal_unavailable_payload_is_accepted(self): # The check date, the key check, and the contact confirmation are the @@ -427,7 +595,7 @@ class ValidationTests(unittest.TestCase): "key_check": {"key_id": 1, "available": 0}, } - result = validate_health_check(payload, KEYS) + result = validate(payload) self.assertEqual(result["next_check_due"], "2027-10-01") self.assertEqual(result["key_check"]["available"], 0) @@ -446,7 +614,7 @@ class ValidationTests(unittest.TestCase): payload = unavailable_payload() payload[field] = value with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) def test_an_unavailable_hardware_key_records_nothing_else(self): payload = unavailable_payload() @@ -454,11 +622,10 @@ class ValidationTests(unittest.TestCase): "hardware_works": 1, "firmware_version": "1.0.0", "seed_backup_verified": "PROBLEM", - "address_path_verified": "PROBLEM", - "address_path": "m/48'/0'/0'/2'/0/0", + "address_path": ADDRESS_PATH, }) - result = validate_health_check(payload, KEYS) + result = validate(payload) self.assertEqual(result["key_check"]["available"], 0) self.assertIsNone(result["key_check"]["hardware_works"]) @@ -468,18 +635,16 @@ class ValidationTests(unittest.TestCase): self.assertIsNone(result["key_check"]["address_path"]) self.assertEqual(result["key_check"]["comments"], "Key is with the third holder") - def test_an_unavailable_cloud_key_keeps_its_derived_cloud_results(self): + def test_an_unavailable_cloud_key_records_nothing_else(self): payload = unavailable_payload(key_number=3) payload["key_check"].update({ - "address_path_verified": "PROBLEM", - "address_path": "m/48'/0'/0'/2'/0/0", + "address_path": ADDRESS_PATH, + "comments": "Key is with the third holder", }) - result = validate_health_check(payload, KEYS) + result = validate(payload) self.assertEqual(result["key_check"]["available"], 0) - self.assertEqual(result["key_check"]["cloud_health_status"], "PROBLEM") - self.assertEqual(result["key_check"]["cloud_provider_operational"], 0) self.assertIsNone(result["key_check"]["address_path_verified"]) self.assertIsNone(result["key_check"]["address_path"]) self.assertEqual(result["software_compatibility_status"], "NOT_ASSESSED") @@ -490,7 +655,261 @@ class ValidationTests(unittest.TestCase): payload["comments"] = "x" * 4001 with self.assertRaises(ValidationError): - validate_health_check(payload, KEYS) + validate(payload) + + +class KeySettingsTests(unittest.TestCase): + def test_a_new_name_and_path_are_normalized(self): + result = validate_key_settings( + {"key_id": 1, "name": " ColdCard ", "address_path": f" {ADDRESS_PATH} "}, + KEYS, + ) + + self.assertEqual(result, {"key_id": 1, "name": "ColdCard", "address_path": ADDRESS_PATH}) + + def test_the_type_is_never_part_of_the_settings(self): + # The type is locked and cannot be changed through the settings + # (section 25.2). + result = validate_key_settings( + {"key_id": 1, "name": "ColdCard", "address_path": ADDRESS_PATH, "type": "cloud"}, + KEYS, + ) + + self.assertNotIn("type", result) + + def test_an_unknown_key_is_rejected(self): + for key_id in (99, None, "1", True): + with self.assertRaises(ValidationError): + validate_key_settings( + {"key_id": key_id, "name": "ColdCard", "address_path": ADDRESS_PATH}, + KEYS, + ) + + def test_the_name_is_required_and_must_be_unique(self): + for name in ("", " ", None, 12, "x" * 61): + with self.assertRaises(ValidationError): + validate_key_settings( + {"key_id": 1, "name": name, "address_path": ADDRESS_PATH}, KEYS + ) + + # A name that repeats another key's name is refused without regard to + # case, while the key's own name is of course allowed (section 25.2). + for name in ("Nunchuk", "nunchuk", " NUNCHUK "): + with self.assertRaises(ValidationError): + validate_key_settings( + {"key_id": 1, "name": name, "address_path": ADDRESS_PATH}, KEYS + ) + + result = validate_key_settings( + {"key_id": 3, "name": "Nunchuk", "address_path": ADDRESS_PATH}, KEYS + ) + self.assertEqual(result["name"], "Nunchuk") + + def test_the_address_path_is_required(self): + for value in ("", " ", None, 12, "m/" + "x" * 200): + with self.assertRaises(ValidationError): + validate_key_settings( + {"key_id": 1, "name": "ColdCard", "address_path": value}, KEYS + ) + + def test_a_missing_or_wrong_payload_is_rejected(self): + for payload in ({}, [], {"key_id": 1}, {"name": "ColdCard"}): + with self.assertRaises(ValidationError): + validate_key_settings(payload, KEYS) + + +class WalletSoftwareTests(unittest.TestCase): + def test_a_valid_list_is_normalized(self): + result = validate_wallet_software( + {"wallet_software": [" Sparrow Wallet ", "BlueWallet"]}, KEYS + ) + + self.assertEqual(result, ["Sparrow Wallet", "BlueWallet"]) + + def test_sparrow_may_be_replaced_by_another_name(self): + # The list may not be emptied, but the entry a new database starts with + # may be replaced once another name has been added (section 25.4). + result = validate_wallet_software({"wallet_software": ["BlueWallet"]}, KEYS) + + self.assertEqual(result, ["BlueWallet"]) + + def test_an_empty_list_is_rejected(self): + with self.assertRaises(ValidationError): + validate_wallet_software({"wallet_software": []}, KEYS) + + def test_a_missing_or_wrong_list_is_rejected(self): + for payload in ({}, [], {"wallet_software": None}, {"wallet_software": "Sparrow Wallet"}): + with self.assertRaises(ValidationError): + validate_wallet_software(payload, KEYS) + + def test_an_empty_or_over_long_name_is_rejected(self): + for value in ("", " ", None, 12, "x" * 61): + with self.assertRaises(ValidationError): + validate_wallet_software({"wallet_software": [value]}, KEYS) + + def test_a_repeated_name_is_rejected_without_regard_to_case(self): + for names in (["BlueWallet", "BlueWallet"], ["BlueWallet", "bluewallet"]): + with self.assertRaises(ValidationError): + validate_wallet_software({"wallet_software": names}, KEYS) + + def test_a_cloud_key_name_is_rejected(self): + # A cloud key already provides its own name as a choice (section 25.4). + for name in ("Nunchuk", "nunchuk", " NUNCHUK "): + with self.assertRaises(ValidationError): + validate_wallet_software({"wallet_software": [name]}, KEYS) + + # A hardware key name is not a cloud key name, so it is allowed. + result = validate_wallet_software({"wallet_software": ["SeedSigner"]}, KEYS) + self.assertEqual(result, ["SeedSigner"]) + + +class RotationTests(unittest.TestCase): + def test_keeping_the_name_needs_no_name(self): + result = validate_rotation( + {"replaced": True, "address_path_unchanged": True, "keep_name": True}, KEYS, 1 + ) + + self.assertEqual(result, {"key_id": 1, "keep_name": True, "name": None}) + + def test_changing_the_name_requires_a_unique_non_empty_name(self): + for name in ("", " ", None, 12, "x" * 61, "Nunchuk", "nunchuk"): + with self.assertRaises(ValidationError): + validate_rotation( + { + "replaced": True, + "address_path_unchanged": True, + "keep_name": False, + "name": name, + }, + KEYS, + 1, + ) + + result = validate_rotation( + { + "replaced": True, + "address_path_unchanged": True, + "keep_name": False, + "name": " ColdCard ", + }, + KEYS, + 1, + ) + self.assertEqual(result, {"key_id": 1, "keep_name": False, "name": "ColdCard"}) + + def test_the_two_confirmations_are_required(self): + for field in ("replaced", "address_path_unchanged"): + for value in (None, False, 0, 1, "yes", "true"): + payload = { + "replaced": True, + "address_path_unchanged": True, + "keep_name": True, + } + payload[field] = value + with self.assertRaises(ValidationError): + validate_rotation(payload, KEYS, 1) + + def test_keep_name_must_be_a_boolean(self): + for value in (None, "yes", 1, 0, ""): + with self.assertRaises(ValidationError): + validate_rotation( + { + "replaced": True, + "address_path_unchanged": True, + "keep_name": value, + }, + KEYS, + 1, + ) + + def test_an_unknown_key_is_rejected(self): + for key_id in (99, None, "1", True): + with self.assertRaises(ValidationError): + validate_rotation( + {"replaced": True, "address_path_unchanged": True, "keep_name": True}, + KEYS, + key_id, + ) + + def test_the_type_and_the_path_are_never_part_of_the_rotation(self): + # The type is locked and the path must be confirmed as unchanged, so + # neither is read from the payload (section 25.2). + result = validate_rotation( + { + "replaced": True, + "address_path_unchanged": True, + "keep_name": True, + "type": "cloud", + "address_path": "m/48'/9'/0'/2'", + }, + KEYS, + 1, + ) + + self.assertEqual(result, {"key_id": 1, "keep_name": True, "name": None}) + + +class AcknowledgementTests(unittest.TestCase): + def test_a_valid_acknowledgement_is_normalized(self): + result = validate_acknowledgement({ + "code": "address_path_mismatch", + "source": " Key 1: SeedSigner ", + "reason": " The key was replaced ", + }) + + self.assertEqual(result, { + "code": "address_path_mismatch", + "source": "Key 1: SeedSigner", + "reason": "The key was replaced", + }) + + def test_an_unknown_or_removed_code_is_rejected(self): + # The removed rules can no longer be triggered or acknowledged + # (section 25.3). + for code in ("cloud_provider_problem", "address_verification_failed", "UNKNOWN", "", None): + with self.assertRaises(ValidationError): + validate_acknowledgement({ + "code": code, + "source": "Key 1: SeedSigner", + "reason": "Done", + }) + + def test_the_source_and_the_reason_are_required(self): + for field in ("source", "reason"): + for value in ("", " ", None, 12): + payload = { + "code": "key_unavailable", + "source": "Key 1: SeedSigner", + "reason": "Done", + } + payload[field] = value + with self.assertRaises(ValidationError): + validate_acknowledgement(payload) + + payload = {"code": "key_unavailable", "source": "Key 1: SeedSigner", "reason": "Done"} + del payload[field] + with self.assertRaises(ValidationError): + validate_acknowledgement(payload) + + def test_over_long_text_is_rejected(self): + with self.assertRaises(ValidationError): + validate_acknowledgement({ + "code": "key_unavailable", + "source": "Key 1: SeedSigner", + "reason": "x" * 2001, + }) + + with self.assertRaises(ValidationError): + validate_acknowledgement({ + "code": "key_unavailable", + "source": "x" * 201, + "reason": "Done", + }) + + def test_a_missing_or_wrong_payload_is_rejected(self): + for payload in ({}, [], {"code": "key_unavailable"}): + with self.assertRaises(ValidationError): + validate_acknowledgement(payload) if __name__ == "__main__":