velocity-python 0.0.109__py3-none-any.whl → 0.0.155__py3-none-any.whl

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)

velocity/db/tests/test_process_error_robustness.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+
+"""
+Test the robustness of the improved process_error method
+"""
+
+import sys
+import unittest
+from unittest.mock import Mock, patch
+import logging
+
+# Add the source directory to the path
+sys.path.insert(0, "/home/ubuntu/tenspace/velocity-python/src")
+
+from velocity.db.core.engine import Engine
+from velocity.db import exceptions
+
+
+class MockException(Exception):
+    """Mock exception for testing"""
+
+    def __init__(self, message, pgcode=None, pgerror=None):
+        super().__init__(message)
+        self.pgcode = pgcode
+        self.pgerror = pgerror
+
+
+class MockSQL:
+    """Mock SQL class for testing"""
+
+    server = "PostgreSQL"
+
+    ApplicationErrorCodes = ["22P02", "42883", "42501", "42601", "25P01", "25P02"]
+    DatabaseMissingErrorCodes = ["3D000"]
+    TableMissingErrorCodes = ["42P01"]
+    ColumnMissingErrorCodes = ["42703"]
+    ForeignKeyMissingErrorCodes = ["42704"]
+    ConnectionErrorCodes = [
+        "08001",
+        "08S01",
+        "57P03",
+        "08006",
+        "53300",
+        "08003",
+        "08004",
+        "08P01",
+    ]
+    DuplicateKeyErrorCodes = ["23505"]
+    RetryTransactionCodes = ["40001", "40P01", "40002"]
+    TruncationErrorCodes = ["22001"]
+    LockTimeoutErrorCodes = ["55P03"]
+    DatabaseObjectExistsErrorCodes = ["42710", "42P07", "42P04"]
+    DataIntegrityErrorCodes = ["23503", "23502", "23514", "23P01", "22003"]
+
+    @classmethod
+    def get_error(cls, e):
+        return getattr(e, "pgcode", None), getattr(e, "pgerror", None)
+
+
+class TestProcessErrorRobustness(unittest.TestCase):
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.engine = Engine(driver=Mock(), config={"test": "config"}, sql=MockSQL())
+
+        # Capture logs for testing
+        self.log_handler = logging.StreamHandler()
+        self.log_handler.setLevel(logging.DEBUG)
+        logger = logging.getLogger("velocity.db.engine")
+        logger.addHandler(self.log_handler)
+        logger.setLevel(logging.DEBUG)
+
+    def test_error_code_classification(self):
+        """Test that error codes are properly classified"""
+        test_cases = [
+            # (pgcode, expected_exception_class, description)
+            ("23505", exceptions.DbDuplicateKeyError, "unique violation"),
+            ("40001", exceptions.DbRetryTransaction, "serialization failure"),
+            ("40P01", exceptions.DbRetryTransaction, "deadlock detected"),
+            ("42501", exceptions.DbApplicationError, "insufficient privilege"),
+            ("42601", exceptions.DbApplicationError, "syntax error"),
+            ("25P01", exceptions.DbApplicationError, "no active sql transaction"),
+            ("3D000", exceptions.DbDatabaseMissingError, "invalid catalog name"),
+            ("08003", exceptions.DbConnectionError, "connection does not exist"),
+            ("23502", exceptions.DbDataIntegrityError, "not null violation"),
+            ("42P01", exceptions.DbTableMissingError, "undefined table"),
+            ("42703", exceptions.DbColumnMissingError, "undefined column"),
+        ]
+
+        for pgcode, expected_exception, description in test_cases:
+            with self.subTest(pgcode=pgcode, description=description):
+                mock_exc = MockException(f"Test error: {description}", pgcode=pgcode)
+
+                with patch(
+                    "sys.exc_info", return_value=(type(mock_exc), mock_exc, None)
+                ):
+                    with self.assertRaises(expected_exception):
+                        self.engine.process_error("test sql", {"param": "value"})
+
+    def test_regex_fallback_patterns(self):
+        """Test regex pattern fallback when error codes aren't available"""
+        test_cases = [
+            # (message, expected_exception_class, description)
+            (
+                "key (sys_id)=(123) already exists.",
+                exceptions.DbDuplicateKeyError,
+                "sys_id duplicate",
+            ),
+            (
+                "duplicate key value violates unique constraint",
+                exceptions.DbDuplicateKeyError,
+                "unique constraint",
+            ),
+            (
+                "database 'testdb' does not exist",
+                exceptions.DbDatabaseMissingError,
+                "database missing",
+            ),
+            (
+                "no such database: mydb",
+                exceptions.DbDatabaseMissingError,
+                "database not found",
+            ),
+            (
+                "table 'users' already exists",
+                exceptions.DbObjectExistsError,
+                "object exists",
+            ),
+            (
+                "server closed the connection unexpectedly",
+                exceptions.DbConnectionError,
+                "connection closed",
+            ),
+            (
+                "connection timed out",
+                exceptions.DbConnectionError,
+                "connection timeout",
+            ),
+            ("no such table: users", exceptions.DbTableMissingError, "table missing"),
+            (
+                "permission denied for table users",
+                exceptions.DbApplicationError,
+                "permission denied",
+            ),
+            (
+                "syntax error at or near 'SELCT'",
+                exceptions.DbApplicationError,
+                "syntax error",
+            ),
+            ("deadlock detected", exceptions.DbLockTimeoutError, "deadlock"),
+        ]
+
+        for message, expected_exception, description in test_cases:
+            with self.subTest(message=message, description=description):
+                mock_exc = MockException(
+                    message
+                )  # No pgcode - will trigger regex fallback
+
+                with patch(
+                    "sys.exc_info", return_value=(type(mock_exc), mock_exc, None)
+                ):
+                    with self.assertRaises(expected_exception):
+                        self.engine.process_error("test sql", {"param": "value"})
+
+    def test_already_custom_exception(self):
+        """Test that custom exceptions are re-raised as-is"""
+        custom_exc = exceptions.DbConnectionError("Already a custom exception")
+
+        with patch("sys.exc_info", return_value=(type(custom_exc), custom_exc, None)):
+            with self.assertRaises(exceptions.DbConnectionError):
+                self.engine.process_error()
+
+    def test_no_active_exception(self):
+        """Test handling when no exception is active"""
+        with patch("sys.exc_info", return_value=(None, None, None)):
+            with self.assertRaises(RuntimeError) as cm:
+                self.engine.process_error()
+            self.assertIn("no active exception", str(cm.exception))
+
+    def test_get_error_failure(self):
+        """Test handling when get_error fails"""
+        mock_exc = MockException("Test error")
+
+        # Mock get_error to raise an exception
+        with patch.object(
+            self.engine.sql, "get_error", side_effect=Exception("get_error failed")
+        ):
+            with patch("sys.exc_info", return_value=(type(mock_exc), mock_exc, None)):
+                # Should still handle the error using fallback mechanisms
+                with self.assertRaises(
+                    Exception
+                ):  # Original exception should be re-raised
+                    self.engine.process_error()
+
+    def test_exception_str_failure(self):
+        """Test handling when converting exception to string fails"""
+
+        class UnstringableException(Exception):
+            def __str__(self):
+                raise Exception("Cannot convert to string")
+
+        mock_exc = UnstringableException("Test error")
+
+        with patch("sys.exc_info", return_value=(type(mock_exc), mock_exc, None)):
+            with self.assertRaises(UnstringableException):
+                self.engine.process_error()
+
+    def test_exception_chaining(self):
+        """Test that exception chaining is preserved"""
+        mock_exc = MockException("Original error", pgcode="23505")
+
+        with patch("sys.exc_info", return_value=(type(mock_exc), mock_exc, None)):
+            try:
+                self.engine.process_error()
+            except exceptions.DbDuplicateKeyError as e:
+                # Check that the original exception is chained
+                self.assertIsInstance(e.__cause__, MockException)
+                self.assertEqual(str(e.__cause__), "Original error")
+
+    def test_enhanced_logging(self):
+        """Test that enhanced logging provides good context"""
+        mock_exc = MockException(
+            "Test error for logging", pgcode="23505", pgerror="duplicate key"
+        )
+
+        with patch("sys.exc_info", return_value=(type(mock_exc), mock_exc, None)):
+            with patch("velocity.db.core.engine.logger") as mock_logger:
+                with self.assertRaises(exceptions.DbDuplicateKeyError):
+                    self.engine.process_error("SELECT * FROM test", {"id": 123})
+
+                # Verify warning log was called with proper context
+                mock_logger.warning.assert_called_once()
+                call_args = mock_logger.warning.call_args
+
+                # Check the message contains key information
+                message = call_args[0][0]
+                self.assertIn("code=23505", message)
+                self.assertIn("message=duplicate key", message)
+                self.assertIn("type=MockException", message)
+
+                # Check extra context is provided
+                extra = call_args[1]["extra"]
+                self.assertEqual(extra["error_code"], "23505")
+                self.assertEqual(extra["sql_stmt"], "SELECT * FROM test")
+                self.assertEqual(extra["sql_params"], {"id": 123})
+
+    def test_unknown_error_logging(self):
+        """Test logging for unhandled/unknown errors"""
+
+        class UnknownException(Exception):
+            pass
+
+        mock_exc = UnknownException("Unknown error type")
+
+        with patch("sys.exc_info", return_value=(type(mock_exc), mock_exc, None)):
+            with patch("velocity.db.core.engine.logger") as mock_logger:
+                with self.assertRaises(UnknownException):
+                    self.engine.process_error("SELECT unknown", {"param": "test"})
+
+                # Verify error log was called for unhandled case
+                mock_logger.error.assert_called_once()
+                call_args = mock_logger.error.call_args
+
+                # Check that comprehensive context is logged
+                extra = call_args[1]["extra"]
+                self.assertIn("available_error_codes", extra)
+                self.assertIn("original_exception_type", extra)
+                self.assertEqual(extra["original_exception_type"], "UnknownException")
+
+
+def main():
+    print("Testing robustness of improved process_error method...")
+
+    # Configure logging to see the output
+    logging.basicConfig(
+        level=logging.DEBUG, format="%(levelname)s - %(name)s - %(message)s"
+    )
+
+    # Run the tests
+    unittest.main(argv=[""], exit=False, verbosity=2)
+
+    print("\n=== Summary ===")
+    print("✅ Enhanced error code classification")
+    print("✅ Robust regex pattern fallback")
+    print("✅ Exception chaining preservation")
+    print("✅ Enhanced logging with context")
+    print("✅ Graceful handling of edge cases")
+    print("✅ Better debugging information")
+
+
+if __name__ == "__main__":
+    main()

