python-jsonrpc-lib 0.3.1__tar.gz → 0.3.2__tar.gz

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/.gitignore

@@ -5,4 +5,5 @@ htmlcov
 .ruff_cache
 .idea
 .vscode
-__pycache__
+__pycache__
+dist

python_jsonrpc_lib-0.3.2/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## 0.3.2
+
+**Bug fixes:**
+
+- `add_security_scheme`: replaced `**kwargs` with `options: dict` parameter, fixing inability to create `apiKey` schemes (conflicting `name` parameter, `in` as Python reserved word)
+- `_convert_value`: Union types containing multiple dataclasses now correctly try all variants instead of crashing on the first mismatch
+- `simplify_id` flag now consistently applies to JSONRPCError schema in OpenAPI output
+- `unregister()` now clears `.rpc` attribute, allowing re-registration of the same Method instance
+- `max_concurrent` parameter is now validated (`-1` or `>= 1`); previously `0` caused a silent deadlock
+- `version` parameter is now validated at init; invalid values like `'3.0'` raise `ValueError`
+- Fixed `bearer_format` typo in tests (should be `bearerFormat` per OpenAPI spec)
+- Fixed OpenAPI tutorial example to match actual generated output
+
+## 0.3.1 (First Public Release)
+
+- JSON-RPC 1.0 and 2.0 support
+- Dataclass-based parameter validation
+- Built-in OpenAPI generation
+- Hierarchical context support
+- Decorator API for prototyping
+- Async/sync methods
+- Batch request handling
+- Strict mode by default
+- Zero external dependencies

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Author
+Copyright (c) 2026 Andy Smith
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jsonrpc-lib
-Version: 0.3.1
+Version: 0.3.2
 Summary: Simple, yet solid - Type-safe JSON-RPC 1.0/2.0 with OpenAPI support
 Project-URL: Homepage, https://github.com/uandysmith/python-jsonrpc-lib
 Project-URL: Documentation, https://uandysmith.github.io/python-jsonrpc-lib/

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/docs/api-reference.md

@@ -279,7 +279,7 @@ yaml_str: str = generator.generate_yaml()
 generator.add_security_scheme(
     name: str,
     scheme_type: Literal["apiKey", "http", "oauth2", "openIdConnect"],
-    **kwargs,
+    options: dict[str, Any] | None = None,
 )
 
 # Add global header parameter
