velocity-python 0.0.131__py3-none-any.whl → 0.0.134__py3-none-any.whl

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()

velocity/db/tests/test_result_sql_aware.py

@@ -0,0 +1,117 @@
+import unittest
+from unittest.mock import Mock, MagicMock
+from velocity.db.core.result import Result
+
+
+class TestResultSQLAwareFetch(unittest.TestCase):
+    """
+    Test cases to verify that Result doesn't attempt to fetch from
+    INSERT/UPDATE/DELETE operations, preventing cursor errors.
+    """
+
+    def test_insert_sql_no_fetch_attempt(self):
+        """Test that INSERT SQL doesn't attempt to fetch rows."""
+        mock_cursor = Mock()
+
+        # Create Result with INSERT SQL
+        result = Result(
+            cursor=mock_cursor, sql="INSERT INTO test (name) VALUES ('test')"
+        )
+
+        # Verify fetchone was never called on INSERT
+        mock_cursor.fetchone.assert_not_called()
+
+        # Verify result is marked as exhausted (no rows expected)
+        self.assertTrue(result._exhausted)
+        self.assertTrue(result._first_row_fetched)
+
+        # Verify cursor is still valid (not set to None)
+        self.assertIsNotNone(result.cursor)
+
+    def test_update_sql_no_fetch_attempt(self):
+        """Test that UPDATE SQL doesn't attempt to fetch rows."""
+        mock_cursor = Mock()
+
+        # Create Result with UPDATE SQL
+        result = Result(cursor=mock_cursor, sql="UPDATE test SET name='new' WHERE id=1")
+
+        # Verify fetchone was never called on UPDATE
+        mock_cursor.fetchone.assert_not_called()
+
+        # Verify result is marked as exhausted (no rows expected)
+        self.assertTrue(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+
+    def test_delete_sql_no_fetch_attempt(self):
+        """Test that DELETE SQL doesn't attempt to fetch rows."""
+        mock_cursor = Mock()
+
+        # Create Result with DELETE SQL
+        result = Result(cursor=mock_cursor, sql="DELETE FROM test WHERE id=1")
+
+        # Verify fetchone was never called on DELETE
+        mock_cursor.fetchone.assert_not_called()
+
+        # Verify result is marked as exhausted (no rows expected)
+        self.assertTrue(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+
+    def test_select_sql_does_fetch(self):
+        """Test that SELECT SQL still attempts to fetch rows."""
+        mock_cursor = Mock()
+        mock_cursor.fetchone.return_value = None  # No rows returned
+
+        # Create Result with SELECT SQL
+        result = Result(cursor=mock_cursor, sql="SELECT * FROM test")
+
+        # Verify fetchone WAS called on SELECT
+        mock_cursor.fetchone.assert_called_once()
+
+        # Verify result is marked as exhausted (no rows returned)
+        self.assertTrue(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+
+    def test_select_sql_with_rows(self):
+        """Test that SELECT SQL with rows works correctly."""
+        mock_cursor = Mock()
+        mock_cursor.fetchone.return_value = ("test_value",)
+        mock_cursor.description = [("column1",)]
+
+        # Create Result with SELECT SQL
+        result = Result(cursor=mock_cursor, sql="SELECT column1 FROM test")
+
+        # Verify fetchone WAS called on SELECT
+        mock_cursor.fetchone.assert_called_once()
+
+        # Verify result has cached first row and is not exhausted
+        self.assertIsNotNone(result._cached_first_row)
+        self.assertFalse(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+
+    def test_case_insensitive_sql_detection(self):
+        """Test that SQL detection works with various cases."""
+        test_cases = [
+            "insert into test values (1)",  # lowercase
+            "INSERT INTO test VALUES (1)",  # uppercase
+            "   INSERT INTO test VALUES (1)",  # leading whitespace
+            "Insert Into test Values (1)",  # mixed case
+            "UPDATE test SET name='x'",  # update
+            "delete from test",  # delete
+            "TRUNCATE TABLE test",  # truncate
+        ]
+
+        for sql in test_cases:
+            with self.subTest(sql=sql):
+                mock_cursor = Mock()
+                result = Result(cursor=mock_cursor, sql=sql)
+
+                # Verify fetchone was never called
+                mock_cursor.fetchone.assert_not_called()
+
+                # Verify result is marked as exhausted
+                self.assertTrue(result._exhausted)
+                self.assertIsNotNone(result.cursor)
+
+
+if __name__ == "__main__":
+    unittest.main()