Various test improvements.

Author: anthony-tuininga

tests/sql/create_schema.sql

@@ -56,7 +56,8 @@ grant
     create view,
     select any dictionary,
     change notification,
-    unlimited tablespace
+    unlimited tablespace,
+    ctxapp
 to &main_user
 /
 

tests/test_1000_module.py

@@ -27,6 +27,7 @@
 """
 
 import datetime
+import unittest
 
 import oracledb
 import test_env
@@ -187,6 +188,12 @@ def test_1006(self):
         )
         self.assertIs(oracledb.version, oracledb.__version__)
 
+    @unittest.skipUnless(test_env.get_is_thin(), "not relevant for thick mode")
+    def test_1007(self):
+        "1007 - test clientversion() fails without init_oracle_client()"
+        with self.assertRaisesRegex(oracledb.ProgrammingError, "^DPY-2021:"):
+            oracledb.clientversion()
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_2300_object_var.py

@@ -430,25 +430,17 @@ def test_2307(self):
     def test_2308(self):
         "2308 - test trying to find an object type that does not exist"
         self.assertRaises(TypeError, self.conn.gettype, 2)
-        self.assertRaisesRegex(
-            oracledb.DatabaseError,
-            "^DPY-2035:",
-            self.conn.gettype,
-            "A TYPE THAT DOES NOT EXIST",
-        )
+        with self.assertRaisesRegex(oracledb.DatabaseError, "^DPY-2035:"):
+            self.conn.gettype("A TYPE THAT DOES NOT EXIST")
 
     def test_2309(self):
         "2309 - test appending an object of the wrong type to a collection"
         collection_obj_type = self.conn.gettype("UDT_OBJECTARRAY")
         collection_obj = collection_obj_type.newobject()
         array_obj_type = self.conn.gettype("UDT_ARRAY")
         array_obj = array_obj_type.newobject()
-        self.assertRaisesRegex(
-            oracledb.DatabaseError,
-            "^DPY-2008:",
-            collection_obj.append,
-            array_obj,
-        )
+        with self.assertRaisesRegex(oracledb.DatabaseError, "^DPY-2008:"):
+            collection_obj.append(array_obj)
 
     def test_2310(self):
         "2310 - test that referencing a sub object affects the parent object"
@@ -487,14 +479,8 @@ def test_2312(self):
         obj = obj_type.newobject()
         wrong_obj_type = self.conn.gettype("UDT_OBJECTARRAY")
         wrong_obj = wrong_obj_type.newobject()
-        self.assertRaisesRegex(
-            oracledb.DatabaseError,
-            "^DPY-2008:",
-            setattr,
-            obj,
-            "SUBOBJECTVALUE",
-            wrong_obj,
-        )
+        with self.assertRaisesRegex(oracledb.DatabaseError, "^DPY-2008:"):
+            setattr(obj, "SUBOBJECTVALUE", wrong_obj)
 
     def test_2313(self):
         "2313 - test setting value of object variable to wrong object type"
@@ -569,12 +555,8 @@ def test_2317(self):
 
     def test_2318(self):
         "2318 - test creating an object variable without a type name"
-        self.assertRaisesRegex(
-            oracledb.DatabaseError,
-            "^DPY-2037:",
-            self.cursor.var,
-            oracledb.DB_TYPE_OBJECT,
-        )
+        with self.assertRaisesRegex(oracledb.DatabaseError, "^DPY-2037:"):
+            self.cursor.var(oracledb.DB_TYPE_OBJECT)
 
     def test_2319(self):
         "2319 - test getting an empty collection as a dictionary"
@@ -711,21 +693,20 @@ def test_2330(self):
         expected_str = f"^<oracledb.DbObject {fqn} at 0x.+>$"
         self.assertRegex(repr(obj), expected_str)
 
+        # object of a package
+        typ = self.conn.gettype("PKG_TESTSTRINGARRAYS.UDT_STRINGLIST")
+        obj = typ.newobject()
+        fqn = f"{typ.schema}.{typ.package_name}.{typ.name}"
+        expected_str = f"^<oracledb.DbObject {fqn} at 0x.+>$"
+        self.assertRegex(repr(obj), expected_str)
+
     def test_2331(self):
         "2331 - test creating an object with invalid data type"
         type_obj = self.conn.gettype("UDT_ARRAY")
-        self.assertRaisesRegex(
-            oracledb.NotSupportedError,
-            "^DPY-3013:",
-            type_obj.newobject,
-            [490, "not a number"],
-        )
-        self.assertRaisesRegex(
-            oracledb.NotSupportedError,
-            "^DPY-3013:",
-            type_obj,
-            [71, "not a number"],
-        )
+        with self.assertRaisesRegex(oracledb.NotSupportedError, "^DPY-3013:"):
+            type_obj.newobject([490, "not a number"])
+        with self.assertRaisesRegex(oracledb.NotSupportedError, "^DPY-3013:"):
+            type_obj([71, "not a number"])
 
     def test_2332(self):
         "2332 - test getting an invalid attribute name from an object"
@@ -749,14 +730,10 @@ def test_2333(self):
                 value = "A" * max_size
                 setattr(obj, attr_name, value)
                 value += "X"
-                self.assertRaisesRegex(
-                    oracledb.ProgrammingError,
-                    "^DPY-2043:",
-                    setattr,
-                    obj,
-                    attr_name,
-                    value,
-                )
+                with self.assertRaisesRegex(
+                    oracledb.ProgrammingError, "^DPY-2043:"
+                ):
+                    setattr(obj, attr_name, value)
 
     def test_2334(self):
         "2334 - test validating a string element value"
@@ -767,20 +744,23 @@ def test_2334(self):
             oracledb.ProgrammingError, "^DPY-2044:", obj.append, "A" * 101
         )
         obj.append("B" * 100)
-        self.assertRaisesRegex(
-            oracledb.ProgrammingError,
-            "^DPY-2044:",
-            obj.setelement,
-            2,
-            "C" * 101,
-        )
+        with self.assertRaisesRegex(oracledb.ProgrammingError, "^DPY-2044:"):
+            obj.setelement(2, "C" * 101)
 
     def test_2335(self):
         "2335 - test validating a string attribute with null value"
         typ = self.conn.gettype("UDT_OBJECT")
         obj = typ.newobject()
         obj.STRINGVALUE = None
 
+    def test_2336(self):
+        "2336 - test initializing (with a sequence) a non collection obj"
+        obj_type = self.conn.gettype("UDT_OBJECT")
+        with self.assertRaisesRegex(oracledb.ProgrammingError, "^DPY-2036:"):
+            obj_type.newobject([1, 2])
+        with self.assertRaisesRegex(oracledb.ProgrammingError, "^DPY-2036:"):
+            obj_type([3, 4])
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_2400_pool.py

@@ -879,6 +879,15 @@ class MyConnection(oracledb.Connection):
         with pool.acquire() as conn:
             self.assertIsInstance(conn, MyConnection)
 
+    def test_2436(self):
+        "2436 - test creating a pool with a subclassed pool type"
+
+        class MyPool(oracledb.ConnectionPool):
+            pass
+
+        pool = test_env.get_pool(pool_class=MyPool)
+        self.assertIsInstance(pool, MyPool)
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_2700_aq.py

@@ -394,7 +394,7 @@ def test_2714(self):
         queue.deqoptions.visibility = oracledb.DEQ_IMMEDIATE
         transformation_str = f"{self.conn.username}.transform2"
         queue.deqoptions.transformation = transformation_str
-        self.assertEqual(queue.deqOptions.transformation, transformation_str)
+        self.assertEqual(queue.deqoptions.transformation, transformation_str)
         queue.deqoptions.wait = oracledb.DEQ_NO_WAIT
         props = queue.deqone()
         self.assertEqual(props.payload.PRICE, expected_price)
@@ -722,6 +722,20 @@ def test_2733(self):
         queue = self.conn.queue("TEST_RAW_QUEUE")
         self.assertIsNone(queue.payload_type)
 
+    def test_2734(self):
+        "2734 - test deprecated attributes (enqOptions, deqOptions)"
+        queue = self.get_and_clear_queue("TEST_RAW_QUEUE")
+        self.assertEqual(queue.enqOptions, queue.enqoptions)
+        self.assertEqual(queue.deqOptions, queue.deqoptions)
+
+    def test_2735(self):
+        "2735 - test deprecated AQ methods (enqOne, deqOne)"
+        value = b"Test 2734"
+        queue = self.get_and_clear_queue("TEST_RAW_QUEUE")
+        queue.enqOne(self.conn.msgproperties(value))
+        props = queue.deqOne()
+        self.assertEqual(props.payload, value)
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_2800_bulk_aq.py

@@ -213,6 +213,15 @@ def test_2809(self):
         self.assertRaises(TypeError, queue.enqmany, ["Not", "msgproperties"])
         self.assertRaises(TypeError, queue.deqmany, "5")
 
+    def test_2810(self):
+        "2810 - test deprecated AQ methods (enqMany, deqMany)"
+        queue = self.get_and_clear_queue(RAW_QUEUE_NAME)
+        data = [b"labrador", b"schnauzer", b"shih tzu"]
+        queue.enqMany([self.conn.msgproperties(d) for d in data])
+        props = queue.deqMany(len(data) + 1)
+        dequeued_data = [p.payload for p in props]
+        self.assertEqual(dequeued_data, data)
+
 
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_3300_soda_database.py

@@ -37,10 +37,6 @@
     test_env.skip_soda_tests(), "unsupported client/server combination"
 )
 class TestCase(test_env.BaseTestCase):
-    def __drop_existing_collections(self, soda_db):
-        for name in soda_db.getCollectionNames():
-            soda_db.openCollection(name).drop()
-
     def __verify_doc(
         self,
         doc,
@@ -63,7 +59,7 @@ def __verify_doc(
 
     def test_3300(self):
         "3300 - test creating documents with JSON data"
-        soda_db = self.conn.getSodaDatabase()
+        soda_db = self.get_soda_database()
         val = {"testKey1": "testValue1", "testKey2": "testValue2"}
         str_val = json.dumps(val)
         bytes_val = str_val.encode()
@@ -78,7 +74,7 @@ def test_3300(self):
 
     def test_3301(self):
         "3301 - test creating documents with raw data"
-        soda_db = self.conn.getSodaDatabase()
+        soda_db = self.get_soda_database()
         val = b"<html/>"
         key = "MyRawKey"
         media_type = "text/html"
@@ -91,8 +87,7 @@ def test_3301(self):
 
     def test_3302(self):
         "3302 - test getting collection names from the database"
-        soda_db = self.conn.getSodaDatabase()
-        self.__drop_existing_collections(soda_db)
+        soda_db = self.get_soda_database()
         self.assertEqual(soda_db.getCollectionNames(), [])
         names = ["zCol", "dCol", "sCol", "aCol", "gCol"]
         sorted_names = list(sorted(names))
@@ -109,25 +104,26 @@ def test_3302(self):
 
     def test_3303(self):
         "3303 - test opening a collection"
-        soda_db = self.conn.getSodaDatabase()
-        self.__drop_existing_collections(soda_db)
+        soda_db = self.get_soda_database()
         coll = soda_db.openCollection("CollectionThatDoesNotExist")
         self.assertIsNone(coll)
         created_coll = soda_db.createCollection("TestOpenCollection")
         coll = soda_db.openCollection(created_coll.name)
         self.assertEqual(coll.name, created_coll.name)
-        coll.drop()
 
     def test_3304(self):
         "3304 - test SodaDatabase repr() and str()"
-        conn = test_env.get_connection()
-        soda_db = conn.getSodaDatabase()
-        self.assertEqual(repr(soda_db), f"<oracledb.SodaDatabase on {conn}>")
-        self.assertEqual(str(soda_db), f"<oracledb.SodaDatabase on {conn}>")
+        soda_db = self.get_soda_database()
+        self.assertEqual(
+            repr(soda_db), f"<oracledb.SodaDatabase on {self.conn}>"
+        )
+        self.assertEqual(
+            str(soda_db), f"<oracledb.SodaDatabase on {self.conn}>"
+        )
 
     def test_3305(self):
         "3305 - test negative cases for SODA database methods"
-        soda_db = self.conn.getSodaDatabase()
+        soda_db = self.get_soda_database()
         self.assertRaises(TypeError, soda_db.createCollection)
         self.assertRaises(TypeError, soda_db.createCollection, 1)
         self.assertRaisesRegex(