Further test improvements.

Author: anthony-tuininga

tests/test_1100_connection.py

@@ -149,7 +149,8 @@ def test_1105_bad_connect_string(self):
         self.assertRaisesRegex(oracledb.DatabaseError, "^DPY-4000:|^DPY-4001:",
                                oracledb.connect, test_env.get_main_user() + \
                                "@" + test_env.get_connect_string())
-        errors = "^DPY-4000:|^DPY-4001:|^DPY-4017:|^ORA-12154:|^ORA-12521:"
+        errors = "^DPY-4000:|^DPY-4001:|^DPY-4017:|^ORA-12154:|^ORA-12521:|" \
+                 "^ORA-12262:"
         self.assertRaisesRegex(oracledb.DatabaseError, errors,
                                oracledb.connect, test_env.get_main_user() + \
                                "@" + test_env.get_connect_string() + "/" + \
@@ -629,5 +630,29 @@ def test_1141_deprecations(self):
         self.assertEqual(conn.maxBytesPerCharacter, 4)
         self.assertEqual(conn.tnsentry, conn.dsn)
 
+    @unittest.skipIf(test_env.get_server_version() < (23, 0) or \
+                     test_env.get_client_version() < (23, 0),
+                     "unsupported client/server")
+    def test_1142_max_length_password(self):
+        "1142 - test maximum allowed length for password"
+        connection = test_env.get_connection()
+        if self.is_on_oracle_cloud(connection):
+            self.skipTest("passwords on Oracle Cloud are strictly controlled")
+
+        orig_password = test_env.get_main_password()
+        new_password_32 = 'a' * 32
+        connection.changepassword(orig_password, new_password_32)
+        connection = test_env.get_connection(password=new_password_32)
+
+        new_password_1024 = 'a' * 1024
+        connection.changepassword(new_password_32, new_password_1024)
+        connection = test_env.get_connection(password=new_password_1024)
+        connection.changepassword(new_password_1024, orig_password)
+
+        new_password_1025 = 'a' * 1025
+        self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-28218:",
+                          connection.changepassword, orig_password,
+                          new_password_1025)
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_2300_object_var.py

@@ -373,6 +373,7 @@ def test_2307_round_trip_object(self):
 
     def test_2308_invalid_type_object(self):
         "2308 - test trying to find an object type that does not exist"
+        self.assertRaises(TypeError, self.connection.gettype, 2)
         self.assertRaisesRegex(oracledb.DatabaseError, "^DPY-2035:",
                                self.connection.gettype,
                                "A TYPE THAT DOES NOT EXIST")

tests/test_3000_subscription.py

@@ -81,7 +81,8 @@ def _process_message(self, message):
                  "thin mode doesn't support subscriptions")
 class TestCase(test_env.BaseTestCase):
 
-    @unittest.skip("FIXME: threaded mode fails on close of connection?")
+    @unittest.skipIf(test_env.get_client_version() < (23, 1),
+                     "crashes in older clients")
     def test_3000_dml_subscription(self):
         "3000 - test subscription for insert, update, delete and truncate"
 
@@ -181,7 +182,8 @@ def test_3001_deprecations(self):
                                self.connection.subscribe,
                                client_initiated=True, clientInitiated=True)
 
-    @unittest.skip("multiple subscriptions cannot be created simultaneously")
+    @unittest.skipIf(test_env.get_client_version() < (23, 1),
+                     "crashes in older clients")
     def test_3002_aq_subscription(self):
         "3002 - test subscription for AQ"
 
@@ -206,7 +208,8 @@ 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?")
+    @unittest.skipIf(test_env.get_client_version() < (23, 1),
+                     "crashes in older clients")
     def test_3003_registerquery_returns(self):
         "3003 - test verifying what registerquery returns"
         data = DMLSubscriptionData(5)
@@ -230,5 +233,26 @@ def test_3003_registerquery_returns(self):
             connection.unsubscribe(sub)
             connection.close()
 
