velocity-python 0.0.120__tar.gz → 0.0.124__tar.gz

{velocity_python-0.0.120/src/velocity_python.egg-info → velocity_python-0.0.124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.120
+Version: 0.0.124
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.120 → velocity_python-0.0.124}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.120"
+version = "0.0.124"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.120 → velocity_python-0.0.124}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.120"
+__version__ = version = "0.0.124"
 
 from . import aws
 from . import db

{velocity_python-0.0.120 → velocity_python-0.0.124}/src/velocity/aws/handlers/base_handler.py

@@ -116,11 +116,12 @@ class BaseHandler:
 
         return actions
 
-    def execute_actions(self, local_context, actions: List[str]) -> bool:
+    def execute_actions(self, tx, local_context, actions: List[str]) -> bool:
         """
         Execute the appropriate actions for the given context.
 
         Args:
+            tx: Database transaction object
             local_context: The context object
             actions: List of action method names to try
 
@@ -129,7 +130,7 @@ class BaseHandler:
         """
         # Execute beforeAction hook if available
         if hasattr(self, "beforeAction"):
-            self.beforeAction(local_context)
+            self.beforeAction(tx, local_context)
 
         action_executed = False
 
@@ -139,7 +140,7 @@ class BaseHandler:
                 break
 
             if hasattr(self, action):
-                result = getattr(self, action)(local_context)
+                result = getattr(self, action)(tx, local_context)
 
                 # Check for deprecated return values (LambdaHandler specific)
                 if result is not None and hasattr(self, "_check_deprecated_return"):
@@ -150,27 +151,29 @@ class BaseHandler:
 
         # Execute afterAction hook if available
         if hasattr(self, "afterAction"):
-            self.afterAction(local_context)
+            self.afterAction(tx, local_context)
 
         return action_executed
 
-    def handle_error(self, local_context, exception: Exception):
+    def handle_error(self, tx, local_context, exception: Exception):
         """
         Handle errors that occur during action execution.
 
         Args:
+            tx: Database transaction object
             local_context: The context object
             exception: The exception that occurred
         """
         if hasattr(self, "onError"):
             self.onError(
+                tx,
                 local_context,
                 exc=exception.__class__.__name__,
                 tb=traceback.format_exc(),
             )
         else:
             # Re-raise if no error handler is defined
-            raise
+            raise exception
 
     def log(self, tx, message: str, function: Optional[str] = None):
         """

{velocity_python-0.0.120 → velocity_python-0.0.124}/src/velocity/aws/handlers/lambda_handler.py

@@ -71,8 +71,19 @@ class LambdaHandler(BaseHandler):
             log=lambda message, function=None: self.log(tx, message, function),
         )
 
+        # Determine action from postdata or query parameters
+        action = postdata.get("action") or req_params.get("action")
+        
+        # Get the list of actions to execute
+        actions = self.get_actions_to_execute(action)
+        
         # Use BaseHandler's execute_actions method
-        return self.execute_actions(tx, local_context, postdata, req_params)
+        try:
+            self.execute_actions(tx, local_context, actions)
+        except Exception as e:
+            self.handle_error(tx, local_context, e)
+            
+        return local_context.response.render()
 
     def track(self, tx, data={}, user=None):
         data = data.copy()

{velocity_python-0.0.120 → velocity_python-0.0.124}/src/velocity/aws/handlers/sqs_handler.py

@@ -78,11 +78,17 @@ class SqsHandler(BaseHandler):
             session=None,
         )
 
+        # Determine action from postdata
+        action = postdata.get("action") if isinstance(postdata, dict) else None
+        
+        # Get the list of actions to execute
+        actions = self.get_actions_to_execute(action)
+
         # Use BaseHandler's execute_actions method
         try:
-            self.execute_actions(tx, local_context, postdata, attrs)
+            self.execute_actions(tx, local_context, actions)
         except Exception as e:
-            self.handle_error(local_context, e)
+            self.handle_error(tx, local_context, e)
 
     def OnActionDefault(self, tx, context):
         """

{velocity_python-0.0.120 → velocity_python-0.0.124/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.120
+Version: 0.0.124
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.120 → velocity_python-0.0.124}/src/velocity_python.egg-info/SOURCES.txt

