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

velocity/db/tests/test_db_utils.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Tests for database utility functions.
+"""
+
+import unittest
+from src.velocity.db.utils import (
+    safe_sort_key_none_last,
+    safe_sort_key_none_first,
+    safe_sort_key_with_default,
+    safe_sort_rows,
+    group_by_fields,
+    safe_sort_grouped_rows,
+)
+
+
+class TestDatabaseUtils(unittest.TestCase):
+    """Test database utility functions."""
+
+    def setUp(self):
+        """Set up test data."""
+        self.sample_data = [
+            {"id": 1, "name": "Alice", "date": "2024-03", "amount": 100},
+            {"id": 2, "name": "Bob", "date": None, "amount": 200},
+            {"id": 3, "name": "Charlie", "date": "2024-01", "amount": None},
+            {"id": 4, "name": "David", "date": "2024-02", "amount": 150},
+            {"id": 5, "name": "Eve", "date": None, "amount": 300},
+        ]
+
+    def test_safe_sort_key_none_last(self):
+        """Test sorting with None values at the end."""
+        sort_key = safe_sort_key_none_last("date")
+        sorted_data = sorted(self.sample_data, key=sort_key)
+
+        dates = [row["date"] for row in sorted_data]
+        expected = ["2024-01", "2024-02", "2024-03", None, None]
+        self.assertEqual(dates, expected)
+
+    def test_safe_sort_key_none_first(self):
+        """Test sorting with None values at the beginning."""
+        sort_key = safe_sort_key_none_first("date")
+        sorted_data = sorted(self.sample_data, key=sort_key)
+
+        dates = [row["date"] for row in sorted_data]
+        expected = [None, None, "2024-01", "2024-02", "2024-03"]
+        self.assertEqual(dates, expected)
+
+    def test_safe_sort_key_with_default(self):
+        """Test sorting with None values replaced by default."""
+        sort_key = safe_sort_key_with_default("date", "1900-01")
+        sorted_data = sorted(self.sample_data, key=sort_key)
+
+        dates = [row["date"] for row in sorted_data]
+        expected = [None, None, "2024-01", "2024-02", "2024-03"]
+        self.assertEqual(dates, expected)
+
+    def test_safe_sort_rows_none_last(self):
+        """Test safe_sort_rows with none_handling='last'."""
+        sorted_data = safe_sort_rows(self.sample_data, "date", none_handling="last")
+
+        dates = [row["date"] for row in sorted_data]
+        expected = ["2024-01", "2024-02", "2024-03", None, None]
+        self.assertEqual(dates, expected)
+
+    def test_safe_sort_rows_none_first(self):
+        """Test safe_sort_rows with none_handling='first'."""
+        sorted_data = safe_sort_rows(self.sample_data, "date", none_handling="first")
+
+        dates = [row["date"] for row in sorted_data]
+        expected = [None, None, "2024-01", "2024-02", "2024-03"]
+        self.assertEqual(dates, expected)
+
+    def test_safe_sort_rows_with_default(self):
+        """Test safe_sort_rows with none_handling='default'."""
+        sorted_data = safe_sort_rows(
+            self.sample_data, "date", none_handling="default", default_value="1900-01"
+        )
+
+        dates = [row["date"] for row in sorted_data]
+        expected = [None, None, "2024-01", "2024-02", "2024-03"]
+        self.assertEqual(dates, expected)
+
+    def test_safe_sort_rows_reverse(self):
+        """Test safe_sort_rows with reverse=True."""
+        sorted_data = safe_sort_rows(self.sample_data, "date", reverse=True)
+
+        dates = [row["date"] for row in sorted_data]
+        expected = [None, None, "2024-03", "2024-02", "2024-01"]
+        self.assertEqual(dates, expected)
+
+    def test_safe_sort_rows_invalid_none_handling(self):
+        """Test safe_sort_rows with invalid none_handling option."""
+        with self.assertRaises(ValueError) as context:
+            safe_sort_rows(self.sample_data, "date", none_handling="invalid")
+
+        self.assertIn("Invalid none_handling option", str(context.exception))
+
+    def test_group_by_fields_single_field(self):
+        """Test grouping by a single field."""
+        # Add data with same names for grouping
+        test_data = [
+            {"name": "Alice", "type": "A", "value": 1},
+            {"name": "Bob", "type": "B", "value": 2},
+            {"name": "Alice", "type": "C", "value": 3},
+            {"name": "Bob", "type": "A", "value": 4},
+        ]
+
+        groups = group_by_fields(test_data, "name")
+
+        self.assertEqual(len(groups), 2)
+        self.assertIn(("Alice",), groups)
+        self.assertIn(("Bob",), groups)
+        self.assertEqual(len(groups[("Alice",)]), 2)
+        self.assertEqual(len(groups[("Bob",)]), 2)
+
+    def test_group_by_fields_multiple_fields(self):
+        """Test grouping by multiple fields."""
+        test_data = [
+            {"name": "Alice", "type": "A", "value": 1},
+            {"name": "Bob", "type": "B", "value": 2},
+            {"name": "Alice", "type": "A", "value": 3},
+            {"name": "Alice", "type": "B", "value": 4},
+        ]
+
+        groups = group_by_fields(test_data, "name", "type")
+
+        self.assertEqual(len(groups), 3)
+        self.assertIn(("Alice", "A"), groups)
+        self.assertIn(("Bob", "B"), groups)
+        self.assertIn(("Alice", "B"), groups)
+        self.assertEqual(len(groups[("Alice", "A")]), 2)
+        self.assertEqual(len(groups[("Bob", "B")]), 1)
+        self.assertEqual(len(groups[("Alice", "B")]), 1)
+
+    def test_safe_sort_grouped_rows(self):
+        """Test sorting rows within groups."""
+        # Create grouped data
+        test_data = [
+            {"group": "A", "date": "2024-03", "value": 1},
+            {"group": "A", "date": None, "value": 2},
+            {"group": "A", "date": "2024-01", "value": 3},
+            {"group": "B", "date": "2024-02", "value": 4},
+            {"group": "B", "date": None, "value": 5},
+        ]
+
+        groups = group_by_fields(test_data, "group")
+        sorted_groups = safe_sort_grouped_rows(groups, "date")
+
+        # Check group A is sorted correctly
+        group_a_dates = [row["date"] for row in sorted_groups[("A",)]]
+        expected_a = ["2024-01", "2024-03", None]
+        self.assertEqual(group_a_dates, expected_a)
+
+        # Check group B is sorted correctly
+        group_b_dates = [row["date"] for row in sorted_groups[("B",)]]
+        expected_b = ["2024-02", None]
+        self.assertEqual(group_b_dates, expected_b)
+
+    def test_payment_profile_scenario(self):
+        """Test the specific payment profile scenario that was failing."""
+        payment_profiles = [
+            {
+                "sys_id": 1,
+                "email_address": "test@example.com",
+                "card_number": "1234",
+                "expiration_date": "2024-12",
+                "status": "active",
+            },
+            {
+                "sys_id": 2,
+                "email_address": "test@example.com",
+                "card_number": "1234",
+                "expiration_date": "2024-06",
+                "status": "active",
+            },
+            {
+                "sys_id": 3,
+                "email_address": "test@example.com",
+                "card_number": "1234",
+                "expiration_date": None,
+                "status": "active",
+            },
+            {
+                "sys_id": 4,
+                "email_address": "other@example.com",
+                "card_number": "5678",
+                "expiration_date": "2025-01",
+                "status": "active",
+            },
+            {
+                "sys_id": 5,
+                "email_address": "other@example.com",
+                "card_number": "5678",
+                "expiration_date": None,
+                "status": "active",
+            },
+        ]
+
+        # Group by email and card number
+        groups = group_by_fields(payment_profiles, "email_address", "card_number")
+
+        # Sort each group by expiration date
+        sorted_groups = safe_sort_grouped_rows(groups, "expiration_date")
+
+        # Verify we can safely enumerate through each group
+        for group_key, group in sorted_groups.items():
+            for idx, row in enumerate(group):
+                # This should not raise any errors
+                self.assertIsInstance(idx, int)
+                self.assertIn("sys_id", row)
+                self.assertIn("expiration_date", row)
+
+        # Check specific group sorting
+        test_group = sorted_groups[("test@example.com", "1234")]
+        exp_dates = [row["expiration_date"] for row in test_group]
+        expected = ["2024-06", "2024-12", None]
+        self.assertEqual(exp_dates, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/test_postgres.py

@@ -0,0 +1,212 @@
+import unittest
+import decimal
+from velocity.db.servers.postgres.sql import SQL
+from velocity.db.servers.tablehelper import TableHelper
+
+
+class TestSQLModule(unittest.TestCase):
+    def test_quote_simple_identifier(self):
+        self.assertEqual(TableHelper.quote("test"), "test")
+
+    def test_quote_reserved_word(self):
+        self.assertEqual(TableHelper.quote("SELECT"), '"SELECT"')
+
+    def test_quote_with_special_characters(self):
+        self.assertEqual(TableHelper.quote("my/schema"), '"my/schema"')
+
+    def test_quote_dot_notation(self):
+        self.assertEqual(TableHelper.quote("my_table.my_column"), "my_table.my_column")
+
+    def test_quote_list_identifiers(self):
+        self.assertEqual(
+            TableHelper.quote(["test", "SELECT", "my_table"]),
+            ["test", '"SELECT"', "my_table"],
+        )
+
+    def test_make_where_simple_equality(self):
+        # Create a mock transaction and table helper
+        mock_tx = type("MockTx", (), {})()
+        helper = TableHelper(mock_tx, "test_table")
+
+        sql, vals = helper.make_where({"column1": "value1"})
+        self.assertIn("column1 = %s", sql)
+        self.assertEqual(vals, ("value1",))
+
+    def test_make_where_with_null(self):
+        mock_tx = type("MockTx", (), {})()
+        helper = TableHelper(mock_tx, "test_table")
+
+        sql, vals = helper.make_where({"column1": None})
+        self.assertIn("column1 is NULL", sql)
+        self.assertEqual(vals, ())
+
+    def test_make_where_with_not_null(self):
+        mock_tx = type("MockTx", (), {})()
+        helper = TableHelper(mock_tx, "test_table")
+
+        sql, vals = helper.make_where({"column1!": None})
+        self.assertIn("column1 is not NULL", sql)
+        self.assertEqual(vals, ())
+
+    def test_make_where_with_operators(self):
+        mock_tx = type("MockTx", (), {})()
+        helper = TableHelper(mock_tx, "test_table")
+
+        sql, vals = helper.make_where({"column1>": 10, "column2!": "value2"})
+        self.assertIn("column1 > %s", sql)
+        self.assertIn("column2 != %s", sql)
+        self.assertEqual(len(vals), 2)
+
+    def test_make_where_with_list(self):
+        mock_tx = type("MockTx", (), {})()
+        helper = TableHelper(mock_tx, "test_table")
+
+        sql, vals = helper.make_where({"column1": [1, 2, 3]})
+        self.assertIn("column1 in", sql.lower())
+        self.assertEqual(len(vals), 3)
+
+    def test_make_where_between(self):
+        mock_tx = type("MockTx", (), {})()
+        helper = TableHelper(mock_tx, "test_table")
+
+        sql, vals = helper.make_where({"column1><": [1, 10]})
+        self.assertIn("between", sql.lower())
+        self.assertEqual(len(vals), 2)
+
+    def test_sql_select_simple(self):
+        sql_query, params = SQL.select(columns="*", table="my_table")
+        self.assertEqual(sql_query, "SELECT * FROM my_table")
+        self.assertEqual(params, ())
+
+    def test_sql_select_with_where(self):
+        sql_query, params = SQL.select(columns="*", table="my_table", where={"id": 1})
+        self.assertEqual(sql_query, "SELECT * FROM my_table WHERE id = %s")
+        self.assertEqual(params, (1,))
+
+    def test_sql_select_with_order_by(self):
+        sql_query, params = SQL.select(columns="*", table="my_table", orderby="id DESC")
+        self.assertEqual(sql_query, "SELECT * FROM my_table ORDER BY id DESC")
+        self.assertEqual(params, ())
+
+    def test_sql_insert(self):
+        sql_query, params = SQL.insert(
+            table="my_table", data={"column1": "value1", "column2": 2}
+        )
+        self.assertEqual(
+            sql_query, "INSERT INTO my_table (column1,column2) VALUES (%s,%s)"
+        )
+        self.assertEqual(params, ("value1", 2))
+
+    def test_sql_update(self):
+        sql_query, params = SQL.update(
+            table="my_table", data={"column1": "new_value"}, pk={"id": 1}
+        )
+        self.assertEqual(sql_query, "UPDATE my_table SET column1 = %s WHERE id = %s")
+        self.assertEqual(params, ("new_value", 1))
+
+    def test_sql_delete(self):
+        sql_query, params = SQL.delete(table="my_table", where={"id": 1})
+        self.assertEqual(sql_query, "DELETE FROM my_table WHERE id = %s")
+        self.assertEqual(params, (1,))
+
+    def test_sql_create_table(self):
+        sql_query, params = SQL.create_table(
+            name="public.test_table", columns={"name": str, "age": int}, drop=True
+        )
+        self.assertIn("CREATE TABLE public.test_table", sql_query)
+        self.assertIn("DROP TABLE IF EXISTS public.test_table CASCADE;", sql_query)
+        self.assertEqual(params, ())
+
+    def test_sql_drop_table(self):
+        sql_query, params = SQL.drop_table("public.test_table")
+        self.assertEqual(sql_query, "drop table if exists public.test_table cascade;")
+        self.assertEqual(params, ())
+
+    def test_sql_create_index(self):
+        sql_query, params = SQL.create_index(
+            table="my_table", columns="column1", unique=True
+        )
+        self.assertIn("CREATE UNIQUE INDEX", sql_query)
+        self.assertIn("ON my_table (column1)", sql_query)
+        self.assertEqual(params, ())
+
+    def test_sql_drop_index(self):
+        sql_query, params = SQL.drop_index(table="my_table", columns="column1")
+        self.assertIn("DROP INDEX IF EXISTS", sql_query)
+        self.assertEqual(params, ())
+
+    def test_sql_foreign_key_creation(self):
+        sql_query, params = SQL.create_foreign_key(
+            table="child_table",
+            columns="parent_id",
+            key_to_table="parent_table",
+            key_to_columns="id",
+        )
+        self.assertIn("ALTER TABLE child_table ADD CONSTRAINT", sql_query)
+        self.assertIn(
+            "FOREIGN KEY (parent_id) REFERENCES parent_table (id);", sql_query
+        )
+        self.assertEqual(params, ())
+
+    def test_sql_merge_insert(self):
+        sql_query, params = SQL.merge(
+            table="my_table",
+            data={"column1": "value1"},
+            pk={"id": 1},
+            on_conflict_do_nothing=True,
+            on_conflict_update=False,
+        )
+        self.assertIn("INSERT INTO my_table", sql_query)
+        self.assertIn("ON CONFLICT (id) DO NOTHING", sql_query)
+        self.assertEqual(params, ("value1", 1))
+
+    def test_sql_merge_update(self):
+        sql_query, params = SQL.merge(
+            table="my_table",
+            data={"column1": "value1"},
+            pk={"id": 1},
+            on_conflict_do_nothing=False,
+            on_conflict_update=True,
+        )
+        self.assertIn("INSERT INTO my_table", sql_query)
+        self.assertIn("ON CONFLICT (id) DO UPDATE SET", sql_query)
+        self.assertEqual(params, ("value1", 1))
+
+    def test_get_type_mapping(self):
+        self.assertEqual(SQL.get_type("string"), "TEXT")
+        self.assertEqual(SQL.get_type(123), "BIGINT")
+        self.assertEqual(SQL.get_type(123.456), "NUMERIC(19, 6)")
+        self.assertEqual(SQL.get_type(True), "BOOLEAN")
+        self.assertEqual(SQL.get_type(None), "TEXT")
+
+    def test_py_type_mapping(self):
+        self.assertEqual(SQL.py_type("INTEGER"), int)
+        self.assertEqual(SQL.py_type("NUMERIC"), decimal.Decimal)
+        self.assertEqual(SQL.py_type("TEXT"), str)
+        self.assertEqual(SQL.py_type("BOOLEAN"), bool)
+
+    def test_sql_truncate(self):
+        sql_query, params = SQL.truncate("my_table")
+        self.assertEqual(sql_query, "truncate table my_table")
+        self.assertEqual(params, ())
+
+    def test_sql_create_view(self):
+        sql_query, params = SQL.create_view(
+            name="my_view", query="SELECT * FROM my_table", temp=True, silent=True
+        )
+        self.assertIn(
+            "CREATE OR REPLACE TEMPORARY VIEW my_view AS SELECT * FROM my_table",
+            sql_query,
+        )
+        self.assertEqual(params, ())
+
+    def test_sql_drop_view(self):
+        sql_query, params = SQL.drop_view(name="my_view", silent=True)
+        self.assertEqual(sql_query, "DROP VIEW IF EXISTS my_view")
+        self.assertEqual(params, ())
+
+    # Additional tests can be added here to cover more methods and edge cases
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/test_postgres_unchanged.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+Quick test to verify PostgreSQL implementation is functionally unchanged.
+"""
+import sys
+import os
+sys.path.insert(0, '/home/ubuntu/tenspace/velocity-python/src')
+
+def test_postgres_unchanged():
+    """Test that PostgreSQL implementation is functionally unchanged."""
+    print("Testing PostgreSQL implementation...")
+    
+    # Test imports
+    try:
+        from velocity.db.servers.postgres import initialize
+        from velocity.db.servers.postgres.sql import SQL
+        from velocity.db.servers.postgres.types import TYPES
+        from velocity.db.servers.postgres.operators import OPERATORS
+        print("✓ All imports successful")
+    except ImportError as e:
+        print(f"✗ Import failed: {e}")
+        return False
+    
+    # Test SQL class attributes are the same
+    expected_server = "PostGreSQL"
+    if SQL.server != expected_server:
+        print(f"✗ SQL.server changed: expected '{expected_server}', got '{SQL.server}'")
+        return False
+    print("✓ SQL.server unchanged")
+    
+    # Test error codes are preserved
+    expected_duplicate_codes = ["23505"]
+    if SQL.DuplicateKeyErrorCodes != expected_duplicate_codes:
+        print(f"✗ DuplicateKeyErrorCodes changed: expected {expected_duplicate_codes}, got {SQL.DuplicateKeyErrorCodes}")
+        return False
+    print("✓ Error codes unchanged")
+    
+    # Test TYPES class methods exist
+    if not hasattr(TYPES, 'get_type'):
+        print("✗ TYPES.get_type method missing")
+        return False
+    if not hasattr(TYPES, 'get_conv'):
+        print("✗ TYPES.get_conv method missing")
+        return False
+    if not hasattr(TYPES, 'py_type'):
+        print("✗ TYPES.py_type method missing")
+        return False
+    print("✓ TYPES methods present")
+    
+    # Test type mappings are correct
+    if TYPES.get_type(str) != "TEXT":
+        print(f"✗ TYPES.get_type(str) changed: expected 'TEXT', got '{TYPES.get_type(str)}'")
+        return False
+    if TYPES.get_type(int) != "BIGINT":
+        print(f"✗ TYPES.get_type(int) changed: expected 'BIGINT', got '{TYPES.get_type(int)}'")
+        return False
+    print("✓ Type mappings unchanged")
+    
+    # Test operators are preserved
+    if OPERATORS.get("<>") != "<>":
+        print(f"✗ Operator '<>' mapping changed")
+        return False
+    if OPERATORS.get("%%") != "ILIKE":
+        print(f"✗ Operator '%%' mapping changed")
+        return False
+    print("✓ Operators unchanged")
+    
+    # Test SQL methods exist (just check key ones)
+    sql_methods = ['select', 'insert', 'update', 'delete', 'merge', 'version', 'databases']
+    for method in sql_methods:
+        if not hasattr(SQL, method):
+            print(f"✗ SQL.{method} method missing")
+            return False
+    print("✓ SQL methods present")
+    
+    print("\n🎉 PostgreSQL implementation is functionally unchanged!")
+    return True
+
+if __name__ == "__main__":
+    success = test_postgres_unchanged()
+    sys.exit(0 if success else 1)