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

velocity/db/tests/postgres/common.py

@@ -0,0 +1,49 @@
+import unittest
+from velocity.db.servers import postgres
+import env
+env.set()
+
+test_db = "test_db_postgres"
+engine = postgres.initialize(database=test_db)
+
+
+class CommonPostgresTest(unittest.TestCase):
+    """
+    Base test class for PostgreSQL tests following the common pattern.
+    All PostgreSQL tests should inherit from this class.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up the test database and create any common tables."""
+        @engine.transaction
+        def setup(tx):
+            tx.switch_to_database("postgres")
+            tx.execute(f"drop database if exists {test_db}", single=True)
+            
+            # Create the test database
+            db = tx.database(test_db)
+            if not db.exists():
+                db.create()
+            db.switch()
+
+            # Call subclass-specific table creation with commit
+            if hasattr(cls, 'create_test_tables'):
+                cls.create_test_tables(tx)
+        
+        setup()
+
+    @classmethod
+    def tearDownClass(cls):
+        """Clean up the test database."""
+        @engine.transaction
+        def cleanup(tx):
+            tx.switch_to_database("postgres")
+            tx.execute(f"drop database if exists {test_db}", single=True)
+        
+        cleanup()
+
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Override this method in subclasses to create test-specific tables."""
+        pass

velocity/db/tests/postgres/test_column.py

@@ -0,0 +1,29 @@
+import unittest
+from velocity.db.core.column import Column
+from velocity.db.exceptions import DbColumnMissingError
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestColumn(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Create test tables for column tests."""
+        tx.table("mock_table").create(
+            columns={
+                "column1": int,
+                "column2": str,
+                "column3": str,
+            }
+        )
+    
+    def test_init(self, tx):
+        column = tx.table("mock_table").column("column1")
+        self.assertIsInstance(column, Column)
+        self.assertEqual(column.name, "column1")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/postgres/test_connections.py

