Further test suite improvements.

Author: anthony-tuininga

tests/test_1900_lob_var.py

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2020, 2022, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2023, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -182,7 +182,10 @@ def __test_lob_operations(self, lob_type):
         self.assertEqual(lob.size(), 10000)
         self.assertRaisesRegex(oracledb.DatabaseError, "^DPY-2014:",
                                lob.trim, new_size=50, newSize=60)
+        self.assertRaises(TypeError, lob.trim, new_size="10000")
         self.assertRaises(TypeError, lob.trim, newSize="10000")
+        lob.trim(new_size=40)
+        self.assertEqual(lob.size(), 40)
         lob.trim()
         self.assertEqual(lob.size(), 0)
         self.assertIsInstance(lob.getchunksize(), int)

tests/test_2400_pool.py

@@ -91,13 +91,15 @@ def __perform_reconfigure_test(self, parameter_name, parameter_value,
                                    wait_timeout=5000, stmtcachesize=25,
                                    max_lifetime_session=1000,
                                    max_sessions_per_shard=3, ping_interval=30,
-                                   getmode=oracledb.POOL_GETMODE_WAIT):
+                                   getmode=oracledb.POOL_GETMODE_WAIT,
+                                   soda_metadata_cache=False):
         creation_args = dict(min=min, max=max, increment=increment,
                              timeout=timeout, wait_timeout=wait_timeout,
                              stmtcachesize=stmtcachesize,
                              max_lifetime_session=max_lifetime_session,
                              max_sessions_per_shard=max_sessions_per_shard,
-                             ping_interval=ping_interval, getmode=getmode)
+                             ping_interval=ping_interval, getmode=getmode,
+                             soda_metadata_cache=soda_metadata_cache)
         reconfigure_args = {}
         reconfigure_args[parameter_name] = parameter_value
 
@@ -111,7 +113,8 @@ def __perform_reconfigure_test(self, parameter_name, parameter_value,
                            max_lifetime_session=pool.max_lifetime_session,
                            max_sessions_per_shard=pool.max_sessions_per_shard,
                            ping_interval=pool.ping_interval,
-                           getmode=pool.getmode)
+                           getmode=pool.getmode,
+                           soda_metadata_cache=pool.soda_metadata_cache)
         expected_args = creation_args.copy()
         expected_args.update(reconfigure_args)
         self.assertEqual(actual_args, expected_args)
@@ -487,6 +490,8 @@ def test_2416_test_reconfigure_pool_with_missing_values(self):
         self.__perform_reconfigure_test("ping_interval", 50)
         self.__perform_reconfigure_test("getmode",
                                         oracledb.POOL_GETMODE_NOWAIT)
+        if test_env.get_client_version() >= (19, 11):
+            self.__perform_reconfigure_test("soda_metadata_cache", True)
 
     @unittest.skipIf(test_env.get_is_thin(),
                      "thin mode doesn't support all the pool params yet")
@@ -783,5 +788,24 @@ def test_2435_acquire_with_different_cclass(self):
                 self.assertEqual(next_sid_serial, sid_serial)
         self.assertEqual(pool.opened, 1)
 
+    def test_2436_pool_params_negative(self):
+        "2436 - test creating a pool invalid params"
+        self.assertRaisesRegex(oracledb.ProgrammingError, "^DPY-2027:",
+                               oracledb.create_pool, params="bad params")
+
+    def test_2437_conn_release_and_drop_negative(self):
+        "2437 - test releasing and dropping an invalid connection"
+        pool = test_env.get_pool()
+        self.assertRaises(TypeError, pool.release, ["invalid connection"])
+        self.assertRaises(TypeError, pool.drop, ["invalid connection"])
+
+    @unittest.skipIf(test_env.get_is_thin(),
+                     "thin mode doesn't set a pool name")
+    def test_2438_name(self):
+        "2438 - test getting pool name"
+        pool = test_env.get_pool()
+        expected_name = "^OCI:SP:.+"
+        self.assertRegex(pool.name, expected_name)
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_2700_aq.py

@@ -404,6 +404,9 @@ def test_2715_enqueue_transformation(self):
         queue.enqoptions.transformation = \
         transformation_str = "%s.transform1" % self.connection.username
         queue.enqoptions.transformation = transformation_str
+        if test_env.get_client_version() >= (23, 1):
+            self.assertEqual(queue.enqoptions.transformation,
+                             transformation_str)
         props = self.connection.msgproperties(payload=book)
         queue.enqone(props)
         self.connection.commit()
@@ -560,5 +563,21 @@ def test_2726_set_payload_bytes(self):
         props.payload = bytes_val
         self.assertEqual(props.payload, bytes_val)
 