velocity/db/tests/test_result_caching.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""
+Test cases for Result class caching functionality.
+
+Tests the new caching behavior in Result class that pre-fetches the first row
+to enable immediate boolean evaluation and accurate state tracking.
+"""
+
+import unittest
+import sys
+import os
+
+# Add src to path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from velocity.db.core.result import Result
+
+
+class MockCursor:
+    """Mock cursor for testing"""
+
+    def __init__(self, rows=None, description=None, raise_on_fetch=False):
+        self.rows = rows or []
+        self.description = description or [("id",), ("name",)]
+        self.position = 0
+        self.raise_on_fetch = raise_on_fetch
+        self.closed = False
+
+    def fetchone(self):
+        if self.closed:
+            raise Exception("Cursor is closed")
+        if self.raise_on_fetch:
+            raise Exception("Simulated cursor error")
+        if self.position < len(self.rows):
+            row = self.rows[self.position]
+            self.position += 1
+            return row
+        return None
+
+    def fetchall(self):
+        if self.closed:
+            raise Exception("Cursor is closed")
+        remaining = self.rows[self.position :]
+        self.position = len(self.rows)
+        return remaining
+
+    def close(self):
+        self.closed = True
+
+
+class TestResultCaching(unittest.TestCase):
+
+    def test_empty_result(self):
+        """Test with no rows"""
+        cursor = MockCursor(rows=[])
+        result = Result(cursor)
+
+        self.assertFalse(bool(result))
+        self.assertTrue(result.is_empty())
+        self.assertFalse(result.has_results())
+        self.assertIsNone(result.one())
+
+    def test_single_row(self):
+        """Test with one row"""
+        cursor = MockCursor(rows=[(1, "Alice")])
+        result = Result(cursor)
+
+        self.assertTrue(bool(result))
+        self.assertFalse(result.is_empty())
+        self.assertTrue(result.has_results())
+
+        row = result.one()
+        self.assertEqual(row["id"], 1)
+        self.assertEqual(row["name"], "Alice")
+
+    def test_multiple_rows_boolean_state(self):
+        """Test that boolean state changes as rows are consumed"""
+        cursor = MockCursor(rows=[(1, "Alice"), (2, "Bob"), (3, "Charlie")])
+        result = Result(cursor)
+
+        # Initially should be True (has results)
+        self.assertTrue(bool(result))
+        self.assertTrue(result.has_results())
+        self.assertFalse(result.is_empty())
+
+        # Consume first row
+        row1 = next(result)
+        self.assertEqual(row1["id"], 1)
+
+        # Should still be True (more rows available)
+        self.assertTrue(bool(result))
+        self.assertTrue(result.has_results())
+
+        # Consume second row
+        row2 = next(result)
+        self.assertEqual(row2["id"], 2)
+
+        # Should still be True (one more row available)
+        self.assertTrue(bool(result))
+        self.assertTrue(result.has_results())
+
+        # Consume third row
+        row3 = next(result)
+        self.assertEqual(row3["id"], 3)
+
+        # Now should be False (no more rows)
+        self.assertFalse(bool(result))
+        self.assertFalse(result.has_results())
+        self.assertTrue(result.is_empty())
+
+        # Trying to get another row should raise StopIteration
+        with self.assertRaises(StopIteration):
+            next(result)
+
+    def test_scalar_functionality(self):
+        """Test scalar functionality"""
+        cursor = MockCursor(rows=[(42, "Answer")])
+        result = Result(cursor)
+
+        self.assertTrue(bool(result))
+        scalar_value = result.scalar()
+        self.assertEqual(scalar_value, 42)
+
+        # After scalar(), should be exhausted
+        self.assertFalse(bool(result))
+
+    def test_boolean_check_then_iterate(self):
+        """Test checking boolean state then iterating"""
+        cursor = MockCursor(rows=[(1, "Alice"), (2, "Bob")])
+        result = Result(cursor)
+
+        # Check if we have results
+        if result:
+            rows = list(result)
+            self.assertEqual(len(rows), 2)
+            self.assertEqual(rows[0]["id"], 1)
+            self.assertEqual(rows[1]["id"], 2)
+        else:
+            self.fail("Result should have data")
+
+        # After consuming all, should be False
+        self.assertFalse(bool(result))
+
+    def test_one_method_exhausts_result(self):
+        """Test that one() method marks result as exhausted"""
+        cursor = MockCursor(rows=[(1, "Alice"), (2, "Bob")])
+        result = Result(cursor)
+
+        self.assertTrue(bool(result))
+
+        row = result.one()
+        self.assertEqual(row["id"], 1)
+
+        # After one(), should be exhausted even though there were more rows
+        self.assertFalse(bool(result))
+
+    def test_caching_preserves_first_row(self):
+        """Test that first row caching doesn't interfere with normal iteration"""
+        cursor = MockCursor(rows=[(1, "Alice"), (2, "Bob"), (3, "Charlie")])
+        result = Result(cursor)
+
+        # Check boolean state (which triggers first row caching)
+        self.assertTrue(bool(result))
+
+        # Iterate through all rows - should get all three
+        rows = list(result)
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(rows[0]["id"], 1)
+        self.assertEqual(rows[1]["id"], 2)
+        self.assertEqual(rows[2]["id"], 3)
+
+    def test_multiple_boolean_checks(self):
+        """Test multiple boolean checks return consistent results"""
+        cursor = MockCursor(rows=[(1, "Alice"), (2, "Bob")])
+        result = Result(cursor)
+
+        # Multiple boolean checks should be consistent
+        self.assertTrue(bool(result))
+        self.assertTrue(result.has_results())
+        self.assertFalse(result.is_empty())
+        self.assertTrue(bool(result))  # Should still be True
+
+        # Consume one row
+        next(result)
+
+        # Should still be True (one more row)
+        self.assertTrue(bool(result))
+        self.assertTrue(result.has_results())
+
+        # Consume last row
+        next(result)
+
+        # Now should be False
+        self.assertFalse(bool(result))
+        self.assertFalse(result.has_results())
+        self.assertTrue(result.is_empty())
+
+    def test_cursor_error_handling(self):
+        """Test handling of cursor errors"""
+        cursor = MockCursor(rows=[(1, "Alice")], raise_on_fetch=True)
+        result = Result(cursor)
+
+        # Should handle cursor error gracefully and return False
+        self.assertFalse(bool(result))
+        self.assertTrue(result.is_empty())
+        self.assertFalse(result.has_results())
+
+    def test_closed_cursor_handling(self):
+        """Test handling of operations on closed cursor"""
+        cursor = MockCursor(rows=[(1, "Alice"), (2, "Bob")])
+        result = Result(cursor)
+
+        # Should work initially
+        self.assertTrue(bool(result))
+
+        # Close the result explicitly
+        result.close()
+
+        # After closing, result should be exhausted
+        self.assertFalse(bool(result))
+        self.assertTrue(result.is_empty())
+        self.assertFalse(result.has_results())
+
+    def test_scalar_with_cursor_error(self):
+        """Test scalar method with cursor errors"""
+        cursor = MockCursor(rows=[(42, "Answer")])
+        result = Result(cursor)
+
+        # Scalar should work with cached first row
+        scalar_value = result.scalar()
+        self.assertEqual(scalar_value, 42)
+
+        # Now test with a new result that has cursor error on fresh fetch
+        cursor2 = MockCursor(rows=[], raise_on_fetch=True)
+        result2 = Result(cursor2)
+
+        # Should return default value gracefully
+        scalar_value2 = result2.scalar("default")
+        self.assertEqual(scalar_value2, "default")
+
+    def test_columns_property_robustness(self):
+        """Test columns property handles missing attributes gracefully"""
+
+        # Create a mock column that behaves like real DB cursor columns
+        class MockColumn:
+            def __init__(self, name):
+                self.name = name
+
+        cursor = MockCursor(rows=[(1, "test")])
+        cursor.description = [MockColumn("test_col")]
+
+        result = Result(cursor)
+        columns = result.columns
+
+        # Should have at least the column name
+        self.assertIn("test_col", columns)
+        self.assertIn("type_name", columns["test_col"])
+        self.assertEqual(columns["test_col"]["type_name"], "unknown")
+
+    def test_multiple_close_calls(self):
+        """Test that multiple close calls don't cause issues"""
+        cursor = MockCursor(rows=[(1, "Alice")])
+        result = Result(cursor)
+
+        # Get the initial state (cached first row)
+        initial_state = bool(result)
+        self.assertTrue(initial_state)
+
+        # Multiple close calls should be safe
+        result.close()
+        result.close()
+        result.close()
+
+        # Result should be marked as exhausted after close
+        self.assertFalse(bool(result))
+
+
+if __name__ == "__main__":
+    unittest.main()