@@ -0,0 +1,25 @@
+import unittest
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestConnections(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Create test tables for connection tests."""
+        tx.table("mock_table").create(
+            columns={
+                "column1": int,
+                "column2": str,
+                "column3": str,
+            }
+        )
+    def test_init(self, tx):
+        # Test the initialization of the Database object
+        assert tx.table("mock_table").exists()
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/postgres/test_database.py

@@ -0,0 +1,21 @@
+import unittest
+from velocity.db.core.database import Database
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestDatabase(CommonPostgresTest):
+
+    @classmethod
+    def create_test_tables(cls, tx):
+        """No special tables needed for database tests."""
+        pass
+
+    def test_init(self, tx):
+        # Test the initialization of the Database object
+        tx.database
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/postgres/test_engine.py

@@ -0,0 +1,205 @@
+import os
+import datetime
+import unittest
+from velocity.db.core.engine import Engine
+from velocity.db.core.transaction import Transaction
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+class TestEngine(CommonPostgresTest):
+    @classmethod
+    def create_test_tables(cls, tx):
+        """No special tables needed for engine tests."""
+        pass
+
+    def test_engine_init(self, tx):
+        import psycopg2
+        from velocity.db.servers.postgres import SQL
+        
+        # Test the engine instance from common test
+        assert engine.sql == SQL
+        assert engine.driver == psycopg2
+
+    def test_engine_attributes(self, tx):
+        import psycopg2
+        from velocity.db.servers.postgres import SQL
+        
+        # Test private attributes
+        assert engine._Engine__sql == SQL
+        assert engine._Engine__driver == psycopg2
+
+    def test_connect(self, tx):
+        import psycopg2
+        
+        assert engine.connect() != None
+        conn = engine.connect()
+        self.assertIsInstance(conn, psycopg2.extensions.connection)
+
+    def test_other_stuff(self, tx):
+        assert engine.version[:10] == "PostgreSQL"
+
+        timestamp = engine.timestamp
+        self.assertIsInstance(timestamp, datetime.datetime)
+        assert engine.user == os.environ["DBUser"]
+        assert test_db in engine.databases
+        assert "public" in engine.schemas
+        assert "information_schema" in engine.schemas
+        assert "public" == engine.current_schema
+        assert engine.current_database == test_db
+        assert [] == engine.views
+        assert [] == engine.tables
+
+    def test_process_error(self, tx):
+        local_engine = Engine(None, None, None)  # Replace None with appropriate arguments
+        with self.assertRaises(
+            Exception
+        ):  # Replace Exception with the specific exception raised by process_error
+            local_engine.process_error(sql_stmt=None, sql_params=None)
+        # Add additional assertions as needed
+
+    def test_transaction_injection_1(self, tx):
+        @engine.transaction
+        def function():
+            pass
+
+        function()
+
+        @engine.transaction
+        def function(_tx):
+            pass
+
+        with self.assertRaises(NameError):
+            function()
+
+        @engine.transaction
+        def function(tx):
+            pass
+
+        with self.assertRaises(TypeError):
+            function(tx=3)
+        with self.assertRaises(TypeError):
+            function(tx=None)
+
+    def test_transaction_injection_function(self, tx):
+        with engine.transaction() as original:
+
+            @engine.transaction
+            def function(tx):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function()
+
+            @engine.transaction
+            def function(tx):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(original)
+
+            @engine.transaction
+            def function(tx=None):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function()
+
+            @engine.transaction
+            def function(tx=None):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(original)
+
+            @engine.transaction
+            def function(tx=None):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(tx=original)
+
+            @engine.transaction
+            def function(tx, a, b):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function(1, 2)
+
+            @engine.transaction
+            def function(tx, a, b):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(original, 1, 2)
+
+            @engine.transaction
+            def function(tx, a, b):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(tx=original, a=1, b=2)
+
+            @engine.transaction
+            def function(tx, src, b):
+                assert tx != None
+                assert tx != src
+                self.assertIsInstance(tx, Transaction)
+
+            function(src=original, b=2)
+
+            @engine.transaction
+            def function(a, tx, b):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function(1, 2)
+
+            @engine.transaction
+            def function(a, tx, b):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(1, original, 2)
+
+    def test_transaction_injection_class(self, tx):
+        test_class = self
+        with engine.transaction() as original:
+
+            @engine.transaction
+            class TestClass:
+                @engine.transaction
+                def __init__(self, tx):
+                    assert tx != None
+                    assert tx != original
+                    test_class.assertIsInstance(tx, Transaction)
+
+                def first_method(self, tx):
+                    assert tx != None
+                    assert tx != original
+                    test_class.assertIsInstance(tx, Transaction)
+
+                def second_method(self, tx):
+                    assert tx != None
+                    assert tx == original
+                    test_class.assertIsInstance(tx, Transaction)
+
+            tc = TestClass()
+
+            tc.first_method()
+            tc.second_method(original)
+            self.assertRaises(AssertionError, tc.second_method)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/postgres/test_general_usage.py

@@ -0,0 +1,88 @@
+import unittest
+import sys
+import os
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestFeatures(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Clean up any existing tables for general usage tests."""
+        # Ensure clean state by dropping tables if they exist
+        tx.table("names").drop()
+        tx.table("addresses").drop()
+
+    def test_foreign_key(self, tx):
+        first = tx.table("names")
+        second = tx.table("addresses")
+        first.create(
+            {
+                "first_name": str,
+                "last_name": str,
+            }
+        )
+        second.create(
+            {
+                "address": str,
+                "address2": str,
+                "city": str,
+                "state": str,
+                "zipcode": str,
+                "country": str,
+                "name_id": int,
+            }
+        )
+        tx.commit()
+        second.create_foreign_key("name_id", "names", "sys_id")
+        first.insert(
+            {
+                "first_name": "John",
+                "last_name": "Doe",
+            }
+        )
+        tx.commit()
+        second.insert(
+            {
+                "address": "123 Main St",
+                "address2": "Apt 123",
+                "city": "New York",
+                "state": "NY",
+                "zipcode": "12345",
+                "country": "USA",
+                "name_id": 1001,
+            }
+        )
+        second.insert(
+            {
+                "address": "123 Main St",
+                "address2": "Apt 123",
+                "city": "New York",
+                "state": "NY",
+                "zipcode": "12345",
+                "country": "USA",
+                "name_id": 1001,
+            }
+        )
+        second.insert(
+            {
+                "address": "123 Main St",
+                "address2": "Apt 123",
+                "city": "New York",
+                "state": "NY",
+                "zipcode": "12345",
+                "country": "USA",
+                "name_id": 1001,
+            }
+        )
+        addresses = second.select(where={"name_id": 1001})
+        # for address in addresses:
+        #     print(address)
+
+        first.drop()
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/postgres/test_imports.py

@@ -0,0 +1,8 @@
+import velocity
+import velocity.db
+import velocity.misc
+import velocity.db.servers.postgres
+
+# import velocity.db.servers.mysql
+import velocity.db.servers.sqlite
+import velocity.db.servers.sqlserver

velocity/db/tests/postgres/test_result.py

@@ -0,0 +1,19 @@
+import unittest
+from velocity.db.core.result import Result
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestResult(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """No special tables needed for result tests."""
+        pass
+    def test_result_all(self, tx):
+        result = tx.execute("SELECT current_timestamp")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/postgres/test_row.py

@@ -0,0 +1,137 @@
+import unittest
+from velocity.db.core.row import Row
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestRow(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Create test tables for row tests."""
+        # Create a test table for row operations
+        tx.table("test_users").create(
+            columns={
+                "name": str,
+                "age": int,
+                "email": str,
+            }
+        )
+    def test_init(self, tx):
+        pass
+
+    # def test_repr(self):
+    #     expected = "{'sys_id': 1, 'sys_name': 'John', 'sys_age': 30}"
+    #     self.assertEqual(repr(self.row), expected)
+
+    # def test_str(self):
+    #     expected = "{'sys_id': 1, 'sys_name': 'John', 'sys_age': 30}"
+    #     self.assertEqual(str(self.row), expected)
+
+    # def test_len(self):
+    #     self.assertEqual(len(self.row), 1)
+
+    # def test_getitem(self):
+    #     self.assertEqual(self.row['sys_name'], 'John')
+
+    # def test_setitem(self):
+    #     with self.assertRaises(Exception):
+    #         self.row['sys_id'] = 2
+
+    # def test_delitem(self):
+    #     with self.assertRaises(Exception):
+    #         del self.row['sys_id']
+
+    # def test_contains(self):
+    #     self.assertTrue('sys_name' in self.row)
+    #     self.assertFalse('sys_email' in self.row)
+
+    # def test_clear(self):
+    #     self.row.clear()
+    #     # Add assertions here to check if the row is cleared
+
+    # def test_keys(self):
+    #     expected = ['sys_id', 'sys_name', 'sys_age']
+    #     self.assertEqual(self.row.keys(), expected)
+
+    # def test_values(self):
+    #     expected = [1, 'John', 30]
+    #     self.assertEqual(self.row.values(), expected)
+
+    # def test_items(self):
+    #     expected = [('sys_id', 1), ('sys_name', 'John'), ('sys_age', 30)]
+    #     self.assertEqual(self.row.items(), expected)
+
+    # def test_get(self):
+    #     self.assertEqual(self.row.get('sys_name'), 'John')
+    #     self.assertEqual(self.row.get('sys_email'), None)
+
+    # def test_setdefault(self):
+    #     self.assertEqual(self.row.setdefault('sys_name'), 'John')
+    #     self.assertEqual(self.row.setdefault('sys_email', 'john@example.com'), 'john@example.com')
+
+    # def test_update(self):
+    #     self.row.update({'sys_name': 'Jane', 'sys_age': 25})
+    #     # Add assertions here to check if the row is updated
+
+    # def test_iterkeys(self):
+    #     expected = ['sys_id', 'sys_name', 'sys_age']
+    #     self.assertEqual(list(self.row.iterkeys()), expected)
+
+    # def test_itervalues(self):
+    #     expected = [1, 'John', 30]
+    #     self.assertEqual(list(self.row.itervalues()), expected)
+
+    # def test_iteritems(self):
+    #     expected = [('sys_id', 1), ('sys_name', 'John'), ('sys_age', 30)]
+    #     self.assertEqual(list(self.row.iteritems()), expected)
+
+    # def test_bool(self):
+    #     self.assertTrue(bool(self.row))
+
+    # def test_copy(self):
+    #     copied_row = self.row.copy()
+    #     # Add assertions here to check if the row is copied correctly
+
+    # def test_to_dict(self):
+    #     expected = {'sys_id': 1, 'sys_name': 'John', 'sys_age': 30}
+    #     self.assertEqual(self.row.to_dict(), expected)
+
+    # def test_extract(self):
+    #     expected = {'sys_id': 1, 'sys_name': 'John'}
+    #     self.assertEqual(self.row.extract('sys_id', 'sys_name'), expected)
+
+    # def test_key_cols(self):
+    #     expected = ['sys_id']
+    #     self.assertEqual(self.row.key_cols, expected)
+
+    # def test_split(self):
+    #     data, pk = self.row.split()
+    #     # Add assertions here to check if the row is split correctly
+
+    # def test_data(self):
+    #     data = self.row.data
+    #     # Add assertions here to check if the data is extracted correctly
+
+    # def test_row(self):
+    #     row = self.row.row('sys_id')
+    #     # Add assertions here to check if the row is fetched correctly
+
+    # def test_match(self):
+    #     other = {'sys_id': 1, 'sys_name': 'John', 'sys_age': 30}
+    #     self.assertTrue(self.row.match(other))
+    #     other = {'sys_id': 2, 'sys_name': 'Jane', 'sys_age': 25}
+    #     self.assertFalse(self.row.match(other))
+
+    # def test_touch(self):
+    #     self.row.touch()
+    #     # Add assertions here to check if the row is touched correctly
+
+    # def test_delete(self):
+    #     self.row.delete()
+    #     # Add assertions here to check if the row is deleted correctly
+
+
+if __name__ == "__main__":
+    unittest.main()