+    def test_2727_queue_attributes(self):
+        "2727 - test getting queue attributes"
+        queue = self.get_and_clear_queue(self.book_queue_name,
+                                         self.book_type_name)
+        self.assertEqual(queue.name, self.book_queue_name)
+        self.assertEqual(queue.connection, self.connection)
+
+    def test_2728_get_write_only_attributes(self):
+        "2728 - test getting write-only attributes"
+        queue = self.get_and_clear_queue(self.book_queue_name,
+                                         self.book_type_name)
+        with self.assertRaises(AttributeError):
+            queue.enqoptions.deliverymode
+        with self.assertRaises(AttributeError):
+            queue.deqoptions.deliverymode
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_3000_subscription.py

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2020, 2022, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2023, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -206,5 +206,29 @@ def test_3002_aq_subscription(self):
         # wait for all messages to be sent
         data.wait_for_messages()
 
+    @unittest.skip("FIXME: threaded mode fails on close of connection?")
+    def test_3003_registerquery_returns(self):
+        "3003 - test verifying what registerquery returns"
+        data = DMLSubscriptionData(5)
+        qos_constants = [
+                oracledb.SUBSCR_QOS_QUERY,
+                oracledb.SUBSCR_QOS_RELIABLE,
+                oracledb.SUBSCR_QOS_DEREG_NFY,
+                oracledb.SUBSCR_QOS_ROWIDS,
+                oracledb.SUBSCR_QOS_BEST_EFFORT
+        ]
+        for qos_constant in qos_constants:
+            connection = test_env.get_connection(events=True)
+            sub = connection.subscribe(qos=qos_constant,
+                                       callback=data.callback_handler)
+            query_id = sub.registerquery("select * from TestTempTable")
+            if qos_constant == oracledb.SUBSCR_QOS_QUERY:
+                self.assertEqual(type(query_id), int)
+                self.assertEqual(type(sub.id), int)
+            else:
+                self.assertEqual(query_id, None)
+            connection.unsubscribe(sub)
+            connection.close()
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_3400_soda_collection.py

@@ -565,5 +565,51 @@ def test_3427_negative(self):
         self.assertRaises(TypeError, coll.find().version, 1971)
         self.assertRaises(TypeError, coll.find().limit, "a word")
 