+    def test_3004_repr(self):
+        "3004 - test Subscription repr()"
+        data = DMLSubscriptionData(5)
+        with test_env.get_connection(events=True) as conn:
+            sub = conn.subscribe(callback=data.callback_handler)
+            self.assertEqual(repr(sub), f"<oracledb.Subscription on {conn}>")
+            conn.unsubscribe(sub)
+
+    @unittest.skipIf(test_env.get_client_version() < (23, 1),
+                     "crashes in older clients")
+    def test_3005_registerquery_negative(self):
+        "3005 - test registerquery with invalid parameters"
+        data = DMLSubscriptionData(5)
+        connection = test_env.get_connection(events=True)
+        sub = connection.subscribe(callback=data.callback_handler)
+        self.assertRaises(TypeError, sub.registerquery,
+                          "select * from TestTempTable", "invalid args")
+        self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-00942",
+                               sub.registerquery, "select * from Nonexistent")
+        connection.unsubscribe(sub)
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_3400_soda_collection.py

@@ -36,10 +36,20 @@
                  "unsupported client/server combination")
 class TestCase(test_env.BaseTestCase):
 
+    def __normalize_docs(self, docs):
+        """
+        Remove the embedded OID added in Oracle Database 23c, if found, in
+        order to ease comparison.
+        """
+        for doc in docs:
+            if doc is not None and "_id" in doc:
+                del doc["_id"]
+
     def __test_skip(self, coll, num_to_skip, expected_content):
         filter_spec = {'$orderby': [{'path': 'name', 'order': 'desc'}]}
         doc = coll.find().filter(filter_spec).skip(num_to_skip).getOne()
         content = doc.getContent() if doc is not None else None
+        self.__normalize_docs([content])
         self.assertEqual(content, expected_content)
 
     def test_3400_invalid_json(self):
@@ -70,8 +80,9 @@ def test_3401_insert_documents(self):
         self.connection.commit()
         self.assertEqual(coll.find().count(), len(values_to_insert))
         for key, value in zip(inserted_keys, values_to_insert):
-            doc = coll.find().key(key).getOne()
-            self.assertEqual(doc.getContent(), value)
+            doc = coll.find().key(key).getOne().getContent()
+            self.__normalize_docs([doc])
+            self.assertEqual(doc, value)
         coll.drop()
 
     def test_3402_skip_documents(self):
@@ -104,8 +115,9 @@ def test_3403_replace_document(self):
         new_content = {'name': 'John', 'address': {'city':'Melbourne'}}
         coll.find().key(doc.key).replaceOne(new_content)
         self.connection.commit()
-        self.assertEqual(coll.find().key(doc.key).getOne().getContent(),
-                         new_content)
+        doc = coll.find().key(doc.key).getOne().getContent()
+        self.__normalize_docs([doc])
+        self.assertEqual(doc, new_content)
         coll.drop()
 
     def test_3404_search_documents_with_content(self):
@@ -260,15 +272,17 @@ def test_3410_document_version(self):
         inserted_doc = coll.insertOneAndGet(content)
         key = inserted_doc.key
         version = inserted_doc.version
-        doc = coll.find().key(key).version(version).getOne()
-        self.assertEqual(doc.getContent(), content)
+        doc = coll.find().key(key).version(version).getOne().getContent()
+        self.__normalize_docs([doc])
+        self.assertEqual(doc, content)
         new_content = {'name': 'James', 'address': {'city': 'Delhi'}}
         replacedDoc = coll.find().key(key).replaceOneAndGet(new_content)
         new_version = replacedDoc.version
         doc = coll.find().key(key).version(version).getOne()
         self.assertEqual(doc, None)
-        doc = coll.find().key(key).version(new_version).getOne()
-        self.assertEqual(doc.getContent(), new_content)
+        doc = coll.find().key(key).version(new_version).getOne().getContent()
+        self.__normalize_docs([doc])
+        self.assertEqual(doc, new_content)
         self.assertEqual(coll.find().key(key).version(version).remove(), 0)
         self.assertEqual(coll.find().key(key).version(new_version).remove(), 1)
         self.assertEqual(coll.find().count(), 0)
