velocity-python 0.0.132__py3-none-any.whl → 0.0.135__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.132"
+__version__ = version = "0.0.135"
 
 from . import aws
 from . import db

velocity/app/tests/__init__.py

@@ -0,0 +1 @@
+# App module tests

velocity/app/tests/test_email_processing.py

@@ -0,0 +1,112 @@
+import unittest
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.mime.application import MIMEApplication
+from velocity.misc.mail import (
+    Attachment,
+    get_full_emails,
+    get_address_only,
+    parse_attachment,
+    parse,
+)
+import hashlib
+
+
+class TestEmailProcessing(unittest.TestCase):
+
+    def test_get_full_emails(self):
+        """Test that email addresses with names are formatted correctly."""
+        mock_address = [
+            type(
+                "Address",
+                (),
+                {"mailbox": b"john", "host": b"example.com", "name": b"John Doe"},
+            ),
+            type(
+                "Address",
+                (),
+                {"mailbox": b"jane", "host": b"example.com", "name": None},
+            ),
+        ]
+        result = get_full_emails(mock_address)
+        self.assertEqual(result, ["John Doe <john@example.com>", "jane@example.com"])
+
+    def test_get_address_only(self):
+        """Test that only email addresses without names are returned."""
+        mock_address = [
+            type("Address", (), {"mailbox": b"john", "host": b"example.com"}),
+            type("Address", (), {"mailbox": b"jane", "host": b"example.com"}),
+        ]
+        result = get_address_only(mock_address)
+        self.assertEqual(result, ["john@example.com", "jane@example.com"])
+
+    def test_attachment_initialization(self):
+        """Test the initialization of the Attachment class."""
+        data = b"file data"
+        attachment = Attachment(name="file.txt", data=data)
+        self.assertEqual(attachment.name, "file.txt")
+        self.assertEqual(attachment.data, data)
+        self.assertEqual(attachment.size, len(data))
+        self.assertEqual(attachment.ctype, "text/plain")
+        self.assertEqual(attachment.hash, hashlib.sha1(data).hexdigest())
+
+    def test_parse_attachment(self):
+        """Test parsing a valid attachment from a message part."""
+        part = MIMEApplication(b"Test file data", Name="test.txt")
+        part["Content-Disposition"] = 'attachment; filename="test.txt"'
+        attachment = parse_attachment(part)
+        self.assertIsInstance(attachment, Attachment)
+        self.assertEqual(attachment.name, "test.txt")
+        self.assertEqual(attachment.ctype, "text/plain")
+        self.assertEqual(attachment.data, b"Test file data")
+
+    def test_parse_attachment_none(self):
+        """Test that parse_attachment returns None if there's no attachment."""
+        part = MIMEText("This is a plain text email part")
+        self.assertIsNone(parse_attachment(part))
+
+    def test_parse_plain_text_email(self):
+        """Test parsing a plain text email."""
+        msg = MIMEText("This is a plain text email")
+        msg["Content-Type"] = "text/plain"
+        result = parse(msg.as_string())
+        self.assertEqual(result["body"], "This is a plain text email")
+        self.assertIsNone(result["html"])
+        self.assertEqual(result["attachments"], [])
+
+    def test_parse_html_email(self):
+        """Test parsing an HTML email."""
+        msg = MIMEText("<p>This is an HTML email</p>", "html")
+        msg["Content-Type"] = "text/html"
+        result = parse(msg.as_string())
+        self.assertEqual(result["html"], "<p>This is an HTML email</p>")
+        self.assertIsNone(result["body"])
+        self.assertEqual(result["attachments"], [])
+
+    def test_parse_multipart_email_with_attachments(self):
+        """Test parsing a multipart email with attachments."""
+        msg = MIMEMultipart()
+        msg.attach(MIMEText("This is a plain text part", "plain"))
+        msg.attach(MIMEText("<p>This is an HTML part</p>", "html"))
+
+        attachment_part = MIMEApplication(b"Attachment data", Name="attachment.txt")
+        attachment_part["Content-Disposition"] = 'attachment; filename="attachment.txt"'
+        msg.attach(attachment_part)
+
+        result = parse(msg.as_string())
+        self.assertEqual(result["body"], "This is a plain text part")
+        self.assertEqual(result["html"], "<p>This is an HTML part</p>")
+        self.assertEqual(len(result["attachments"]), 1)
+        self.assertEqual(result["attachments"][0].name, "attachment.txt")
+        self.assertEqual(result["attachments"][0].data, b"Attachment data")
+
+    def test_parse_empty_email(self):
+        """Test parsing an empty email string."""
+        result = parse("")
+        self.assertIsNone(result["body"])
+        self.assertIsNone(result["html"])
+        self.assertEqual(result["attachments"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/app/tests/test_payment_profile_sorting.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Test for payment profile sorting with None expiration dates.
+
+This addresses the production error:
+TypeError: '<' not supported between instances of 'NoneType' and 'NoneType'
+
+The error occurs when sorting payment profiles by expiration_date when some values are None.
+"""
+
+import unittest
+from datetime import datetime
+
+
+class TestPaymentProfileSorting(unittest.TestCase):
+    """Test sorting payment profiles with various expiration date scenarios."""
+
+    def setUp(self):
+        """Set up test data with various expiration date scenarios."""
+        self.payment_profiles = [
+            {
+                "sys_id": 1,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": "2024-12",
+                "status": "active",
+            },
+            {
+                "sys_id": 2,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": "2024-06",
+                "status": "active",
+            },
+            {
+                "sys_id": 3,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": None,
+                "status": "active",
+            },
+            {
+                "sys_id": 4,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": "2025-01",
+                "status": "active",
+            },
+            {
+                "sys_id": 5,
+                "email_address": "test1@example.com",
+                "card_number": "1234",
+                "expiration_date": None,
+                "status": "active",
+            },
+        ]
+
+    def test_original_error_reproduction(self):
+        """Reproduce the original error to confirm it happens."""
+        with self.assertRaises(TypeError) as context:
+            # This should fail with the original error
+            sorted(self.payment_profiles, key=lambda x: x["expiration_date"])
+
+        self.assertIn(
+            "'<' not supported between instances of 'NoneType'", str(context.exception)
+        )
+
+    def test_safe_sorting_with_none_last(self):
+        """Test sorting with None values placed at the end."""
+
+        def safe_sort_key_none_last(row):
+            """Sort key that places None values at the end."""
+            exp_date = row["expiration_date"]
+            if exp_date is None:
+                return (1, "")  # (1, "") sorts after (0, any_date)
+            return (0, exp_date)
+
+        sorted_profiles = sorted(self.payment_profiles, key=safe_sort_key_none_last)
+
+        # Check that non-None dates come first and are in order
+        non_none_dates = [
+            p["expiration_date"]
+            for p in sorted_profiles
+            if p["expiration_date"] is not None
+        ]
+        self.assertEqual(non_none_dates, ["2024-06", "2024-12", "2025-01"])
+
+        # Check that None values come last
+        none_dates = [
+            p["expiration_date"]
+            for p in sorted_profiles
+            if p["expiration_date"] is None
+        ]
+        self.assertEqual(len(none_dates), 2)
+
+        # Verify the full sort order
+        expected_order = ["2024-06", "2024-12", "2025-01", None, None]
+        actual_order = [p["expiration_date"] for p in sorted_profiles]
+        self.assertEqual(actual_order, expected_order)
+
+    def test_safe_sorting_with_none_first(self):
+        """Test sorting with None values placed at the beginning."""
+
+        def safe_sort_key_none_first(row):
+            """Sort key that places None values at the beginning."""
+            exp_date = row["expiration_date"]
+            if exp_date is None:
+                return (0, "")  # (0, "") sorts before (1, any_date)
+            return (1, exp_date)
+
+        sorted_profiles = sorted(self.payment_profiles, key=safe_sort_key_none_first)
+
+        # Check that None values come first
+        none_count = sum(1 for p in sorted_profiles[:2] if p["expiration_date"] is None)
+        self.assertEqual(none_count, 2)
+
+        # Check that non-None dates come after and are in order
+        non_none_dates = [
+            p["expiration_date"]
+            for p in sorted_profiles
+            if p["expiration_date"] is not None
+        ]
+        self.assertEqual(non_none_dates, ["2024-06", "2024-12", "2025-01"])
+
+    def test_safe_sorting_with_default_date(self):
+        """Test sorting with None values replaced by a default date."""
+
+        def safe_sort_key_with_default(row):
+            """Sort key that replaces None with a default date."""
+            exp_date = row["expiration_date"]
+            if exp_date is None:
+                return "1900-01"  # Very old date so None values sort first
+            return exp_date
+
+        sorted_profiles = sorted(self.payment_profiles, key=safe_sort_key_with_default)
+
+        # Check that None values (now "1900-01") come first
+        none_count = sum(1 for p in sorted_profiles[:2] if p["expiration_date"] is None)
+        self.assertEqual(none_count, 2)
+
+        # Check the overall order
+        actual_order = [p["expiration_date"] for p in sorted_profiles]
+        expected_order = [None, None, "2024-06", "2024-12", "2025-01"]
+        self.assertEqual(actual_order, expected_order)
+
+    def test_grouped_sorting_scenario(self):
+        """Test the specific scenario from the billing handler."""
+        # Group profiles by email and card number (as in the original code)
+        groups = {}
+        for row in self.payment_profiles:
+            key = (row["email_address"], row["card_number"])
+            if key not in groups:
+                groups[key] = []
+            groups[key].append(row)
+
+        # Process each group with safe sorting
+        for group in groups.values():
+            # This should not raise an error
+            def safe_sort_key(row):
+                exp_date = row["expiration_date"]
+                return (exp_date is None, exp_date or "")
+
+            sorted_group = sorted(group, key=safe_sort_key)
+
+            # Verify we can enumerate through the sorted group
+            for idx, row in enumerate(sorted_group):
+                self.assertIsInstance(idx, int)
+                self.assertIn("sys_id", row)
+                self.assertIn("expiration_date", row)
+
+
+def safe_expiration_date_sort_key(row):
+    """
+    Safe sorting key for payment profiles by expiration date.
+
+    Handles None values by placing them at the end of the sort order.
+
+    Args:
+        row: Dictionary representing a payment profile with 'expiration_date' key
+
+    Returns:
+        Tuple that can be safely sorted, with None values last
+    """
+    exp_date = row["expiration_date"]
+    if exp_date is None:
+        return (1, "")  # (1, "") sorts after (0, any_date)
+    return (0, exp_date)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/app/tests/test_spreadsheet_functions.py

@@ -0,0 +1,124 @@
+import unittest
+import base64
+from io import BytesIO
+from openpyxl import load_workbook
+from velocity.misc.export import (
+    extract,
+    autosize_columns,
+    create_spreadsheet,
+    get_downloadable_spreadsheet,
+)
+
+
+class TestSpreadsheetFunctions(unittest.TestCase):
+
+    def test_extract(self):
+        """Test extracting values from a dictionary based on a list of keys."""
+        data = {"name": "Alice", "age": 30, "city": "Wonderland"}
+        keys = ["name", "city", "nonexistent_key"]
+        result = extract(data, keys)
+        self.assertEqual(result, ["Alice", "Wonderland", None])
+
+    def test_autosize_columns(self):
+        """Test that the columns are autosized based on the content."""
+        buffer = BytesIO()
+        headers = ["Column1", "Column2"]
+        rows = [["Short", "This is a longer text that should set the column width"]]
+
+        # Create a workbook and worksheet
+        create_spreadsheet(headers, rows, buffer)
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Run autosize_columns on the loaded worksheet
+        autosize_columns(worksheet)
+
+        # Check if the column widths were adjusted properly
+        col1_width = worksheet.column_dimensions["A"].width
+        col2_width = worksheet.column_dimensions["B"].width
+        self.assertGreater(col2_width, col1_width)
+
+    def test_create_spreadsheet_basic(self):
+        """Test creating a spreadsheet with headers and rows."""
+        buffer = BytesIO()
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"], ["Row2-Col1", "Row2-Col2"]]
+
+        create_spreadsheet(headers, rows, buffer)
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify headers and rows
+        self.assertEqual(worksheet["A1"].value, "Header1")
+        self.assertEqual(worksheet["B1"].value, "Header2")
+        self.assertEqual(worksheet["A2"].value, "Row1-Col1")
+        self.assertEqual(worksheet["B2"].value, "Row1-Col2")
+        self.assertEqual(worksheet["A3"].value, "Row2-Col1")
+        self.assertEqual(worksheet["B3"].value, "Row2-Col2")
+
+    def test_create_spreadsheet_with_styles_and_merge(self):
+        """Test creating a spreadsheet with custom styles and merged cells."""
+        buffer = BytesIO()
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"]]
+        styles = {"A1": "col_header", "B1": "col_header"}
+        merge = ["A1:B1"]
+
+        create_spreadsheet(headers, rows, buffer, styles=styles, merge=merge)
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify merged cells and styles
+        self.assertTrue(worksheet.merged_cells.ranges)
+        self.assertEqual(str(worksheet.merged_cells.ranges[0]), "A1:B1")
+        self.assertEqual(worksheet["A1"].style, "col_header")
+        self.assertEqual(worksheet["B1"].style, "col_header")
+
+    def test_create_spreadsheet_with_freeze_panes_and_dimensions(self):
+        """Test creating a spreadsheet with freeze panes and custom row/column dimensions."""
+        buffer = BytesIO()
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"]]
+        dimensions = {"rows": {1: 25}, "columns": {"A": 20, "B": 30}}
+
+        create_spreadsheet(
+            headers, rows, buffer, freeze_panes="A2", dimensions=dimensions
+        )
+        buffer.seek(0)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify freeze panes and custom dimensions
+        self.assertEqual(worksheet.freeze_panes, "A2")
+        self.assertEqual(worksheet.row_dimensions[1].height, 25)
+        self.assertEqual(worksheet.column_dimensions["A"].width, 20)
+        self.assertEqual(worksheet.column_dimensions["B"].width, 30)
+
+    def test_get_downloadable_spreadsheet(self):
+        """Test generating a downloadable spreadsheet encoded in base64."""
+        headers = ["Header1", "Header2"]
+        rows = [["Row1-Col1", "Row1-Col2"], ["Row2-Col1", "Row2-Col2"]]
+
+        # Generate the base64-encoded spreadsheet
+        encoded_spreadsheet = get_downloadable_spreadsheet(headers, rows)
+        decoded_data = base64.b64decode(encoded_spreadsheet)
+
+        # Load the spreadsheet from the decoded data and verify its content
+        buffer = BytesIO(decoded_data)
+        workbook = load_workbook(buffer)
+        worksheet = workbook.active
+
+        # Verify headers and rows
+        self.assertEqual(worksheet["A1"].value, "Header1")
+        self.assertEqual(worksheet["B1"].value, "Header2")
+        self.assertEqual(worksheet["A2"].value, "Row1-Col1")
+        self.assertEqual(worksheet["B2"].value, "Row1-Col2")
+        self.assertEqual(worksheet["A3"].value, "Row2-Col1")
+        self.assertEqual(worksheet["B3"].value, "Row2-Col2")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/aws/tests/__init__.py

@@ -0,0 +1 @@
+# AWS module tests

velocity/aws/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()