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

velocity/db/tests/postgres/test_transaction.py

@@ -0,0 +1,106 @@
+import re
+import unittest
+import sys
+import os
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestTransaction(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """No special tables needed for transaction tests."""
+        pass
+
+    def test_init(self, tx):
+        t = tx.table("test_table")
+        assert t.exists() == False
+        assert tx.tables() == []
+        assert (
+            str(t)
+            == """Table: test_table
+(table exists) False
+Columns: 0
+Rows: 0
+"""
+        )
+        self.assertTrue(re.match(r"PostGreSQL\.transaction\(.*:test_db_postgres\)", str(tx)))
+
+    def test_rollback(self, tx):
+        t = tx.table("test_table")
+        for i in range(10):
+
+            temp = t.insert(
+                {
+                    "fname": "test",
+                    "lname": "test",
+                    "email": "test@test.com",
+                    "age": 1,
+                    "address": "test",
+                    "city": "test",
+                    "state": "test",
+                    "zipcode": "test",
+                    "country": "test",
+                }
+            )
+
+        assert (
+            str(t)
+            == """Table: test_table
+(table exists) True
+Columns: 10
+Rows: 10
+"""
+        )
+        tx.rollback()
+        assert (
+            str(t)
+            == """Table: test_table
+(table exists) False
+Columns: 0
+Rows: 0
+"""
+        )
+        tx.table("test_table").drop()
+        print("End of test_rollback")
+
+    def test_drop(self, tx):
+        t = tx.table("test_table")
+        t.drop()
+        for i in range(10):
+            t.insert(
+                {
+                    "fname": "test",
+                    "lname": "test",
+                    "email": "test@test.com",
+                    "age": 1,
+                    "address": "test",
+                    "city": "test",
+                    "state": "test",
+                    "zipcode": "test",
+                    "country": "test",
+                }
+            )
+        assert (
+            str(t)
+            == """Table: test_table
+(table exists) True
+Columns: 10
+Rows: 10
+"""
+        )
+        tx.table("test_table").drop()
+        assert (
+            str(t)
+            == """Table: test_table
+(table exists) False
+Columns: 0
+Rows: 0
+"""
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/tests/sql/__init__.py

@@ -0,0 +1 @@
+# SQL tests

velocity/db/tests/sql/common.py

@@ -0,0 +1,177 @@
+import unittest
+from velocity.db.servers import postgres
+import random
+
+test_db = "test_foreign_key_db"
+engine = postgres.initialize(
+    database=test_db,
+)
+print(engine)
+
+
+@engine.transaction  # Decorator to run the test in a transaction
+class TestSQLModule(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls, tx):
+        tx.switch_to_database("postgres")
+        tx.execute(f"drop database if exists {test_db}", single=True)
+        # Drop and recreate the test database to ensure a clean environment
+        db = tx.database(test_db)
+        if db.exists():
+            # Possibly drop if needed, or just recreate if the environment ensures cleanliness
+            pass
+        else:
+            db.create()
+        db.switch()
+
+        cls.create_tables(tx)
+        cls.insert_data(tx)
+
+    @classmethod
+    def create_tables(cls, tx):
+        # Table with normal columns
+        tx.table("normal_table").create(
+            columns={
+                "name": str,
+                "active": bool,
+                "value": float,
+            }
+        )
+
+        # Table with "aggregate-like" column names
+        # and a reserved keyword as a column name (e.g. "order")
+        tx.table("weird_names_table").create(
+            columns={
+                "Sum_info": str,  # Looks like SUM but isn't
+                "MAX_hours": int,  # Starts with MAX but not necessarily aggregate
+                "order": str,  # reserved keyword in SQL, test quoting
+            }
+        )
+
+        # Parent and child tables to test foreign keys and multiple pointers
+        tx.table("fk_parent").create(
+            columns={
+                "parent_name": str,
+                "num_things": int,
+                "is_valid": bool,
+            }
+        )
+        tx.table("fk_middle").create(
+            columns={
+                "parent_id": int,
+                "title": str,
+            }
+        )
+        tx.table("fk_middle").create_foreign_key("parent_id", "fk_parent", "sys_id")
+
+        tx.table("fk_child").create(
+            columns={"parent_id": int, "middle_id": int, "description": str}
+        )
+        tx.table("fk_child").create_foreign_key("parent_id", "fk_parent", "sys_id")
+        tx.table("fk_child").create_foreign_key("middle_id", "fk_middle", "sys_id")
+
+        # Another table for testing multiple foreign references to the same table
+        tx.table("fk_self_ref").create(
+            columns={
+                "ref_id": int,
+                "info": str,
+            }
+        )
+        # A self referencing foreign key (if supported by environment)
+        tx.table("fk_self_ref").create_foreign_key("ref_id", "fk_self_ref", "sys_id")
+
+        # Table to test special operators and placeholders
+        tx.table("special_values_table").create(
+            columns={
+                "name": str,
+                "status": str,
+                "score": float,
+            }
+        )
+
+    @classmethod
+    def insert_data(cls, tx):
+        normal_table = tx.table("normal_table")
+        normal_table.upsert(
+            {"sys_id": 1, "name": "Alpha", "active": True, "value": 10.5}
+        )
+        normal_table.upsert(
+            {"sys_id": 2, "name": "Beta", "active": False, "value": None}
+        )
+
+        weird = tx.table("weird_names_table")
+        weird.upsert(
+            {
+                "sys_id": 10,
+                "Sum_info": "Not an Aggregate",
+                "MAX_hours": 40,
+                "order": "first",
+            }
+        )
+        weird.upsert(
+            {"sys_id": 20, "Sum_info": "Also Not", "MAX_hours": 50, "order": "second"}
+        )
+
+        parent = tx.table("fk_parent")
+        parent.upsert({"sys_id": 100, "parent_name": "P1"})
+        parent.upsert({"sys_id": 200, "parent_name": "P2"})
+
+        middle = tx.table("fk_middle")
+        middle.upsert({"sys_id": 300, "parent_id": 100, "title": "M1"})
+        middle.upsert({"sys_id": 400, "parent_id": 200, "title": "M2"})
+
+        child = tx.table("fk_child")
+        child.upsert(
+            {"sys_id": 500, "parent_id": 100, "middle_id": 300, "description": "C1"}
+        )
+        child.upsert(
+            {"sys_id": 600, "parent_id": 200, "middle_id": 400, "description": "C2"}
+        )
+
+        self_ref = tx.table("fk_self_ref")
+        self_ref.upsert({"sys_id": 700, "ref_id": None, "info": "root"})
+        self_ref.upsert({"sys_id": 800, "ref_id": 700, "info": "child_of_700"})
+        self_ref.upsert({"sys_id": 900, "ref_id": 800, "info": "child_of_800"})
+
+        special = tx.table("special_values_table")
+        special.upsert(
+            {
+                "sys_id": 1000,
+                "name": "Infinite Score",
+                "status": "open",
+                "score": 9999.99,
+            }
+        )
+        special.upsert(
+            {"sys_id": 1100, "name": "Unknown Value", "status": None, "score": None}
+        )
+        special.upsert(
+            {"sys_id": 1200, "name": "Regular Entry", "status": "closed", "score": 100}
+        )
+
+        emails = [
+            "test.user1@example.com",
+            "demo.account@domain.com", 
+            "sample.email@test.com",
+            "mock.data@company.com",
+            "placeholder@example.com",
+            "testcase@domain.com",
+            "fakeuser@test.com",
+            "demodata@company.com",
+        ]
+        for i in range(10):
+            special.upsert(
+                {
+                    "sys_id": 1300 + i,
+                    "name": f"Entry {i}",
+                    "status": "open",
+                    "score": i * 10,
+                    "email": random.choice(emails),
+                }
+            )
+
+    # @classmethod
+    # def tearDownClass(cls, tx):
+    #     tx.switch_to_database("postgres")
+    #     tx.execute(f"drop database if exists {test_db}", single=True)

velocity/db/tests/sql/test_postgres_select_advanced.py

@@ -0,0 +1,285 @@
+import unittest
+import velocity.db.exceptions
+from common import TestSQLModule, engine
+import time
+
+DO_ALL = True
+
+print(f"DO_ALL: {DO_ALL}")
+
+
+@engine.transaction
+class TestLocal(TestSQLModule):
+
+    def test_select_self_refer_wildcard(self, tx):
+        if not DO_ALL:
+            return
+
+        sql, vars = tx.table("fk_child").select(
+            sql_only=True, columns=["A.*", "parent_id>parent_name"]
+        )
+        expected_sql = """
+        SELECT A.*,
+        B.parent_name AS parent_id_parent_name
+        FROM fk_child AS A
+        LEFT JOIN fk_parent AS B ON A.parent_id = B.sys_id
+        """
+        expected_vars = ()
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+
+        # for row in tx.table("fk_child").select(
+        #     columns=["A.*", "parent_id>parent_name"]
+        # ):
+        #     print(row)
+
+        sql, vars = tx.table("fk_self_ref").select(
+            sql_only=True, columns=["A.*", "ref_id>info"]
+        )
+        expected_sql = """
+        SELECT A.*,
+        B.info AS ref_id_info
+        FROM fk_self_ref AS A
+        LEFT JOIN fk_self_ref AS B ON A.ref_id = B.sys_id
+        """
+        expected_vars = ()
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+        # for row in tx.table("fk_self_ref").select(columns=["A.*", "ref_id>info"]):
+        #     print(row)
+
+        sql, vars = tx.table("fk_self_ref").select(
+            sql_only=True, columns=["A.*", "ref_id>info", "ref_id>ref_id"]
+        )
+        expected_sql = """
+        SELECT A.*,
+        B.info AS ref_id_info,
+        B.ref_id AS ref_id_ref_id
+        FROM fk_self_ref AS A
+        LEFT JOIN fk_self_ref AS B ON A.ref_id = B.sys_id
+        """
+        expected_vars = ()
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+        # for row in tx.table("fk_self_ref").select(
+        #     columns=["A.*", "ref_id>info", "ref_id>ref_id"]
+        # ):
+        #     print(row)
+
+    def test_complex_update(self, tx):
+        if not DO_ALL:
+            return
+        sql, vars = tx.table("fk_child").update(
+            sql_only=True,
+            data={
+                "name": "@parent_id>parent_name",
+                "value": "@parent_id>num_things",
+                "active": "@parent_id>is_valid",
+            },
+            where={
+                ">parent_id>num_things": "10",
+                "<num_things": "10",
+            },
+        )
+
+        expected_sql = """
+        UPDATE fk_child AS A
+        SET name = %s,
+            "value" = %s,
+            active = %s
+        LEFT JOIN fk_parent AS B
+        WHERE B.num_things > %s
+        AND num_things < %s
+        AND A.parent_id = B.sys_id
+        """
+        expected_vars = (
+            "@parent_id>parent_name",
+            "@parent_id>num_things",
+            "@parent_id>is_valid",
+            "10",
+            "10",
+        )
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+
+        sql, vars = tx.table("fk_child").update(
+            sql_only=True,
+            data={
+                "a": "a",
+                "b": "a",
+                "c": "a",
+                "d": "a",
+                "e": "a",
+            },
+            where={
+                "sys_id": "700",
+            },
+        )
+
+        expected_sql = """
+        UPDATE fk_child
+        SET a = %s,
+            b = %s,
+            c = %s,
+            d = %s,
+            e = %s
+        WHERE sys_id = %s
+        """
+        expected_vars = ("a", "a", "a", "a", "a", "700")
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+
+    def test_complex_merge(self, tx):
+        if not DO_ALL:
+            return
+        for i in range(10):
+            tx.table("fk_you").insert(
+                data={
+                    "sys_id": i + 1000,
+                    "parent_id": 1,
+                    "name": f"Child {i}",
+                    "value": i,
+                    "active": True,
+                },
+            )
+            self.assertRaises(
+                velocity.db.exceptions.DbDuplicateKeyError,
+                tx.table("fk_you").insert,
+                data={
+                    "sys_id": i + 1000,
+                    "parent_id": 2,
+                    "name": f"Child {i}-2",
+                    "value": i,
+                    "active": False,
+                },
+            )
+        for i in range(10):
+            tx.table("fk_you").insert(
+                data={
+                    "parent_id": 3,
+                    "name": f"Child {i}-3",
+                    "value": i,
+                    "active": True,
+                },
+            )
+
+        for i in range(10):
+            tx.table("fk_you").merge(
+                data={
+                    "sys_id": i + 1000,
+                    "parent_id": 4,
+                    "name": f"Child {i}4",
+                    "value": i,
+                    "active": False,
+                },
+            )
+        for i in range(10):
+            tx.table("fk_you").merge(
+                data={
+                    "sys_id": i + 1100,
+                    "parent_id": 4,
+                    "name": f"Child {i}4",
+                    "value": i,
+                    "active": False,
+                },
+            )
+        tx.commit()
+
+    def test_duplicate_rows(self, tx):
+        sql, vars = tx.table("special_values_table").duplicate_rows(
+            sql_only=True,
+            columns=["email", "status"],
+        )
+        expected_sql = """
+         SELECT t.*
+        FROM special_values_table t
+        JOIN (SELECT email,
+        status
+        FROM special_values_table
+        GROUP BY email,
+                status
+        HAVING count(*) > %s) dup
+        ON t.email = dup.email AND t.status = dup.status
+        ORDER BY email, status
+        """
+        expected_vars = (1,)
+
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+
+        # for row in tx.table("special_values_table").duplicate_rows(
+        #     columns=["email", "status"],
+        # ):
+        #     print(row)
+
+        sql, vars = tx.table("special_values_table").has_duplicates(
+            sql_only=True,
+            columns=["email", "status"],
+        )
+        expected_sql = """
+        SELECT 1
+        FROM special_values_table
+        GROUP BY email,
+                status
+        HAVING count(*) > %s FETCH NEXT 1 ROWS ONLY
+        """
+        expected_vars = (1,)
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+
+        self.assertEqual(
+            tx.table("special_values_table").has_duplicates(
+                columns=["email", "status"],
+            ),
+            True,
+        )
+
+        expected_sql = """
+        SELECT 1
+        FROM special_values_table
+        GROUP BY email,
+                status
+        HAVING count(*) > %s FETCH NEXT 1 ROWS ONLY
+        """
+        expected_vars = (1,)
+
+        self.assertEqual(
+            sql.split(),
+            expected_sql.split(),
+        )
+        self.assertEqual(vars, expected_vars)
+        self.assertEqual(
+            tx.table("special_values_table").has_duplicates(
+                columns=["sys_id", "status"],
+            ),
+            False,
+        )
+        for row in tx.table("special_values_table").duplicate_rows(
+            columns=["sys_id", "status"],
+        ):
+            print(row)
+
+
+if __name__ == "__main__":
+    unittest.main()