@@ -65,6 +65,7 @@ tests/test_email_processing.py
 tests/test_fix.py
 tests/test_format.py
 tests/test_iconv.py
+tests/test_lambda_handler_json_serialization.py
 tests/test_merge.py
 tests/test_oconv.py
 tests/test_original_error.py

velocity_python-0.0.124/tests/test_lambda_handler_json_serialization.py

@@ -0,0 +1,120 @@
+"""
+Test Lambda Handler JSON Serialization Fix
+
+This test verifies that LambdaHandler.serve() returns a JSON-serializable
+dictionary instead of a Response object, preventing the 
+"Object of type method is not JSON serializable" error.
+"""
+
+import json
+import unittest
+from unittest.mock import MagicMock, patch
+import sys
+import os
+
+# Add src to path for testing
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from velocity.aws.handlers.lambda_handler import LambdaHandler
+from velocity.aws.handlers.response import Response
+
+
+class TestLambdaHandlerJSONSerialization(unittest.TestCase):
+    """Test cases for Lambda Handler JSON serialization."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.test_event = {
+            "body": '{"action": "test", "payload": {}}',
+            "httpMethod": "POST",
+            "headers": {"Content-Type": "application/json"},
+            "requestContext": {
+                "identity": {
+                    "sourceIp": "127.0.0.1",  # localhost test IP for unit testing
+                    "userAgent": "test-agent"
+                }
+            },
+            "queryStringParameters": {}
+        }
+        
+        self.test_context = MagicMock()
+        self.test_context.function_name = "test-function"
+
+    def test_serve_returns_json_serializable_dict(self):
+        """Test that serve() returns a JSON-serializable dictionary."""
+        
+        # Create handler
+        handler = LambdaHandler(self.test_event, self.test_context)
+        
+        # Mock the transaction decorator to pass through tx
+        with patch('velocity.aws.handlers.lambda_handler.engine') as mock_engine:
+            def mock_transaction(func):
+                def wrapper(*args, **kwargs):
+                    mock_tx = MagicMock()
+                    return func(mock_tx, *args, **kwargs)
+                return wrapper
+            
+            mock_engine.transaction = mock_transaction
+            
+            # Call serve method
+            result = handler.serve(MagicMock())
+            
+            # Verify result is a dictionary (JSON-serializable)
+            self.assertIsInstance(result, dict)
+            
+            # Verify it has the expected Lambda response structure
+            self.assertIn("statusCode", result)
+            self.assertIn("headers", result)
+            self.assertIn("body", result)
+            
+            # Verify the body is a JSON string
+            self.assertIsInstance(result["body"], str)
+            
+            # Verify the entire result can be JSON serialized
+            try:
+                json.dumps(result)
+            except (TypeError, ValueError) as e:
+                self.fail(f"Result is not JSON serializable: {e}")
+
+    def test_response_object_has_render_method(self):
+        """Test that Response object has a proper render method."""
+        response = Response()
+        
+        # Verify render method exists
+        self.assertTrue(hasattr(response, 'render'))
+        self.assertTrue(callable(response.render))
+        
+        # Verify render returns a dictionary
+        rendered = response.render()
+        self.assertIsInstance(rendered, dict)
+        
+        # Verify structure
+        self.assertIn("statusCode", rendered)
+        self.assertIn("headers", rendered)
+        self.assertIn("body", rendered)
+        
+        # Verify JSON serializable
+        try:
+            json.dumps(rendered)
+        except (TypeError, ValueError) as e:
+            self.fail(f"Rendered response is not JSON serializable: {e}")
+
+    def test_response_render_vs_raw_object(self):
+        """Test the difference between Response object and rendered response."""
+        response = Response()
+        
+        # Raw response object should not be directly JSON serializable
+        # (it contains method references)
+        with self.assertRaises((TypeError, ValueError)):
+            json.dumps(response)
+        
+        # But rendered response should be JSON serializable
+        rendered = response.render()
+        try:
+            json.dumps(rendered)
+        except (TypeError, ValueError) as e:
+            self.fail(f"Rendered response should be JSON serializable: {e}")
+
+
+if __name__ == '__main__':
+    unittest.main()