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

velocity/db/tests/test_row_get_missing_column.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""
+Test to verify that Row.get() handles missing columns gracefully.
+"""
+
+import unittest
+from unittest.mock import Mock, patch
+from velocity.db.core.row import Row
+from velocity.db.exceptions import DbColumnMissingError
+
+
+class TestRowGetMissingColumn(unittest.TestCase):
+
+    def setUp(self):
+        """Set up a mock row for testing."""
+        # Create a mock table
+        self.mock_table = Mock()
+
+        # Create a row instance
+        self.row = Row(self.mock_table, {"id": 1})
+
+    def test_get_existing_column(self):
+        """Test that get() works normally for existing columns."""
+        # Mock the table.get_value to return a normal value
+        self.mock_table.get_value.return_value = "test_value"
+
+        result = self.row.get("existing_column")
+        self.assertEqual(result, "test_value")
+
+    def test_get_missing_column_with_db_column_missing_error(self):
+        """Test that get() returns default when DbColumnMissingError is raised."""
+        # Mock the table.get_value to raise DbColumnMissingError
+        self.mock_table.get_value.side_effect = DbColumnMissingError(
+            'Column "nonexistent" does not exist'
+        )
+
+        result = self.row.get("nonexistent", "default_value")
+        self.assertEqual(result, "default_value")
+
+    def test_get_missing_column_with_generic_error(self):
+        """Test that get() returns default when a generic column error is raised."""
+        # Mock the table.get_value to raise a generic exception with column error message
+        generic_error = Exception('column "descriptor" does not exist')
+        self.mock_table.get_value.side_effect = generic_error
+
+        result = self.row.get("descriptor", "default_value")
+        self.assertEqual(result, "default_value")
+
+    def test_get_missing_column_no_default(self):
+        """Test that get() returns None when no default is provided."""
+        # Mock the table.get_value to raise DbColumnMissingError
+        self.mock_table.get_value.side_effect = DbColumnMissingError(
+            'Column "nonexistent" does not exist'
+        )
+
+        result = self.row.get("nonexistent")
+        self.assertIsNone(result)
+
+    def test_get_other_exception_reraises(self):
+        """Test that get() re-raises non-column-related exceptions."""
+        # Mock the table.get_value to raise a different type of exception
+        other_error = Exception("Some other database error")
+        self.mock_table.get_value.side_effect = other_error
+
+        with self.assertRaises(Exception) as context:
+            self.row.get("some_column")
+
+        self.assertEqual(str(context.exception), "Some other database error")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/test_schema_locking_initializers.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Test schema locking support in all database initializers.
+"""
+
+import unittest
+import os
+from unittest.mock import patch, MagicMock
+
+from velocity.db.servers.mysql import MySQLInitializer
+from velocity.db.servers.sqlite import SQLiteInitializer  
+from velocity.db.servers.sqlserver import SQLServerInitializer
+from velocity.db.servers.postgres import PostgreSQLInitializer
+
+
+class TestSchemaLockingInitializers(unittest.TestCase):
+    """Test that all database initializers support schema locking parameters."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        # Mock the database drivers
+        self.mock_mysql = MagicMock()
+        self.mock_sqlite = MagicMock()
+        self.mock_pytds = MagicMock()
+        self.mock_psycopg2 = MagicMock()
+        
+    @patch('mysql.connector')
+    def test_mysql_schema_locked_parameter(self, mock_mysql_connector):
+        """Test MySQL initializer accepts schema_locked parameter."""
+        mock_mysql_connector.return_value = self.mock_mysql
+        
+        config = {
+            "database": "test_db",
+            "host": "localhost", 
+            "user": "test_user",
+            "password": "test_pass"
+        }
+        
+        # Test with schema_locked=True
+        engine = MySQLInitializer.initialize(config, schema_locked=True)
+        self.assertTrue(engine.schema_locked)
+        
+        # Test with schema_locked=False (default)
+        engine = MySQLInitializer.initialize(config, schema_locked=False)
+        self.assertFalse(engine.schema_locked)
+        
+        # Test default behavior
+        engine = MySQLInitializer.initialize(config)
+        self.assertFalse(engine.schema_locked)
+
+    def test_sqlite_schema_locked_parameter(self):
+        """Test SQLite initializer accepts schema_locked parameter."""
+        config = {"database": ":memory:"}
+        
+        # Test with schema_locked=True
+        engine = SQLiteInitializer.initialize(config, schema_locked=True)
+        self.assertTrue(engine.schema_locked)
+        
+        # Test with schema_locked=False (default)
+        engine = SQLiteInitializer.initialize(config, schema_locked=False)
+        self.assertFalse(engine.schema_locked)
+        
+        # Test default behavior
+        engine = SQLiteInitializer.initialize(config)
+        self.assertFalse(engine.schema_locked)
+
+    @patch('pytds')
+    def test_sqlserver_schema_locked_parameter(self, mock_pytds):
+        """Test SQL Server initializer accepts schema_locked parameter."""
+        mock_pytds.return_value = self.mock_pytds
+        
+        config = {
+            "database": "test_db",
+            "server": "localhost",
+            "user": "test_user", 
+            "password": "test_pass"
+        }
+        
+        # Test with schema_locked=True
+        engine = SQLServerInitializer.initialize(config, schema_locked=True)
+        self.assertTrue(engine.schema_locked)
+        
+        # Test with schema_locked=False (default)
+        engine = SQLServerInitializer.initialize(config, schema_locked=False)
+        self.assertFalse(engine.schema_locked)
+        
+        # Test default behavior
+        engine = SQLServerInitializer.initialize(config)
+        self.assertFalse(engine.schema_locked)
+
+    @patch('psycopg2')
+    def test_postgres_schema_locked_parameter(self, mock_psycopg2):
+        """Test PostgreSQL initializer accepts schema_locked parameter."""
+        mock_psycopg2.return_value = self.mock_psycopg2
+        
+        config = {
+            "database": "test_db",
+            "host": "localhost",
+            "user": "test_user", 
+            "password": "test_pass"
+        }
+        
+        # Test with schema_locked=True
+        engine = PostgreSQLInitializer.initialize(config, schema_locked=True)
+        self.assertTrue(engine.schema_locked)
+        
+        # Test with schema_locked=False (default)
+        engine = PostgreSQLInitializer.initialize(config, schema_locked=False)
+        self.assertFalse(engine.schema_locked)
+        
+        # Test default behavior
+        engine = PostgreSQLInitializer.initialize(config)
+        self.assertFalse(engine.schema_locked)
+
+    @patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "true"})
+    @patch('mysql.connector')
+    def test_mysql_environment_variable_override(self, mock_mysql_connector):
+        """Test MySQL respects VELOCITY_SCHEMA_LOCKED environment variable."""
+        mock_mysql_connector.return_value = self.mock_mysql
+        
+        config = {
+            "database": "test_db",
+            "host": "localhost",
+            "user": "test_user",
+            "password": "test_pass"
+        }
+        
+        # Environment variable should override default
+        engine = MySQLInitializer.initialize(config)
+        self.assertTrue(engine.schema_locked)
+        
+        # Environment variable should override explicit False
+        engine = MySQLInitializer.initialize(config, schema_locked=False)
+        self.assertTrue(engine.schema_locked)
+
+    @patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "true"})
+    def test_sqlite_environment_variable_override(self):
+        """Test SQLite respects VELOCITY_SCHEMA_LOCKED environment variable."""
+        config = {"database": ":memory:"}
+        
+        # Environment variable should override default
+        engine = SQLiteInitializer.initialize(config)
+        self.assertTrue(engine.schema_locked)
+        
+        # Environment variable should override explicit False
+        engine = SQLiteInitializer.initialize(config, schema_locked=False)
+        self.assertTrue(engine.schema_locked)
+
+    @patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "true"})
+    @patch('pytds')
+    def test_sqlserver_environment_variable_override(self, mock_pytds):
+        """Test SQL Server respects VELOCITY_SCHEMA_LOCKED environment variable."""
+        mock_pytds.return_value = self.mock_pytds
+        
+        config = {
+            "database": "test_db",
+            "server": "localhost",
+            "user": "test_user",
+            "password": "test_pass"
+        }
+        
+        # Environment variable should override default
+        engine = SQLServerInitializer.initialize(config)
+        self.assertTrue(engine.schema_locked)
+        
+        # Environment variable should override explicit False
+        engine = SQLServerInitializer.initialize(config, schema_locked=False)
+        self.assertTrue(engine.schema_locked)
+
+    @patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "true"})
+    @patch('psycopg2')
+    def test_postgres_environment_variable_override(self, mock_psycopg2):
+        """Test PostgreSQL respects VELOCITY_SCHEMA_LOCKED environment variable."""
+        mock_psycopg2.return_value = self.mock_psycopg2
+        
+        config = {
+            "database": "test_db",
+            "host": "localhost",
+            "user": "test_user",
+            "password": "test_pass"
+        }
+        
+        # Environment variable should override default
+        engine = PostgreSQLInitializer.initialize(config)
+        self.assertTrue(engine.schema_locked)
+        
+        # Environment variable should override explicit False
+        engine = PostgreSQLInitializer.initialize(config, schema_locked=False)
+        self.assertTrue(engine.schema_locked)
+
+    @patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "1"})
+    @patch('mysql.connector')
+    def test_environment_variable_various_true_values(self, mock_mysql_connector):
+        """Test that various 'true' values in environment variable work."""
+        mock_mysql_connector.return_value = self.mock_mysql
+        
+        config = {
+            "database": "test_db",
+            "host": "localhost",
+            "user": "test_user",
+            "password": "test_pass"
+        }
+        
+        # Test "1"
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "1"}):
+            engine = MySQLInitializer.initialize(config)
+            self.assertTrue(engine.schema_locked)
+        
+        # Test "yes"
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "yes"}):
+            engine = MySQLInitializer.initialize(config)
+            self.assertTrue(engine.schema_locked)
+        
+        # Test "TRUE" (case insensitive)
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "TRUE"}):
+            engine = MySQLInitializer.initialize(config)
+            self.assertTrue(engine.schema_locked)
+        
+        # Test "false" (should not lock)
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "false"}):
+            engine = MySQLInitializer.initialize(config)
+            self.assertFalse(engine.schema_locked)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/test_schema_locking_simple.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Simple test to verify schema locking parameters in initializers.
+"""
+
+import unittest
+import os
+from unittest.mock import patch
+
+from velocity.db.servers.sqlite import SQLiteInitializer
+
+
+class TestSchemaLockingSimple(unittest.TestCase):
+    """Test schema locking with SQLite (no external dependencies)."""
+    
+    def test_sqlite_schema_locked_parameter(self):
+        """Test SQLite initializer accepts schema_locked parameter."""
+        config = {"database": ":memory:"}
+        
+        # Test with schema_locked=True
+        engine = SQLiteInitializer.initialize(config, schema_locked=True)
+        self.assertTrue(engine.schema_locked)
+        
+        # Test with schema_locked=False (default)
+        engine = SQLiteInitializer.initialize(config, schema_locked=False)
+        self.assertFalse(engine.schema_locked)
+        
+        # Test default behavior
+        engine = SQLiteInitializer.initialize(config)
+        self.assertFalse(engine.schema_locked)
+
+    @patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "true"})
+    def test_sqlite_environment_variable_override(self):
+        """Test SQLite respects VELOCITY_SCHEMA_LOCKED environment variable."""
+        config = {"database": ":memory:"}
+        
+        # Environment variable should override default
+        engine = SQLiteInitializer.initialize(config)
+        self.assertTrue(engine.schema_locked)
+        
+        # Environment variable should override explicit False
+        engine = SQLiteInitializer.initialize(config, schema_locked=False)
+        self.assertTrue(engine.schema_locked)
+
+    def test_environment_variable_various_true_values(self):
+        """Test that various 'true' values in environment variable work."""
+        config = {"database": ":memory:"}
+        
+        # Test "1"
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "1"}):
+            engine = SQLiteInitializer.initialize(config)
+            self.assertTrue(engine.schema_locked)
+        
+        # Test "yes"
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "yes"}):
+            engine = SQLiteInitializer.initialize(config)
+            self.assertTrue(engine.schema_locked)
+        
+        # Test "TRUE" (case insensitive)
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "TRUE"}):
+            engine = SQLiteInitializer.initialize(config)
+            self.assertTrue(engine.schema_locked)
+        
+        # Test "false" (should not lock)
+        with patch.dict(os.environ, {"VELOCITY_SCHEMA_LOCKED": "false"}):
+            engine = SQLiteInitializer.initialize(config)
+            self.assertFalse(engine.schema_locked)
+
+    def test_schema_locking_methods(self):
+        """Test schema locking runtime methods work correctly."""
+        config = {"database": ":memory:"}
+        
+        # Start unlocked
+        engine = SQLiteInitializer.initialize(config, schema_locked=False)
+        self.assertFalse(engine.schema_locked)
+        
+        # Lock at runtime
+        engine.lock_schema()
+        self.assertTrue(engine.schema_locked)
+        
+        # Unlock at runtime
+        engine.unlock_schema()
+        self.assertFalse(engine.schema_locked)
+        
+        # Test context manager
+        engine.lock_schema()
+        self.assertTrue(engine.schema_locked)
+        
+        with engine.unlocked_schema():
+            self.assertFalse(engine.schema_locked)
+        
+        # Should be locked again after context
+        self.assertTrue(engine.schema_locked)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/test_sql_builder.py