@@ -309,8 +309,7 @@ generator = OpenAPIGenerator(
 generator.add_security_scheme(
     "BearerAuth",
     scheme_type="http",
-    scheme="bearer",
-    bearerFormat="JWT",
+    options={"scheme": "bearer", "bearerFormat": "JWT"},
 )
 generator.add_security_requirement("BearerAuth")
 spec = generator.generate()
@@ -504,7 +503,20 @@ response = rpc.handle(
 
 ## Changelog
 
-### 1.0.0 (First Release)
+### 0.3.2
+
+**Bug fixes:**
+
+- `add_security_scheme`: replaced `**kwargs` with `options: dict` parameter, fixing inability to create `apiKey` schemes (conflicting `name` parameter, `in` as Python reserved word)
+- `_convert_value`: Union types containing multiple dataclasses now correctly try all variants instead of crashing on the first mismatch
+- `simplify_id` flag now consistently applies to JSONRPCError schema in OpenAPI output
+- `unregister()` now clears `.rpc` attribute, allowing re-registration of the same Method instance
+- `max_concurrent` parameter is now validated (`-1` or `>= 1`); previously `0` caused a silent deadlock
+- `version` parameter is now validated at init; invalid values like `'3.0'` raise `ValueError`
+- Fixed `bearer_format` typo in tests (should be `bearerFormat` per OpenAPI spec)
+- Fixed OpenAPI tutorial example to match actual generated output
+
+### 0.3.1 (First Public Release)
 
 - JSON-RPC 1.0 and 2.0 support
 - Dataclass-based parameter validation

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/docs/tutorial/07-openapi.md

@@ -67,28 +67,47 @@ import json
 print(json.dumps(spec, indent=2))
 ```
 
-**Generated OpenAPI Schema:**
+**Generated OpenAPI Schema (abbreviated):**
+
+Each method gets its own path using fragment syntax (`#method.name`), with separate
+request and response schemas in `components/schemas`:
 
 ```json title="openapi_output.json"
 {
-  "openapi": "3.0.0",
+  "openapi": "3.0.3",
   "info": {
     "title": "Calculator API",
     "version": "1.0.0",
     "description": "Simple calculator with JSON-RPC 2.0"
   },
   "paths": {
-    "/": {
+    "/jsonrpc#math.calculate": {
       "post": {
-        "summary": "JSON-RPC endpoint",
+        "operationId": "math_calculate",
+        "summary": "Perform a math operation.",
+        "tags": ["math"],
         "requestBody": {
+          "required": true,
           "content": {
             "application/json": {
-              "schema": {
-                "oneOf": [
-                  {"$ref": "#/components/schemas/CalculateRequest"},
-                  {"$ref": "#/components/schemas/GreetRequest"}
-                ]
+              "schema": {"$ref": "#/components/schemas/math.calculate_request"}
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful response",
+            "content": {
+              "application/json": {
+                "schema": {"$ref": "#/components/schemas/math.calculate_response"}
+              }
+            }
+          },
+          "default": {
+            "description": "JSON-RPC Error",
+            "content": {
+              "application/json": {
+                "schema": {"$ref": "#/components/schemas/JSONRPCError"}
               }
             }
           }
@@ -98,11 +117,12 @@ print(json.dumps(spec, indent=2))
   },
   "components": {
     "schemas": {
-      "CalculateRequest": {
+      "math.calculate_request": {
         "type": "object",
         "properties": {
-          "jsonrpc": {"type": "string", "enum": ["2.0"]},
-          "method": {"type": "string", "enum": ["calculate"]},
+          "jsonrpc": {"const": "2.0"},
+          "method": {"const": "math.calculate"},
+          "id": {"type": "integer"},
           "params": {
             "type": "object",
             "properties": {
@@ -111,10 +131,9 @@ print(json.dumps(spec, indent=2))
               "operation": {"type": "string"}
             },
             "required": ["x", "y", "operation"]
-          },
-          "id": {"type": "integer"}
+          }
         },
-        "required": ["jsonrpc", "method", "params", "id"]
+        "required": ["jsonrpc", "method", "id", "params"]
       }
     }
   }
@@ -412,25 +431,35 @@ generator = OpenAPIGenerator(rpc, title="Secure API", version="1.0.0")
 generator.add_security_scheme(
     "BearerAuth",
     scheme_type="http",
-    scheme="bearer",
-    bearerFormat="JWT",
+    options={"scheme": "bearer", "bearerFormat": "JWT"},
 )
 generator.add_security_requirement("BearerAuth")
 
+# API Key
+generator = OpenAPIGenerator(rpc, title="API Key API", version="1.0.0")
+generator.add_security_scheme(
+    "ApiKeyAuth",
+    scheme_type="apiKey",
+    options={"name": "X-API-Key", "in": "header"},
+)
+generator.add_security_requirement("ApiKeyAuth")
+
 # OAuth2
 generator = OpenAPIGenerator(rpc, title="OAuth API", version="1.0.0")
 generator.add_security_scheme(
     "OAuth2",
     scheme_type="oauth2",
-    flows={
-        "authorizationCode": {
-            "authorizationUrl": "https://example.com/oauth/authorize",
-            "tokenUrl": "https://example.com/oauth/token",
-            "scopes": {
-                "read": "Read access",
-                "write": "Write access",
-            },
-        }
+    options={
+        "flows": {
+            "authorizationCode": {
+                "authorizationUrl": "https://example.com/oauth/authorize",
+                "tokenUrl": "https://example.com/oauth/token",
+                "scopes": {
+                    "read": "Read access",
+                    "write": "Write access",
+                },
+            }
+        },
     },
 )
 generator.add_security_requirement("OAuth2", scopes=["read", "write"])

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-jsonrpc-lib"
-version = "0.3.1"
+version = "0.3.2"
 description = "Simple, yet solid - Type-safe JSON-RPC 1.0/2.0 with OpenAPI support"
 readme = "README.md"
 requires-python = ">=3.11"

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/src/jsonrpc/__init__.py

@@ -46,7 +46,7 @@ from .response import build_error_response, build_response, parse_response
 from .types import ErrorResponse, Request, Response, Version
 from .validation import validate_params, validate_result_type
 
-__version__ = '0.3.1'
+__version__ = '0.3.2'
 
 __all__ = [
     # Main classes

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/src/jsonrpc/jsonrpc.py

@@ -190,6 +190,12 @@ class JSONRPC:
             v1.0: allow_batch=False, allow_dict_params=False, allow_list_params=True
             v2.0: allow_batch=True, allow_dict_params=True, allow_list_params=True
         """
+        if version not in ('1.0', '2.0'):
+            raise ValueError(f"version must be '1.0' or '2.0', got {version!r}")
+
+        if max_concurrent is not None and max_concurrent != -1 and max_concurrent < 1:
+            raise ValueError(f'max_concurrent must be -1 (unlimited) or >= 1, got {max_concurrent}')
+
         self.version = version
         self.validate_results = validate_results
         self.context_type = context_type
@@ -615,9 +621,7 @@ class JSONRPC:
             return self.serialize(response)
 
         if self.max_batch != -1 and len(data) > self.max_batch:
-            error = InvalidRequestError(
-                f'Batch too large: {len(data)} requests, maximum is {self.max_batch}'
-            )
+            error = InvalidRequestError(f'Batch too large: {len(data)} requests, maximum is {self.max_batch}')
             response = build_error_response(error, None, self.version)
             return self.serialize(response)
 
@@ -646,9 +650,7 @@ class JSONRPC:
             return self.serialize(response)
 
         if self.max_batch != -1 and len(data) > self.max_batch:
-            error = InvalidRequestError(
-                f'Batch too large: {len(data)} requests, maximum is {self.max_batch}'
-            )
+            error = InvalidRequestError(f'Batch too large: {len(data)} requests, maximum is {self.max_batch}')
             response = build_error_response(error, None, self.version)
             return self.serialize(response)
 

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/src/jsonrpc/method.py

@@ -303,6 +303,8 @@ class MethodGroup:
     def unregister(self, name: str) -> None:
         """Unregister a method or subgroup by name.
 
+        Clears the `.rpc` attribute so the instance can be re-registered.
+
         Args:
             name: Method or subgroup name (not a path)
 
@@ -310,9 +312,12 @@ class MethodGroup:
             KeyError: If name not found in either methods or subgroups
         """
         if name in self._methods:
-            del self._methods[name]
+            method = self._methods.pop(name)
+            if hasattr(method, 'rpc'):
+                del method.rpc
         elif name in self._subgroups:
-            del self._subgroups[name]
+            subgroup = self._subgroups.pop(name)
+            subgroup._clear_rpc()
         else:
             raise KeyError(f"'{name}' not found in group '{self._name}'")
 
@@ -559,3 +564,15 @@ class MethodGroup:
 
         for subgroup in self._subgroups.values():
             subgroup._inject_rpc(rpc)
+
+    def _clear_rpc(self) -> None:
+        """Clear RPC reference from group and all children (recursive)."""
+        if hasattr(self, 'rpc'):
+            del self.rpc
+
+        for method in self._methods.values():
+            if hasattr(method, 'rpc'):
+                del method.rpc
+
+        for subgroup in self._subgroups.values():
+            subgroup._clear_rpc()

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/src/jsonrpc/openapi.py

@@ -174,25 +174,31 @@ class OpenAPIGenerator:
         self,
         name: str,
         scheme_type: Literal['apiKey', 'http', 'oauth2', 'openIdConnect'],
-        **kwargs: Any,
+        options: dict[str, Any] | None = None,
     ) -> None:
         """Add authentication/security scheme.
 
         Args:
             name: Scheme name (used in security requirements)
             scheme_type: Type of security scheme
-            **kwargs: Additional scheme properties (scheme, bearerFormat, in, name, etc.)
+            options: Additional scheme properties as a dict.
+                Keys are passed directly into the OpenAPI security scheme object.
 
         Example:
             >>> openapi.add_security_scheme(
             ...     "bearerAuth",
             ...     scheme_type="http",
-            ...     scheme="bearer",
-            ...     bearerFormat="JWT"
+            ...     options={"scheme": "bearer", "bearerFormat": "JWT"},
+            ... )
+            >>> openapi.add_security_scheme(
+            ...     "apiKeyAuth",
+            ...     scheme_type="apiKey",
+            ...     options={"name": "X-API-Key", "in": "header"},
             ... )
         """
         scheme: dict[str, Any] = {'type': scheme_type}
-        scheme.update(kwargs)
+        if options:
+            scheme.update(options)
         self.security_schemes[name] = scheme
 
     def add_header(
@@ -390,13 +396,7 @@ class OpenAPIGenerator:
                                 },
                                 'required': ['code', 'message'],
                             },
-                            'id': {
-                                'oneOf': [
-                                    {'type': 'string'},
-                                    {'type': 'integer'},
-                                    {'type': 'null'},
-                                ]
-                            },
+                            'id': self._error_id_schema(),
                         },
                         'required': ['jsonrpc', 'error', 'id'],
                     },
@@ -421,6 +421,12 @@ class OpenAPIGenerator:
             return {'type': 'integer'}
         return {'oneOf': [{'type': 'string'}, {'type': 'integer'}]}
 
+    def _error_id_schema(self) -> dict[str, Any]:
+        """Return JSON Schema for the error response id field (includes null)."""
+        if self.simplify_id:
+            return {'oneOf': [{'type': 'integer'}, {'type': 'null'}]}
+        return {'oneOf': [{'type': 'string'}, {'type': 'integer'}, {'type': 'null'}]}
+
     def _generate_method_request_schema(
         self,
         full_name: str,

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/src/jsonrpc/validation.py

@@ -226,7 +226,7 @@ def _convert_value(value: Any, expected_type: type, _depth: int = 0) -> Any:
             if arg is not type(None):
                 try:
                     return _convert_value(value, arg, _depth=_depth)
-                except (TypeError, ValueError):
+                except (TypeError, ValueError, InvalidParamsError):
                     continue
         return value
 

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/tests/test_internal_api.py

@@ -261,6 +261,60 @@ class TestJSONRPCFacade(unittest.TestCase):
         with self.assertRaises(MethodNotFoundError):
             rpc.call_method('math.add', {'a': 1, 'b': 2})
 
+    def test_unregister_method_then_reregister_same_instance(self):
+        """Test re-registering the same Method instance after unregister."""
+        rpc = JSONRPC(version='2.0')
+        math = MethodGroup()
+        add = AddMethod()
+        math.register('add', add)
+        rpc.register('math', math)
+
+        self.assertEqual(rpc.call_method('math.add', {'a': 1, 'b': 2}), 3)
+
+        rpc.unregister('math.add')
+        # Same instance should be re-registerable after unregister
+        math.register('add', add)
+        self.assertEqual(rpc.call_method('math.add', {'a': 5, 'b': 3}), 8)
+
+    def test_unregister_subgroup_clears_rpc_on_children(self):
+        """Test unregistering a subgroup clears .rpc on all nested methods."""
+        rpc = JSONRPC(version='2.0')
+        math = MethodGroup()
+        add = AddMethod()
+        sub = SubtractMethod()
+        math.register('add', add)
+        math.register('subtract', sub)
+        rpc.register('math', math)
+
+        self.assertTrue(hasattr(add, 'rpc'))
+        self.assertTrue(hasattr(sub, 'rpc'))
+
+        rpc.unregister('math')
+        self.assertFalse(hasattr(add, 'rpc'))
+        self.assertFalse(hasattr(sub, 'rpc'))
+
+    def test_invalid_version_raises_value_error(self):
+        """Test that invalid version raises ValueError."""
+        with self.assertRaises(ValueError) as ctx:
+            JSONRPC(version='3.0')
+        self.assertIn("'1.0' or '2.0'", str(ctx.exception))
+
+    def test_max_concurrent_zero_raises_value_error(self):
+        """Test that max_concurrent=0 raises ValueError."""
+        with self.assertRaises(ValueError) as ctx:
+            JSONRPC(max_concurrent=0)
+        self.assertIn('max_concurrent', str(ctx.exception))
+
+    def test_max_concurrent_negative_two_raises_value_error(self):
+        """Test that max_concurrent=-2 raises ValueError."""
+        with self.assertRaises(ValueError):
+            JSONRPC(max_concurrent=-2)
+
+    def test_max_concurrent_minus_one_is_valid(self):
+        """Test that max_concurrent=-1 (unlimited) is accepted."""
+        rpc = JSONRPC(max_concurrent=-1)
+        self.assertEqual(rpc._effective_max_concurrent, -1)
+
 
 class TestCallMethod(unittest.TestCase):
     """Comprehensive tests for call_method() internal API."""

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/tests/test_jsonrpc_v2.py

@@ -871,9 +871,7 @@ class TestJSONRPCV2DefensiveExceptionHandling(unittest.TestCase):
 
         # Patch _handle_single to raise — bypasses all internal error handling.
         with patch.object(self.rpc, '_handle_single', side_effect=RuntimeError('internal crash')):
-            response = self.rpc.handle(
-                '{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":1}'
-            )
+            response = self.rpc.handle('{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":1}')
         data = json.loads(response)
         self.assertEqual(data['error']['code'], -32603)
         self.assertIn('internal crash', data['error']['message'])
@@ -884,9 +882,7 @@ class TestJSONRPCV2DefensiveExceptionHandling(unittest.TestCase):
 
         with patch.object(self.rpc, '_handle_single_async', side_effect=RuntimeError('async crash')):
             response = asyncio.run(
-                self.rpc.handle_async(
-                    '{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":1}'
-                )
+                self.rpc.handle_async('{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":1}')
             )
         data = json.loads(response)
         self.assertEqual(data['error']['code'], -32603)
@@ -1136,9 +1132,7 @@ class TestJSONRPCV2SerializationHooks(unittest.TestCase):
 
         rpc = self._make_rpc()
         with patch.object(rpc, 'serialize', side_effect=self._failing_serialize(fail_on_call=1)):
-            response = rpc.handle(
-                '{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":42}'
-            )
+            response = rpc.handle('{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":42}')
         data = json.loads(response)
         self.assertEqual(data['error']['code'], -32603)
         self.assertIn('cannot serialize', data['error']['message'])
@@ -1151,9 +1145,7 @@ class TestJSONRPCV2SerializationHooks(unittest.TestCase):
         rpc = self._make_rpc()
         with patch.object(rpc, 'serialize', side_effect=self._failing_serialize(fail_on_call=1)):
             response = asyncio.run(
-                rpc.handle_async(
-                    '{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":42}'
-                )
+                rpc.handle_async('{"jsonrpc":"2.0","method":"math.add","params":{"a":1,"b":2},"id":42}')
             )
         data = json.loads(response)
         self.assertEqual(data['error']['code'], -32603)
@@ -1164,9 +1156,7 @@ class TestJSONRPCV2SerializationHooks(unittest.TestCase):
         from unittest.mock import patch
 
         rpc = self._make_rpc()
-        batch = json.dumps(
-            [{'jsonrpc': '2.0', 'method': 'math.add', 'params': {'a': 1, 'b': 2}, 'id': 1}]
-        )
+        batch = json.dumps([{'jsonrpc': '2.0', 'method': 'math.add', 'params': {'a': 1, 'b': 2}, 'id': 1}])
         with patch.object(rpc, 'serialize', side_effect=self._failing_serialize(fail_on_call=1)):
             response = rpc.handle(batch)
         data = json.loads(response)
@@ -1177,9 +1167,7 @@ class TestJSONRPCV2SerializationHooks(unittest.TestCase):
         from unittest.mock import patch
 
         rpc = self._make_rpc()
-        batch = json.dumps(
-            [{'jsonrpc': '2.0', 'method': 'math.add', 'params': {'a': 1, 'b': 2}, 'id': 1}]
-        )
+        batch = json.dumps([{'jsonrpc': '2.0', 'method': 'math.add', 'params': {'a': 1, 'b': 2}, 'id': 1}])
         with patch.object(rpc, 'serialize', side_effect=self._failing_serialize(fail_on_call=1)):
             response = asyncio.run(rpc.handle_async(batch))
         data = json.loads(response)
@@ -1219,6 +1207,7 @@ class TestV2Logging(unittest.TestCase):
 
     def test_async_notification_error_logged_at_debug(self):
         """Suppressed async notification errors are logged at DEBUG level."""
+
         class AsyncBrokenMethod(Method):
             async def execute(self, params: None) -> str:
                 raise RuntimeError('Async error!')

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/tests/test_openapi.py

@@ -649,6 +649,11 @@ class TestOpenAPISchemaValidation(unittest.TestCase):
         id_schema = add_request['properties']['id']
         self.assertEqual(id_schema, {'type': 'integer'})
 
+        # Error schema id should also respect simplify_id
+        error_schema = schemas['JSONRPCError']
+        error_id = error_schema['properties']['id']
+        self.assertEqual(error_id, {'oneOf': [{'type': 'integer'}, {'type': 'null'}]})
+
     def test_simplify_id_false_uses_oneof(self):
         """simplify_id=False produces oneOf[string, integer] for id fields."""
         generator = OpenAPIGenerator(self.rpc, simplify_id=False)
@@ -665,6 +670,12 @@ class TestOpenAPISchemaValidation(unittest.TestCase):
         add_response = schemas['math.add_response']
         self.assertEqual(add_response['properties']['id'], expected_id)
 
+        # Error schema id should include null
+        error_schema = schemas['JSONRPCError']
+        error_id = error_schema['properties']['id']
+        expected_error_id = {'oneOf': [{'type': 'string'}, {'type': 'integer'}, {'type': 'null'}]}
+        self.assertEqual(error_id, expected_error_id)
+
 
 class TestOpenAPITypeConversionEdgeCases(unittest.TestCase):
     """Tests for edge cases in type conversion to JSON Schema."""
@@ -817,7 +828,11 @@ class TestOpenAPISecurityAndHeaders(unittest.TestCase):
         generator = OpenAPIGenerator(rpc)
 
         # Add security scheme
-        generator.add_security_scheme(name='bearerAuth', scheme_type='http', scheme='bearer', bearer_format='JWT')
+        generator.add_security_scheme(
+            name='bearerAuth',
+            scheme_type='http',
+            options={'scheme': 'bearer', 'bearerFormat': 'JWT'},
+        )
 
         # Add security requirement
         generator.add_security_requirement('bearerAuth')
@@ -828,10 +843,38 @@ class TestOpenAPISecurityAndHeaders(unittest.TestCase):
         self.assertIn('securitySchemes', spec['components'])
         self.assertIn('bearerAuth', spec['components']['securitySchemes'])
 
+        # Check security scheme content
+        scheme = spec['components']['securitySchemes']['bearerAuth']
+        self.assertEqual(scheme['type'], 'http')
+        self.assertEqual(scheme['scheme'], 'bearer')
+        self.assertEqual(scheme['bearerFormat'], 'JWT')
+
         # Check security requirement is applied globally
         self.assertIn('security', spec)
         self.assertEqual(spec['security'], [{'bearerAuth': []}])
 
+    def test_add_apikey_security_scheme(self):
+        """Test adding apiKey security scheme with name and in fields."""
+        rpc = JSONRPC()
+        math_group = MethodGroup()
+        math_group.register('add', AddMethod())
+        rpc.register('math', math_group)
+
+        generator = OpenAPIGenerator(rpc)
+        generator.add_security_scheme(
+            name='apiKeyAuth',
+            scheme_type='apiKey',
+            options={'name': 'X-API-Key', 'in': 'header'},
+        )
+        generator.add_security_requirement('apiKeyAuth')
+
+        spec = generator.generate()
+
+        scheme = spec['components']['securitySchemes']['apiKeyAuth']
+        self.assertEqual(scheme['type'], 'apiKey')
+        self.assertEqual(scheme['name'], 'X-API-Key')
+        self.assertEqual(scheme['in'], 'header')
+
     def test_add_oauth2_security_with_scopes(self):
         """Test adding OAuth2 security with scopes."""
         rpc = JSONRPC()
@@ -845,12 +888,14 @@ class TestOpenAPISecurityAndHeaders(unittest.TestCase):
         generator.add_security_scheme(
             name='oauth2',
             scheme_type='oauth2',
-            flows={
-                'authorizationCode': {
-                    'authorizationUrl': 'https://example.com/oauth/authorize',
-                    'tokenUrl': 'https://example.com/oauth/token',
-                    'scopes': {'read': 'Read access', 'write': 'Write access'},
-                }
+            options={
+                'flows': {
+                    'authorizationCode': {
+                        'authorizationUrl': 'https://example.com/oauth/authorize',
+                        'tokenUrl': 'https://example.com/oauth/token',
+                        'scopes': {'read': 'Read access', 'write': 'Write access'},
+                    }
+                },
             },
         )
 
@@ -859,6 +904,12 @@ class TestOpenAPISecurityAndHeaders(unittest.TestCase):
 
         spec = generator.generate()
 
+        # Check security scheme content
+        scheme = spec['components']['securitySchemes']['oauth2']
+        self.assertEqual(scheme['type'], 'oauth2')
+        self.assertIn('flows', scheme)
+        self.assertIn('authorizationCode', scheme['flows'])
+
         # Check security requirement includes scopes
         self.assertIn('security', spec)
         self.assertEqual(spec['security'], [{'oauth2': ['read', 'write']}])

{python_jsonrpc_lib-0.3.1 → python_jsonrpc_lib-0.3.2}/tests/test_utils.py

@@ -843,6 +843,26 @@ class TestAdvancedTypeEdgeCases(unittest.TestCase):
         result = _convert_value(value, TypeA | TypeB)
         self.assertIs(result, value)
 
+    def test_convert_value_union_dataclass_field_mismatch(self):
+        """Union fallback: if first dataclass has wrong fields (InvalidParamsError), try next."""
+        from dataclasses import dataclass
+
+        @dataclass
+        class TypeA:
+            name: str
+            age: int
+
+        @dataclass
+        class TypeB:
+            x: int
+            y: int
+
+        # Value matches TypeB fields but not TypeA → should fall through to TypeB
+        result = _convert_value({'x': 1, 'y': 2}, TypeA | TypeB)
+        self.assertIsInstance(result, TypeB)
+        self.assertEqual(result.x, 1)
+        self.assertEqual(result.y, 2)
+
     def test_convert_value_plain_list_returns_as_is(self):
         """Test _convert_value with plain list (no args) - line 246."""
         from jsonrpc.validation import _convert_value