@@ -473,6 +487,8 @@ def test_3420_save_and_get(self):
     def test_3421_insert_many_and_get(self):
         "3421 - test insert many and get"
         soda_db = self.get_soda_database(minclient=(18, 5))
+        for name in soda_db.getCollectionNames():
+            soda_db.openCollection(name).drop()
         coll = soda_db.createCollection("TestInsertManyAndGet")
         values_to_insert = [
             dict(name="George", age=25),
@@ -485,8 +501,9 @@ def test_3421_insert_many_and_get(self):
         for key, expected_doc in zip(inserted_keys, values_to_insert):
             if isinstance(expected_doc, dict):
                 expected_doc = soda_db.createDocument(expected_doc)
-            doc = coll.find().key(key).getOne()
-            self.assertEqual(doc.getContent(), expected_doc.getContent())
+            doc = coll.find().key(key).getOne().getContent()
+            self.__normalize_docs([doc])
+            self.assertEqual(doc, expected_doc.getContent())
         coll.drop()
 
     def test_3422_close_cursor(self):
@@ -540,6 +557,7 @@ def test_3425_map_mode(self):
             coll = soda_db.createCollection("TestSodaMapMode", mapMode=mapMode)
             coll.insertMany(data)
         fetched_data = list(d.getContent() for d in coll.find().getDocuments())
+        self.__normalize_docs(fetched_data)
         self.assertEqual(fetched_data, expected_data)
         self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-40626",
                                coll.drop)
@@ -615,6 +633,8 @@ def test_3429_getting_indexes(self):
         "3429 - test getting indexes on a collection"
         soda_db = self.get_soda_database()
         coll = soda_db.createCollection("TestSodaGetIndexes")
+        coll.drop()
+        coll = soda_db.createCollection("TestSodaGetIndexes")
         index_1 =  {
             'name': 'ix_3428-1',
             'fields': [

tests/test_4400_tpc.py

@@ -220,5 +220,34 @@ def test_4408_tpc_recover_read_only(self):
         recovers = self.connection.tpc_recover()
         self.assertEqual(len(recovers), 0)
 
+    def test_4409_tpc_commit_one_phase(self):
+        "4409 - test tpc_commit() with one_phase parameter"
+        self.cursor.execute("truncate table TestTempTable")
+        xid = self.connection.xid(4409, "txn4409", "branch1")
+        self.connection.tpc_begin(xid)
+        values = (1, 'test4409')
+        self.cursor.execute("""
+                insert into TestTempTable (IntCol, StringCol1)
+                values (:1, :2)""", values)
+        self.cursor.execute("select IntCol, StringCol1 from TestTempTable")
+        self.connection.tpc_commit(xid, one_phase=True)
+        self.assertEqual(self.cursor.fetchall(), [values])
+
+    def test_4410_tpc_commit_one_phase_negative(self):
+        "4410 - test negative cases for tpc_commit()"
+        self.cursor.execute("truncate table TestTempTable")
+        xid = self.connection.xid(4410, "txn4410", "branch1")
+        self.connection.tpc_begin(xid)
+        self.cursor.execute("""
+                insert into TestTempTable (IntCol, StringCol1)
+                values (1, 'test4410')""")
+        self.assertRaises(TypeError, self.connection.tpc_commit, "invalid xid")
+        self.connection.tpc_prepare(xid)
+        self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-02053:",
+                               self.connection.tpc_commit, xid, one_phase=True)
+        self.assertRaisesRegex(oracledb.DatabaseError, "^ORA-24756:",
+                               self.connection.tpc_commit, xid)
+        self.connection.tpc_rollback(xid)
+
 if __name__ == "__main__":
     test_env.run_test_cases()

tests/test_env.py

@@ -131,7 +131,7 @@ def get_client_version():
     value = PARAMETERS.get(name)
     if value is None:
         if get_is_thin():
-            value = (21, 3)
+            value = (23, 2)
         else:
             value = oracledb.clientversion()[:2]
         PARAMETERS[name] = value