@@ -0,0 +1,165 @@
+import unittest
+from velocity.db.servers import postgres
+from velocity.db.core.table import Query
+import sqlparse
+
+test_db = "test_foreign_key_db"
+engine = postgres.initialize(database=test_db)
+
+
+@engine.transaction
+class TestSqlBuilder(unittest.TestCase):
+
+    def test_basic_select(self, tx):
+        sql, vals = tx.table("child_table").select(
+            columns=[
+                "parent_id>name",
+                "middle_id>title",
+                "sys_id",
+                "description",
+            ],
+            where={
+                "sys_id": 1,
+                "parent_id>name": None,
+                "in_list": [1, 2, 3, 4, 5],
+                "in_tuple": (1, 2, 3, 4, 5),
+                "!something": Query("Select * from table where sys_id = %s", (1000,)),
+                "!=notequal": 2,
+                "><between": [1, 10],
+            },
+            groupby="parent_id>name, middle_id>title",
+            having={"<>parent_id>name": "test"},
+            orderby="parent_id>name desc, middle_id>title asc, sys_id desc",
+            sql_only=True,
+        )
+
+        expected_sql = """SELECT B.name,
+       C.title,
+       A.sys_id,
+       A.description
+FROM child_table AS A
+LEFT JOIN parent_table AS B ON A.parent_id = parent_table.sys_id
+LEFT JOIN middle_table AS C ON A.middle_id = middle_table.sys_id
+WHERE A.sys_id = %s
+  AND B.name IS NULL
+  AND A.in_list IN %s
+  AND A.in_tuple IN %s
+  AND A.something NOT IN
+    (SELECT *
+     FROM TABLE
+     WHERE sys_id = %s)
+  AND A.notequal <> %s
+  AND A.between BETWEEN %s AND %s
+GROUP BY B.name,
+         C.title
+HAVING B.name <> %s
+ORDER BY B.name DESC,
+         C.title ASC,
+         sys_id DESC"""
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(
+            vals, (1, [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], 1000, 2, 1, 10, "test")
+        )
+
+    def test_select_with_wildcard(self, tx):
+        sql, vals = tx.table("users").select(sql_only=True)
+        expected_sql = "SELECT * FROM users"
+        expected_sql = sqlparse.format(
+            expected_sql, reindent=True, keyword_case="upper"
+        )
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, ())
+
+    def test_select_with_columns(self, tx):
+        sql, vals = tx.table("users").select(columns=["id", "name"], sql_only=True)
+        expected_sql = "SELECT id, name FROM users"
+        expected_sql = sqlparse.format(
+            expected_sql, reindent=True, keyword_case="upper"
+        )
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, ())
+
+    def test_select_with_distinct(self, tx):
+        sql, vals = tx.table("users").select(columns="DISTINCT id, name", sql_only=True)
+        print(sql)
+        expected_sql = "SELECT DISTINCT id, name FROM users"
+        expected_sql = sqlparse.format(
+            expected_sql, reindent=True, keyword_case="upper"
+        )
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, ())
+
+    def test_select_with_join(self, tx):
+        sql, vals = tx.table("users").select(
+            columns=["id", "name", "profile>email"],
+            where={"profile>email": "test@example.com"},
+            sql_only=True,
+        )
+        print(sql)
+        expected_sql = (
+            'SELECT "A"."id", "A"."name", "B"."email" AS "profile_email" '
+            'FROM "users" AS "A" '
+            'LEFT OUTER JOIN "profile" AS "B" '
+            'ON "A"."profile_id" = "B"."id" '
+            'WHERE "B"."email" = %s'
+        )
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, ("test@example.com",))
+
+    def xtest_group_by(self):
+        sql, vals = SqlBuilder.select(
+            columns="id, COUNT(*)", table="users", groupby="id"
+        )
+        expected_sql = 'SELECT "id", COUNT(*) FROM "users" GROUP BY id'
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, [])
+
+    def xtest_order_by(self):
+        sql, vals = SqlBuilder.select(
+            columns="id, name", table="users", orderby="name DESC"
+        )
+        expected_sql = 'SELECT "id", "name" FROM "users" ORDER BY name DESC'
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, [])
+
+    def xtest_limit_offset(self):
+        sql, vals = SqlBuilder.select(
+            columns="id, name", table="users", start=10, qty=20
+        )
+        expected_sql = (
+            'SELECT "id", "name" FROM "users" OFFSET 10 ROWS FETCH NEXT 20 ROWS ONLY'
+        )
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, [])
+
+    def xtest_for_update(self):
+        sql, vals = SqlBuilder.select(columns="id, name", table="users", lock=True)
+        expected_sql = 'SELECT "id", "name" FROM "users" FOR UPDATE'
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, [])
+
+    def xtest_skip_locked(self):
+        sql, vals = SqlBuilder.select(
+            columns="id, name", table="users", skip_locked=True
+        )
+        expected_sql = 'SELECT "id", "name" FROM "users" FOR UPDATE SKIP LOCKED'
+        self.assertEqual(sql, expected_sql)
+        self.assertEqual(vals, [])
+
+    def xtest_invalid_table(self):
+        with self.assertRaises(Exception) as context:
+            SqlBuilder.select(columns="id, name", table=None)
+        self.assertTrue("Table name required" in str(context.exception))
+
+    def xtest_missing_foreign_key(self):
+        with self.assertRaises(exceptions.DbApplicationError) as context:
+            SqlBuilder.select(
+                columns=["profile>email"],
+                table="users",
+                tx=lambda table: None,  # Simulate missing foreign key
+            )
+        self.assertTrue("Foreign key not defined" in str(context.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()