fix: use MissingKeyTypeError, InvalidKeyIdError errors

Author: lepture

src/joserfc/_keys.py

@@ -6,6 +6,7 @@
 from .rfc7518.rsa_key import RSAKey
 from .rfc7518.ec_key import ECKey
 from .rfc8037.okp_key import OKPKey
+from .errors import InvalidKeyIdError, InvalidKeyTypeError, MissingKeyTypeError
 from .util import to_bytes
 
 __all__ = [
@@ -62,10 +63,10 @@ def import_key(
             if "kty" in data:
                 key_type = data["kty"]  # type: ignore[assignment]
             else:
-                raise ValueError("Missing key type")
+                raise MissingKeyTypeError("Missing key type")
 
         if key_type not in cls.key_types:
-            raise ValueError(f'Invalid key type: "{key_type}"')
+            raise InvalidKeyTypeError(f'Invalid key type: "{key_type}"')
 
         if isinstance(data, str):
             data = to_bytes(data)
@@ -92,7 +93,7 @@ def generate_key(
             JWKRegistry.generate_key("EC", "P-256")
         """
         if key_type not in cls.key_types:
-            raise ValueError(f'Invalid key type: "{key_type}"')
+            raise InvalidKeyTypeError(f'Invalid key type: "{key_type}"')
 
         key_cls = cls.key_types[key_type]
         return key_cls.generate_key(crv_or_size, parameters, private, auto_kid)  # type: ignore[arg-type]
@@ -138,7 +139,7 @@ def get_by_kid(self, kid: str | None = None) -> Key:
         for key in self.keys:
             if key.kid == kid:
                 return key
-        raise ValueError(f'No key for kid: "{kid}"')
+        raise InvalidKeyIdError(f'No key for kid: "{kid}"')
 
     def pick_random_key(self, algorithm: str) -> t.Optional[Key]:
         key_types = self.algorithm_keys.get(algorithm)

src/joserfc/errors.py

@@ -37,10 +37,18 @@ class InvalidKeyLengthError(JoseError):
     error = "invalid_key_length"
 
 
+class MissingKeyTypeError(JoseError):
+    error = "missing_key_type"
+
+
 class InvalidKeyTypeError(JoseError):
     error = "invalid_key_type"
 
 
+class InvalidKeyIdError(JoseError):
+    error = "invalid_key_id"
+
+
 class InvalidExchangeKeyError(JoseError):
     error = "invalid_exchange_key"
     description = "Invalid key for exchanging shared key"

tests/jwk/test_jwk_set.py

@@ -1,4 +1,6 @@
 from unittest import TestCase
+
+from joserfc.errors import InvalidKeyTypeError, InvalidKeyIdError
 from joserfc.jwk import KeySet, RSAKey, ECKey, OctKey
 from tests.keys import read_key
 
@@ -26,7 +28,7 @@ def test_generate_and_import_key_set(self):
         self.assertEqual(len(jwks2.keys), 4)
 
     def test_generate_key_set_errors(self):
-        self.assertRaises(ValueError, KeySet.generate_key_set, 'NOT_FOUND', 2048)
+        self.assertRaises(InvalidKeyTypeError, KeySet.generate_key_set, 'NOT_FOUND', 2048)
 
     def test_initialize_key_set(self):
         keys = []
@@ -57,7 +59,7 @@ def test_key_set_methods(self):
 
         k1 = key_set.get_by_kid(key["kid"])
         self.assertEqual(k1.kid, key["kid"])
-        self.assertRaises(ValueError, key_set.get_by_kid, "invalid")
+        self.assertRaises(InvalidKeyIdError, key_set.get_by_kid, "invalid")
 
         key_set = KeySet.generate_key_set("oct", 8, count=1)
         k2 = key_set.get_by_kid()

tests/jwk/test_key_methods.py

@@ -5,7 +5,7 @@
 from joserfc.errors import (
     UnsupportedKeyAlgorithmError,
     UnsupportedKeyUseError,
-    UnsupportedKeyOperationError,
+    UnsupportedKeyOperationError, InvalidKeyTypeError, MissingKeyTypeError, InvalidKeyIdError,
 )
 
 register_key_set()
@@ -66,14 +66,14 @@ def test_guess_key_set(self):
         guest = Guest()
         guest._headers["alg"] = "HS256"
 
-        self.assertRaises(ValueError, guess_key, key_set, guest)
+        self.assertRaises(InvalidKeyIdError, guess_key, key_set, guest)
         key1 = guess_key(key_set, guest, True)
         self.assertIsInstance(key1, OctKey)
         guess_key(key_set, guest)
 
         guest = Guest()
         guest._headers["alg"] = "RS256"
-        self.assertRaises(ValueError, guess_key, key_set, guest)
+        self.assertRaises(InvalidKeyIdError, guess_key, key_set, guest)
         key2 = guess_key(key_set, guest, True)
         self.assertIsInstance(key2, RSAKey)
 
@@ -98,12 +98,12 @@ def test_import_key(self):
         key = JWKRegistry.import_key(data)
         self.assertIsInstance(key, OctKey)
 
-        self.assertRaises(ValueError, JWKRegistry.import_key, "secret", "invalid")
+        self.assertRaises(InvalidKeyTypeError, JWKRegistry.import_key, "secret", "invalid")
 
     def test_generate_key(self):
         key = JWKRegistry.generate_key("oct", 8)
         self.assertIsInstance(key, OctKey)
-        self.assertRaises(ValueError, JWKRegistry.generate_key, "invalid", 8)
+        self.assertRaises(InvalidKeyTypeError, JWKRegistry.generate_key, "invalid", 8)
 
     def test_check_use(self):
         key = OctKey.import_key("secret", {"use": "sig"})
@@ -156,4 +156,4 @@ def test_check_ops(self):
         )
 
     def test_import_without_kty(self):
-        self.assertRaises(ValueError, JWKRegistry.import_key, {})
+        self.assertRaises(MissingKeyTypeError, JWKRegistry.import_key, {})