+    def test_3428_fetch_array_size(self):
+        "3428 - test fetchArraySize"
+        soda_db = self.get_soda_database(minclient=(19, 5))
+        coll = soda_db.createCollection("TestSodaFetchArraySize")
+        coll.find().remove()
+        for i in range(90):
+            coll.save({'name': 'Emmanuel', 'age': i + 1})
+        self.connection.commit()
+
+        self.setup_round_trip_checker()
+        # setting array size to 0 will use the default value of 100
+        # requires a single round-trip
+        docs = coll.find().fetchArraySize(0).getDocuments()
+        self.assertRoundTrips(1)
+
+        # setting array size to 1 requires a round-trip for each SodaDoc
+        coll.find().fetchArraySize(1).getDocuments()
+        self.assertRoundTrips(91)
+
+        # setting array size to 20 requires 5 round-trips
+        coll.find().fetchArraySize(20).getDocuments()
+        self.assertRoundTrips(5)
+
+        # getting a SodaDocCursor requires a round-trip
+        coll.find().fetchArraySize(0).getCursor()
+        self.assertRoundTrips(1)
+
+        # setting array size to 1 and iterating the SodaDocCursor requires a
+        # round-trip for each SodaDoc
+        soda_doc_cursor = coll.find().fetchArraySize(1).getCursor()
+        for soda_doc in soda_doc_cursor:
+            continue
+        self.assertRoundTrips(91)
+
+        # setting array size to 50 and iterating the SodaDocCursor requires
+        # two round-trips
+        soda_doc_cursor = coll.find().fetchArraySize(50).getCursor()
+        for soda_doc in soda_doc_cursor:
+            continue
+        self.assertRoundTrips(2)
+
+        # check a few negative scenarios
+        self.assertRaises(TypeError, coll.find().fetchArraySize, "Mijares")
+        self.assertRaises(TypeError, coll.find().fetchArraySize, -1)
+        coll.drop()
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_4400_tpc.py

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2021, 2022, Oracle and/or its affiliates.
+# Copyright (c) 2021, 2023, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -116,5 +116,109 @@ def test_4403_rollback_with_xid(self):
                 order by IntCol""")
         self.assertEqual(self.cursor.fetchall(), [(1, 'tesName')])
 
+    def test_4404_tpc_begin_resume(self):
+        "4404 - test resuming a transaction"
+        self.cursor.execute("truncate table TestTempTable")
+        xid1 = self.connection.xid(3939, "txn3939", "branch39")
+        xid2 = self.connection.xid(3940, "txn3940", "branch40")
+        values = [
+            [xid1, (1, "User Info")],
+            [xid2, (2, "Other User Info")]
+        ]
+        for xid, data in values:
+            self.connection.tpc_begin(xid)
+            self.cursor.execute("""
+                    insert into TestTempTable (IntCol, StringCol1)
+                    values (:1, :2)""", data)
+            self.connection.tpc_end()
+        for xid, _ in values:
+            self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-24757:",
+                                   self.connection.tpc_begin, xid)
+        for xid, data in values:
+            self.connection.tpc_begin(xid, oracledb.TPC_BEGIN_RESUME)
+            self.cursor.execute(
+                    "select IntCol, StringCol1 from TestTempTable")
+            res, = self.cursor.fetchall()
+            self.assertEqual(res, data)
+            self.connection.tpc_rollback(xid)
+
+    def test_4405_tpc_begin_promote(self):
+        "4405 - test promoting a local transaction to a tpc transaction"
+        self.cursor.execute("truncate table TestTempTable")
+        xid = self.connection.xid(3941, "txn3941", "branch41")
+        values = (1, "String 1")
+        self.cursor.execute(
+                """insert into TestTempTable (IntCol, StringCol1)
+                   values (:1, :2)""", values)
+        self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-24776",
+                               self.connection.tpc_begin, xid)
+        self.connection.tpc_begin(xid, oracledb.TPC_BEGIN_PROMOTE)
+        self.cursor.execute("select IntCol, StringCol1 from TestTempTable")
+        res, = self.cursor.fetchall()
+        self.assertEqual(res, values)
+        self.connection.tpc_rollback(xid)
+
+    def test_4406_tpc_end_with_xid(self):
+        "4406 - test ending a transaction with parameter xid"
+        self.cursor.execute("truncate table TestTempTable")
+        xid1 = self.connection.xid(4406, "txn4406a", "branch3")
+        xid2 = self.connection.xid(4406, "txn4406b", "branch4")
+        self.connection.tpc_begin(xid1)
+        self.cursor.execute("""
+                insert into TestTempTable (IntCol, StringCol1)
+                values (1, 'test4406a')""")
+        self.connection.tpc_begin(xid2)
+        self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-24758:",
+                               self.connection.tpc_end, xid1)
+        self.cursor.execute("""
+                insert into TestTempTable (IntCol, StringCol1)
+                values (2, 'test4406b')""")
+        self.connection.tpc_end(xid2)
+        self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-25352:",
+                               self.connection.tpc_end, xid1)
+        self.connection.tpc_rollback(xid1)
+        self.connection.tpc_rollback(xid2)
+
+    def test_4407_tpc_recover(self):
+        "4407 - test tpc_recover()"
+        self.cursor.execute("truncate table TestTempTable")
+        n_xids = 10
+        for i in range(n_xids):
+            xid = self.connection.xid(4407 + i, f"txn4407{i}", f"branch{i}")
+            self.connection.tpc_begin(xid)
+            self.cursor.execute("""
+                    insert into TestTempTable (IntCol, StringCol1)
+                    values (:1, 'test4407')""", [i + 1])
+            self.connection.tpc_prepare(xid)
+        recovers = self.connection.tpc_recover()
+        self.assertEqual(len(recovers), n_xids)
+
+        self.cursor.execute("select * from DBA_PENDING_TRANSACTIONS")
+        self.assertEqual(self.cursor.fetchall(), recovers)
+
+        for format_id, txn, branch in recovers:
+            if format_id % 2 == 0:
+                xid = self.connection.xid(format_id, txn, branch)
+                self.connection.tpc_commit(xid)
+        recovers = self.connection.tpc_recover()
+        self.assertEqual(len(recovers), n_xids // 2)
+
+        for format_id, txn, branch in recovers:
+            xid = self.connection.xid(format_id, txn, branch)
+            self.connection.tpc_rollback(xid)
+        recovers = self.connection.tpc_recover()
+        self.assertEqual(len(recovers), 0)
+
+    def test_4408_tpc_recover_read_only(self):
+        "4408 - test tpc_recover() with read-only transaction"
+        self.cursor.execute("truncate table TestTempTable")
+        for i in range(4):
+            xid = self.connection.xid(4408 + i, f"txn4408{i}", f"branch{i}")
+            self.connection.tpc_begin(xid)
+            self.cursor.execute("select * from TestTempTable")
+            self.connection.tpc_prepare(xid)
+        recovers = self.connection.tpc_recover()
+        self.assertEqual(len(recovers), 0)
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_4500_connect_params.py

@@ -645,5 +645,19 @@ def test_4562_connection_id_prefix(self):
         params.parse_connect_string("my_host4562b/my_service_name_4562b")
         self.assertEqual(params.connection_id_prefix, "prefix4562b")
 
+    def test_4563_override_parameters(self):
+        "4563 - test overriding parameters with parse_connection_string"
+        params = oracledb.ConnectParams()
+        params.parse_connect_string("my_host:3578/my_service_name")
+        params.set(service_name="new_service_name", port=613)
+        self.assertEqual(params.service_name, "my_service_name")
+        self.assertEqual(params.port, 3578)
+
+        params = oracledb.ConnectParams()
+        params.set(service_name="my_service_name", port=613)
+        params.parse_connect_string("my_host:3578/new_service_name")
+        self.assertEqual(params.service_name, "new_service_name")
+        self.assertEqual(params.port, 3578)
+
 if __name__ == "__main__":
     test_env.run_test_cases()