IDEV-2299: Improve implementation that handles positional args as well.

Author: jbabac

domaintools/decorators.py

@@ -1,4 +1,5 @@
 import functools
+import inspect
 
 from typing import List, Union
 
@@ -24,8 +25,26 @@ def decorator(func):
         normalized_methods = [methods] if isinstance(methods, str) else methods
         func._api_methods = normalized_methods
 
+        # Get the signature of the original function ONCE
+        sig = inspect.signature(func)
+
         @functools.wraps(func)
         def wrapper(self, *args, **kwargs):
+
+            try:
+                bound_args = sig.bind(*args, **kwargs)
+            except TypeError:
+                # If arguments don't match signature, let the actual func raise the error
+                return func(*args, **kwargs)
+
+            arguments = bound_args.arguments
+
+            # Robustly find 'self' (it's usually the first argument in bound_args)
+            # We look for the first value in arguments, or try to get 'self' explicitly.
+            instance = arguments.get("self")
+            if not instance and args:
+                instance = args[0]
+
             # Retrieve the Spec from the instance
             # We assume 'self' has a .specs attribute (like DocstringPatcher expects)
             spec = getattr(self, "specs", {}).get(spec_name)
@@ -43,14 +62,13 @@ def wrapper(self, *args, **kwargs):
                         spec=spec,
                         path=path,
                         method=current_method,
-                        parameters=kwargs,
+                        parameters=arguments,
                     )
                 except ValueError as e:
-                    # Optional: Log the error or re-raise custom exception
                     print(f"[Validation Error] {e}")
                     raise e
 
-            # 5. Proceed with the original function call
+            # Proceed with the original function call
             return func(*args, **kwargs)
 
         # Copy tags to wrapper for the DocstringPatcher to find

tests/test_decorators.py

@@ -195,3 +195,25 @@ def get_users():
 
             assert result == "Ran Safe"
             mock_validate.assert_not_called()
+
+    def test_positional_arguments_are_mapped(self, mock_client):
+        """
+        Test that passing arguments positionally (args) instead of via keywords (kwargs)
+        still triggers validation correctly.
+        """
+
+        # Define function with explicit parameter names
+        @api_endpoint(spec_name="v1", path="/users", methods="POST")
+        def create_user(name=None, body=None):
+            return "Success"
+
+        with patch("domaintools.request_validator.RequestValidator.validate") as mock_validate:
+            # CALL POSITIONALLY: passing client and body as args
+            # (Note: we pass mock_client manually because create_user is just a function here)
+            create_user(mock_client, "test-name")
+
+            # Verify validator received the data mapped to 'body_data'
+            mock_validate.assert_called_once()
+            call_kwargs = mock_validate.call_args[1]
+
+            assert call_kwargs.get("parameters") == {"name": "test-name"}