def test_1122_connection_attributes(self): "1122 - test connection attribute values" connection = oracledb.connect(base.get_main_user(), base.get_main_password(), base.get_connect_string(), encoding="ASCII") self.assertEqual(connection.maxBytesPerCharacter, 1) connection = oracledb.connect(base.get_main_user(), base.get_main_password(), base.get_connect_string(), encoding="UTF-8") self.assertEqual(connection.maxBytesPerCharacter, 4) if base.get_client_version() >= (12, 1): self.assertEqual(connection.ltxid, b'') self.assertEqual(connection.current_schema, None) connection.current_schema = "test_schema" self.assertEqual(connection.current_schema, "test_schema") self.assertEqual(connection.edition, None) connection.external_name = "test_external" self.assertEqual(connection.external_name, "test_external") connection.internal_name = "test_internal" self.assertEqual(connection.internal_name, "test_internal") connection.stmtcachesize = 30 self.assertEqual(connection.stmtcachesize, 30) self.assertRaises(TypeError, connection.stmtcachesize, 20.5) self.assertRaises(TypeError, connection.stmtcachesize, "value")
def test_2412_tagging_invalid_key(self): "2412 - testTagging with Invalid key" pool = base.get_pool(getmode=oracledb.SPOOL_ATTRVAL_NOWAIT) conn = pool.acquire() self.assertRaises(TypeError, pool.release, conn, tag=12345) if base.get_client_version() >= (12, 2): self.assertRaises(oracledb.DatabaseError, pool.release, conn, tag="INVALID_TAG")
def test_1123_closed_connection_attributes(self): "1123 - test closed connection attribute values" connection = base.get_connection() connection.close() attr_names = ["current_schema", "edition", "external_name", "internal_name", "stmtcachesize"] if base.get_client_version() >= (12, 1): attr_names.append("ltxid") for name in attr_names: self.assertRaises(oracledb.InterfaceError, getattr, connection, name)
def test_2400_pool(self): "2400 - test that the pool is created and has the right attributes" pool = base.get_pool(min=2, max=8, increment=3, getmode=oracledb.SPOOL_ATTRVAL_WAIT) self.assertEqual(pool.username, base.get_main_user(), "user name differs") self.assertEqual(pool.tnsentry, base.get_connect_string(), "tnsentry differs") self.assertEqual(pool.dsn, base.get_connect_string(), "dsn differs") self.assertEqual(pool.max, 8, "max differs") self.assertEqual(pool.min, 2, "min differs") self.assertEqual(pool.increment, 3, "increment differs") self.assertEqual(pool.opened, 2, "opened differs") self.assertEqual(pool.busy, 0, "busy not 0 at start") connection_1 = pool.acquire() self.assertEqual(pool.busy, 1, "busy not 1 after acquire") self.assertEqual(pool.opened, 2, "opened not unchanged (1)") connection_2 = pool.acquire() self.assertEqual(pool.busy, 2, "busy not 2 after acquire") self.assertEqual(pool.opened, 2, "opened not unchanged (2)") connection_3 = pool.acquire() self.assertEqual(pool.busy, 3, "busy not 3 after acquire") self.assertEqual(pool.opened, 5, "opened not changed (3)") pool.release(connection_3) self.assertEqual(pool.busy, 2, "busy not 2 after release") del connection_2 self.assertEqual(pool.busy, 1, "busy not 1 after del") pool.getmode = oracledb.SPOOL_ATTRVAL_NOWAIT self.assertEqual(pool.getmode, oracledb.SPOOL_ATTRVAL_NOWAIT) if base.get_client_version() >= (12, 2): pool.getmode = oracledb.SPOOL_ATTRVAL_TIMEDWAIT self.assertEqual(pool.getmode, oracledb.SPOOL_ATTRVAL_TIMEDWAIT) pool.stmtcachesize = 50 self.assertEqual(pool.stmtcachesize, 50) pool.timeout = 10 self.assertEqual(pool.timeout, 10) if base.get_client_version() >= (12, 1): pool.max_lifetime_session = 10 self.assertEqual(pool.max_lifetime_session, 10)
def test_1103_attributes(self): "1103 - test connection end-to-end tracing attributes" connection = base.get_connection() if base.get_client_version() >= (12, 1) \ and not self.is_on_oracle_cloud(connection): sql = "select dbop_name from v$sql_monitor " \ "where sid = sys_context('userenv', 'sid')" \ "and status = 'EXECUTING'" self.__verify_attributes(connection, "dbop", "oracledb_dbop", sql) sql = "select sys_context('userenv', 'action') from dual" self.__verify_attributes(connection, "action", "oracledb_Action", sql) sql = "select sys_context('userenv', 'module') from dual" self.__verify_attributes(connection, "module", "oracledb_Module", sql) sql = "select sys_context('userenv', 'client_info') from dual" self.__verify_attributes(connection, "clientinfo", "oracledb_cinfo", sql) sql = "select sys_context('userenv', 'client_identifier') from dual" self.__verify_attributes(connection, "client_identifier", "oracledb_cid", sql)
def test_2411_plsql_session_callbacks(self): "2411 - test PL/SQL session callbacks" if base.get_client_version() < (12, 2): self.skipTest("PL/SQL session callbacks not supported before 12.2") pool = base.get_pool(min=2, max=8, increment=3, getmode=oracledb.SPOOL_ATTRVAL_NOWAIT, sessionCallback="pkg_SessionCallback.TheCallback") tags = [ "NLS_DATE_FORMAT=SIMPLE", "NLS_DATE_FORMAT=FULL;TIME_ZONE=UTC", "NLS_DATE_FORMAT=FULL;TIME_ZONE=MST" ] actual_tags = [None, None, "NLS_DATE_FORMAT=FULL;TIME_ZONE=UTC"] # truncate PL/SQL session callback log conn = pool.acquire() cursor = conn.cursor() cursor.execute("truncate table PLSQLSessionCallbacks") conn.close() # request sessions with each of the first two tags for tag in tags[:2]: conn = pool.acquire(tag=tag) conn.close() # for the last tag, use the matchanytag flag conn = pool.acquire(tag=tags[2], matchanytag=True) conn.close() # verify the PL/SQL session callback log is accurate conn = pool.acquire() cursor = conn.cursor() cursor.execute(""" select RequestedTag, ActualTag from PLSQLSessionCallbacks order by FixupTimestamp""") results = cursor.fetchall() expected_results = list(zip(tags, actual_tags)) self.assertEqual(results, expected_results)
# # Portions Copyright 2001-2007, Computronix (Canada) Ltd., Edmonton, Alberta, # Canada. All rights reserved. #------------------------------------------------------------------------------ """ 3200 - Module for testing features introduced in 12.1 """ import base import cx_Oracle as oracledb import datetime import unittest @unittest.skipUnless(base.get_client_version() >= (12, 1), "unsupported client") class TestCase(base.BaseTestCase): def test_3200_array_dml_row_counts_off(self): "3200 - test executing with arraydmlrowcounts mode disabled" self.cursor.execute("truncate table TestArrayDML") rows = [(1, "First"), (2, "Second")] sql = "insert into TestArrayDML (IntCol,StringCol) values (:1,:2)" self.cursor.executemany(sql, rows, arraydmlrowcounts=False) self.assertRaises(oracledb.DatabaseError, self.cursor.getarraydmlrowcounts) rows = [(3, "Third"), (4, "Fourth")] self.cursor.executemany(sql, rows) self.assertRaises(oracledb.DatabaseError, self.cursor.getarraydmlrowcounts)
class TestCase(base.BaseTestCase): 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.assertEqual(content, expected_content) def test_3400_invalid_json(self): "3400 - test inserting invalid JSON value into SODA collection" invalid_json = "{testKey:testValue}" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("InvalidJSON") doc = soda_db.createDocument(invalid_json) self.assertRaises(oracledb.DatabaseError, coll.insertOne, doc) coll.drop() def test_3401_insert_documents(self): "3401 - test inserting documents into a SODA collection" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoInsertDocs") coll.find().remove() values_to_insert = [{ "name": "George", "age": 47 }, { "name": "Susan", "age": 39 }, { "name": "John", "age": 50 }, { "name": "Jill", "age": 54 }] inserted_keys = [] for value in values_to_insert: doc = coll.insertOneAndGet(value) inserted_keys.append(doc.key) 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) coll.drop() def test_3402_skip_documents(self): "3402 - test skipping documents in a SODA collection" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoSkipDocs") coll.find().remove() values_to_insert = [{ "name": "Anna", "age": 62 }, { "name": "Mark", "age": 37 }, { "name": "Martha", "age": 43 }, { "name": "Matthew", "age": 28 }] for value in values_to_insert: coll.insertOne(value) self.connection.commit() self.__test_skip(coll, 0, values_to_insert[3]) self.__test_skip(coll, 1, values_to_insert[2]) self.__test_skip(coll, 3, values_to_insert[0]) self.__test_skip(coll, 4, None) self.__test_skip(coll, 125, None) def test_3403_replace_document(self): "3403 - test replace documents in SODA collection" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoReplaceDoc") coll.find().remove() content = {'name': 'John', 'address': {'city': 'Sydney'}} doc = coll.insertOneAndGet(content) 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) coll.drop() def test_3404_search_documents_with_content(self): "3404 - test search documents with content using $like and $regex" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoSearchDocContent") coll.find().remove() data = [{ 'name': 'John', 'address': { 'city': 'Bangalore' } }, { 'name': 'Johnson', 'address': { 'city': 'Banaras' } }, { 'name': 'Joseph', 'address': { 'city': 'Bangalore' } }, { 'name': 'Jibin', 'address': { 'city': 'Secunderabad' } }, { 'name': 'Andrew', 'address': { 'city': 'Hyderabad' } }, { 'name': 'Matthew', 'address': { 'city': 'Mumbai' } }] for value in data: coll.insertOne(value) self.connection.commit() filter_specs = [({ 'name': { '$like': 'And%' } }, 1), ({ 'name': { '$like': 'J%n' } }, 3), ({ 'name': { '$like': '%hn%' } }, 2), ({ 'address.city': { '$like': 'Ban%' } }, 3), ({ 'address.city': { '$like': '%bad' } }, 2), ({ 'address.city': { '$like': 'Hyderabad' } }, 1), ({ 'address.city': { '$like': 'China%' } }, 0), ({ 'name': { '$regex': 'Jo.*' } }, 3), ({ 'name': { '$regex': '.*[ho]n' } }, 2), ({ 'name': { '$regex': 'J.*h' } }, 1), ({ 'address.city': { '$regex': 'Ba.*' } }, 3), ({ 'address.city': { '$regex': '.*bad' } }, 2), ({ 'address.city': { '$regex': 'Hyderabad' } }, 1), ({ 'name': { '$regex': 'Js.*n' } }, 0)] for filter_spec, expected_count in filter_specs: self.assertEqual(coll.find().filter(filter_spec).count(), expected_count, filter_spec) coll.drop() def test_3405_document_remove(self): "3405 - test removing documents" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoRemoveDocs") coll.find().remove() data = [{ 'name': 'John', 'address': { 'city': 'Bangalore' } }, { 'name': 'Johnson', 'address': { 'city': 'Banaras' } }, { 'name': 'Joseph', 'address': { 'city': 'Mangalore' } }, { 'name': 'Jibin', 'address': { 'city': 'Secunderabad' } }, { 'name': 'Andrew', 'address': { 'city': 'Hyderabad' } }, { 'name': 'Matthew', 'address': { 'city': 'Mumbai' } }] docs = [coll.insertOneAndGet(v) for v in data] coll.find().key(docs[3].key).remove() self.assertEqual(coll.find().count(), len(data) - 1) searchResults = coll.find().filter({'name': {'$like': 'Jibin'}}) self.assertEqual(searchResults.count(), 0) coll.find().filter({'name': {'$like': 'John%'}}).remove() self.assertEqual(coll.find().count(), len(data) - 3) coll.find().filter({'name': {'$regex': 'J.*'}}).remove() self.assertEqual(coll.find().count(), len(data) - 4) self.connection.commit() coll.drop() def test_3406_CreateAndDropIndex(self): "3406 - test create and drop Index" index_name = "cxoTestIndexes_ix_1" index_spec = { 'name': index_name, 'fields': [{ 'path': 'address.city', 'datatype': 'string', 'order': 'asc' }] } soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("TestIndexes") coll.find().remove() self.connection.commit() coll.dropIndex(index_name) coll.createIndex(index_spec) self.assertRaises(oracledb.DatabaseError, coll.createIndex, index_spec) self.assertEqual(coll.dropIndex(index_name), True) self.assertEqual(coll.dropIndex(index_name), False) coll.drop() def test_3407_get_documents(self): "3407 - test getting documents from Collection" self.connection.autocommit = True soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoTestGetDocs") coll.find().remove() data = [{ 'name': 'John', 'address': { 'city': 'Bangalore' } }, { 'name': 'Johnson', 'address': { 'city': 'Banaras' } }, { 'name': 'Joseph', 'address': { 'city': 'Mangalore' } }, { 'name': 'Jibin', 'address': { 'city': 'Secunderabad' } }, { 'name': 'Andrew', 'address': { 'city': 'Hyderabad' } }] inserted_keys = list(sorted(coll.insertOneAndGet(v).key for v in data)) fetched_keys = list(sorted(d.key for d in coll.find().getDocuments())) self.assertEqual(fetched_keys, inserted_keys) coll.drop() def test_3408_cursor(self): "3408 - test fetching documents from a cursor" self.connection.autocommit = True soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoFindViaCursor") coll.find().remove() data = [ { 'name': 'John', 'address': { 'city': 'Bangalore' } }, { 'name': 'Johnson', 'address': { 'city': 'Banaras' } }, { 'name': 'Joseph', 'address': { 'city': 'Mangalore' } }, ] inserted_keys = list(sorted(coll.insertOneAndGet(v).key for v in data)) fetched_keys = list(sorted(d.key for d in coll.find().getCursor())) self.assertEqual(fetched_keys, inserted_keys) coll.drop() def test_3409_multiple_document_remove(self): "3409 - test removing multiple documents using multiple keys" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoRemoveMultipleDocs") coll.find().remove() data = [{ 'name': 'John', 'address': { 'city': 'Bangalore' } }, { 'name': 'Johnson', 'address': { 'city': 'Banaras' } }, { 'name': 'Joseph', 'address': { 'city': 'Mangalore' } }, { 'name': 'Jibin', 'address': { 'city': 'Secunderabad' } }, { 'name': 'Andrew', 'address': { 'city': 'Hyderabad' } }, { 'name': 'Matthew', 'address': { 'city': 'Mumbai' } }] docs = [coll.insertOneAndGet(v) for v in data] keys = [docs[i].key for i in (1, 3, 5)] num_removed = coll.find().keys(keys).remove() self.assertEqual(num_removed, len(keys)) self.assertEqual(coll.find().count(), len(data) - len(keys)) self.connection.commit() coll.drop() def test_3410_document_version(self): "3410 - test using version to get documents and remove them" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoDocumentVersion") coll.find().remove() content = {'name': 'John', 'address': {'city': 'Bangalore'}} 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) 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) 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) self.connection.commit() coll.drop() def test_3411_get_cursor(self): "3411 - test keys with GetCursor" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoKeysWithGetCursor") coll.find().remove() data = [{ 'name': 'John', 'address': { 'city': 'Bangalore' } }, { 'name': 'Johnson', 'address': { 'city': 'Banaras' } }, { 'name': 'Joseph', 'address': { 'city': 'Mangalore' } }, { 'name': 'Jibin', 'address': { 'city': 'Secunderabad' } }, { 'name': 'Andrew', 'address': { 'city': 'Hyderabad' } }, { 'name': 'Matthew', 'address': { 'city': 'Mumbai' } }] docs = [coll.insertOneAndGet(v) for v in data] keys = [docs[i].key for i in (2, 4, 5)] fetched_keys = [d.key for d in coll.find().keys(keys).getCursor()] self.assertEqual(list(sorted(fetched_keys)), list(sorted(keys))) self.connection.commit() coll.drop() def test_3412_created_on(self): "3412 - test createdOn attribute of Document" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("CreatedOn") coll.find().remove() data = {'name': 'John', 'address': {'city': 'Bangalore'}} doc = coll.insertOneAndGet(data) self.assertEqual(doc.createdOn, doc.lastModified) @unittest.skipIf(base.get_client_version() < (20, 1), "unsupported client") def test_3413_soda_truncate(self): "3413 - test Soda truncate" soda_db = self.connection.getSodaDatabase() coll = soda_db.createCollection("cxoTruncateDocs") coll.find().remove() values_to_insert = [{ "name": "George", "age": 47 }, { "name": "Susan", "age": 39 }, { "name": "John", "age": 50 }, { "name": "Jill", "age": 54 }] for value in values_to_insert: coll.insertOne(value) self.connection.commit() self.assertEqual(coll.find().count(), len(values_to_insert)) coll.truncate() self.assertEqual(coll.find().count(), 0) coll.drop()