HackBase/python-cx_Oracle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated test cases to use the correct names for the various assertions instead

Browse Source 
of the deprecated names.
This commit is contained in:
Anthony Tuininga 2016-01-21 09:59:03 -07:00
parent 0e35397616
commit 2ba419ebd6
31 changed files with 607 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
test/3kArrayDMLBatchError.py
View File

@ -9,12 +9,12 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, "Second") ]
sql = "insert into TestArrayDML (IntCol,StringCol) values (:1,:2)"
self.cursor.executemany(sql, rows, arraydmlrowcounts = False)
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.getarraydmlrowcounts)
rows = [ (3, "Third"),
(4, "Fourth") ]
self.cursor.executemany(sql, rows)
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.getarraydmlrowcounts)
def testArrayDMLRowCountsOn(self):
@ -29,11 +29,11 @@ class TestArrayDMLBatchError(BaseTestCase):
"values (:1,:2,:3)"
self.cursor.executemany(sql, rows, arraydmlrowcounts = True)
self.connection.commit()
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1, 1, 1, 1, 1])
self.cursor.execute("select count(*) from TestArrayDML")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExceptionInIteration(self):
"test executing with arraydmlrowcounts with exception"
@ -43,9 +43,9 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, "Third"),
(4, "Fourth") ]
sql = "insert into TestArrayDML (IntCol,StringCol) values (:1,:2)"
self.failUnlessRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
self.assertRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
sql, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(), [1, 1])
self.assertEqual(self.cursor.getarraydmlrowcounts(), [1, 1])
def testExecutingDelete(self):
"test executing delete statement with arraydmlrowcount mode"
@ -64,7 +64,7 @@ class TestArrayDMLBatchError(BaseTestCase):
rows = [ (200,), (300,), (400,) ]
statement = "delete from TestArrayDML where IntCol2 = :1"
self.cursor.executemany(statement, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(), [1, 3, 2])
self.assertEqual(self.cursor.getarraydmlrowcounts(), [1, 3, 2])
def testExecutingUpdate(self):
"test executing update statement with arraydmlrowcount mode"
@ -86,7 +86,7 @@ class TestArrayDMLBatchError(BaseTestCase):
("Four", 400) ]
sql = "update TestArrayDML set StringCol = :1 where IntCol2 = :2"
self.cursor.executemany(sql, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(), [1, 1, 3, 2])
self.assertEqual(self.cursor.getarraydmlrowcounts(), [1, 1, 3, 2])
def testInsertWithBatchError(self):
"test executing insert with multiple distinct batch errors"
@ -108,8 +108,8 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(actualErrors, expectedErrors)
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1, 1, 0, 1, 0])
def testBatchErrorFalse(self):
@ -120,7 +120,7 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, "Third", 300) ]
sql = "insert into TestArrayDML (IntCol, StringCol, IntCol2) " \
"values (:1, :2, :3)"
self.failUnlessRaises(cx_Oracle.IntegrityError,
self.assertRaises(cx_Oracle.IntegrityError,
self.cursor.executemany, sql, rows, batcherrors = False)
def testUpdatewithBatchError(self):
@ -143,7 +143,7 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.assertEqual(actualErrors, expectedErrors)
rows = [ (101, "First"),
(201, "Second"),
(3000, "Third"),
@ -158,8 +158,8 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(actualErrors, expectedErrors)
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1, 2, 0, 0, 1])
self.failUnlessEqual(self.cursor.rowcount, 4)
self.assertEqual(self.cursor.rowcount, 4)

60
test/3kNumberVar.py
View File

@ -28,7 +28,7 @@ class TestNumberVar(BaseTestCase):
where NumberCol - :value1 - :value2 = trunc(NumberCol)""",
value1 = decimal.Decimal("0.20"),
value2 = decimal.Decimal("0.05"))
self.failUnlessEqual(self.cursor.fetchall(),
self.assertEqual(self.cursor.fetchall(),
[self.dataByKey[1], self.dataByKey[5], self.dataByKey[9]])
def testBindFloat(self):
@ -37,7 +37,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where NumberCol - :value = trunc(NumberCol)""",
value = 0.25)
self.failUnlessEqual(self.cursor.fetchall(),
self.assertEqual(self.cursor.fetchall(),
[self.dataByKey[1], self.dataByKey[5], self.dataByKey[9]])
def testBindSmallLong(self):
@ -46,7 +46,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 3)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindLargeLong(self):
"test binding in a large long integer"
@ -58,7 +58,7 @@ class TestNumberVar(BaseTestCase):
end;""",
value = valueVar)
value = valueVar.getvalue()
self.failUnlessEqual(value, 6088343249)
self.assertEqual(value, 6088343249)
def testBindIntegerAfterString(self):
"test binding in an number after setting input sizes to a string"
@ -67,7 +67,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 3)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindNull(self):
"test binding in a null"
@ -75,7 +75,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindNumberArrayDirect(self):
"test binding in a number array"
@ -90,12 +90,12 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
startValue = 5,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 73.75)
self.assertEqual(returnValue.getvalue(), 73.75)
array = list(range(15))
self.cursor.execute(statement,
startValue = 10,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 115.0)
self.assertEqual(returnValue.getvalue(), 115.0)
def testBindNumberArrayBySizes(self):
"test binding in a number array (with setinputsizes)"
@ -110,7 +110,7 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
startValue = 6,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 74.75)
self.assertEqual(returnValue.getvalue(), 74.75)
def testBindNumberArrayByVar(self):
"test binding in a number array (with arrayvar)"
@ -126,7 +126,7 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
integerValue = 7,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 75.75)
self.assertEqual(returnValue.getvalue(), 75.75)
def testBindZeroLengthNumberArrayByVar(self):
"test binding in a zero length number array (with arrayvar)"
@ -140,8 +140,8 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
integerValue = 8,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 8.0)
self.failUnlessEqual(array.getvalue(), [])
self.assertEqual(returnValue.getvalue(), 8.0)
self.assertEqual(array.getvalue(), [])
def testBindInOutNumberArrayByVar(self):
"test binding in/out a number array (with arrayvar)"
@ -156,7 +156,7 @@ class TestNumberVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutNumberArrayByVar(self):
"test binding out a Number array (with arrayvar)"
@ -168,7 +168,7 @@ class TestNumberVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutSetInputSizes(self):
"test binding out with set input sizes defined"
@ -177,7 +177,7 @@ class TestNumberVar(BaseTestCase):
begin
:value := 5;
end;""")
self.failUnlessEqual(vars["value"].getvalue(), 5)
self.assertEqual(vars["value"].getvalue(), 5)
def testBindInOutSetInputSizes(self):
"test binding in/out with set input sizes defined"
@ -187,7 +187,7 @@ class TestNumberVar(BaseTestCase):
:value := :value + 5;
end;""",
value = 1.25)
self.failUnlessEqual(vars["value"].getvalue(), 6.25)
self.assertEqual(vars["value"].getvalue(), 6.25)
def testBindOutVar(self):
"test binding out with cursor.var() method"
@ -197,7 +197,7 @@ class TestNumberVar(BaseTestCase):
:value := 5;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), 5)
self.assertEqual(var.getvalue(), 5)
def testBindInOutVarDirectSet(self):
"test binding in/out with cursor.var() method"
@ -208,12 +208,12 @@ class TestNumberVar(BaseTestCase):
:value := :value + 5;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), 7.25)
self.assertEqual(var.getvalue(), 7.25)
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestNumbers")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('NUMBERCOL', cx_Oracle.NUMBER, 13, 22, 9, 2, 0),
('FLOATCOL', cx_Oracle.NUMBER, 127, 22, 126, -127, 0),
@ -223,17 +223,17 @@ class TestNumberVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestNumbers order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestNumbers order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -242,13 +242,13 @@ class TestNumberVar(BaseTestCase):
from TestNumbers
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)
def testReturnAsFloat(self):
"test that fetching a floating point number returns such in Python"
self.cursor.execute("select 1.25 from dual")
result, = self.cursor.fetchone()
self.failUnlessEqual(result, 1.25)
self.assertEqual(result, 1.25)

62
test/3kStringVar.py
View File

@ -24,7 +24,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = "String 5")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindDifferentVar(self):
"test binding a different variable on second execution"
@ -32,10 +32,10 @@ class TestStringVar(BaseTestCase):
retval_2 = self.cursor.var(cx_Oracle.STRING, 30)
self.cursor.execute("begin :retval := 'Called'; end;",
retval = retval_1)
self.failUnlessEqual(retval_1.getvalue(), "Called")
self.assertEqual(retval_1.getvalue(), "Called")
self.cursor.execute("begin :retval := 'Called'; end;",
retval = retval_2)
self.failUnlessEqual(retval_2.getvalue(), "Called")
self.assertEqual(retval_2.getvalue(), "Called")
def testBindStringAfterNumber(self):
"test binding in a string after setting input sizes to a number"
@ -44,7 +44,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = "String 6")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[6]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[6]])
def testBindStringArrayDirect(self):
"test binding in a string array"
@ -59,12 +59,12 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 5,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 86)
self.assertEqual(returnValue.getvalue(), 86)
array = [ "String - %d" % i for i in range(15) ]
self.cursor.execute(statement,
integerValue = 8,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 163)
self.assertEqual(returnValue.getvalue(), 163)
def testBindStringArrayBySizes(self):
"test binding in a string array (with setinputsizes)"
@ -79,7 +79,7 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 6,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 87)
self.assertEqual(returnValue.getvalue(), 87)
def testBindStringArrayByVar(self):
"test binding in a string array (with arrayvar)"
@ -94,7 +94,7 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 7,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 88)
self.assertEqual(returnValue.getvalue(), 88)
def testBindInOutStringArrayByVar(self):
"test binding in/out a string array (with arrayvar)"
@ -110,7 +110,7 @@ class TestStringVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutStringArrayByVar(self):
"test binding out a string array (with arrayvar)"
@ -122,7 +122,7 @@ class TestStringVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindRaw(self):
"test binding in a raw"
@ -131,7 +131,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where RawCol = :value""",
value = b"Raw 4")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[4]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[4]])
def testBindAndFetchRowid(self):
"test binding (and fetching) a rowid"
@ -145,7 +145,7 @@ class TestStringVar(BaseTestCase):
from TestStrings
where rowid = :value""",
value = rowid)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindNull(self):
"test binding in a null"
@ -153,7 +153,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizesByType(self):
"test binding out with set input sizes defined (by type)"
@ -162,7 +162,7 @@ class TestStringVar(BaseTestCase):
begin
:value := 'TSI';
end;""")
self.failUnlessEqual(vars["value"].getvalue(), "TSI")
self.assertEqual(vars["value"].getvalue(), "TSI")
def testBindOutSetInputSizesByInteger(self):
"test binding out with set input sizes defined (by integer)"
@ -171,7 +171,7 @@ class TestStringVar(BaseTestCase):
begin
:value := 'TSI (I)';
end;""")
self.failUnlessEqual(vars["value"].getvalue(), "TSI (I)")
self.assertEqual(vars["value"].getvalue(), "TSI (I)")
def testBindInOutSetInputSizesByType(self):
"test binding in/out with set input sizes defined (by type)"
@ -181,7 +181,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI';
end;""",
value = "InVal")
self.failUnlessEqual(vars["value"].getvalue(), "InVal TSI")
self.assertEqual(vars["value"].getvalue(), "InVal TSI")
def testBindInOutSetInputSizesByInteger(self):
"test binding in/out with set input sizes defined (by integer)"
@ -191,7 +191,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI (I)';
end;""",
value = "InVal")
self.failUnlessEqual(vars["value"].getvalue(), "InVal TSI (I)")
self.assertEqual(vars["value"].getvalue(), "InVal TSI (I)")
def testBindOutVar(self):
"test binding out with cursor.var() method"
@ -201,7 +201,7 @@ class TestStringVar(BaseTestCase):
:value := 'TSI (VAR)';
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), "TSI (VAR)")
self.assertEqual(var.getvalue(), "TSI (VAR)")
def testBindInOutVarDirectSet(self):
"test binding in/out with cursor.var() method"
@ -212,7 +212,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI (VAR)';
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), "InVal TSI (VAR)")
self.assertEqual(var.getvalue(), "InVal TSI (VAR)")
def testBindLongString(self):
"test that binding a long string succeeds"
@ -231,14 +231,14 @@ class TestStringVar(BaseTestCase):
inString = "1234567890" * 9000
var.setvalue(0, inString)
outString = var.getvalue()
self.failUnlessEqual(inString, outString,
self.assertEqual(inString, outString,
"output does not match: in was %d, out was %d" % \
(len(inString), len(outString)))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestStrings")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('STRINGCOL', cx_Oracle.STRING, 20, 20, 0, 0, 0),
('RAWCOL', cx_Oracle.BINARY, 30, 30, 0, 0, 0),
@ -248,17 +248,17 @@ class TestStringVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestStrings order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestStrings order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -267,7 +267,7 @@ class TestStringVar(BaseTestCase):
from TestStrings
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

30
test/ArrayDMLBatchError.py
View File

@ -9,12 +9,12 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, "Second") ]
sql = "insert into TestArrayDML (IntCol,StringCol) values (:1,:2)"
self.cursor.executemany(sql, rows, arraydmlrowcounts = False)
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.getarraydmlrowcounts)
rows = [ (3, "Third"),
(4, "Fourth") ]
self.cursor.executemany(sql, rows)
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.getarraydmlrowcounts)
def testArrayDMLRowCountsOn(self):
@ -29,11 +29,11 @@ class TestArrayDMLBatchError(BaseTestCase):
"values (:1,:2,:3)"
self.cursor.executemany(sql, rows, arraydmlrowcounts = True)
self.connection.commit()
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 1L, 1L, 1L, 1L])
self.cursor.execute("select count(*) from TestArrayDML")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExceptionInIteration(self):
"test executing with arraydmlrowcounts with exception"
@ -43,9 +43,9 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, "Third"),
(4, "Fourth") ]
sql = "insert into TestArrayDML (IntCol,StringCol) values (:1,:2)"
self.failUnlessRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
self.assertRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
sql, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(), [1L, 1L])
self.assertEqual(self.cursor.getarraydmlrowcounts(), [1L, 1L])
def testExecutingDelete(self):
"test executing delete statement with arraydmlrowcount mode"
@ -64,7 +64,7 @@ class TestArrayDMLBatchError(BaseTestCase):
rows = [ (200,), (300,), (400,) ]
statement = "delete from TestArrayDML where IntCol2 = :1"
self.cursor.executemany(statement, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(), [1L, 3L, 2L])
self.assertEqual(self.cursor.getarraydmlrowcounts(), [1L, 3L, 2L])
def testExecutingUpdate(self):
"test executing update statement with arraydmlrowcount mode"
@ -86,7 +86,7 @@ class TestArrayDMLBatchError(BaseTestCase):
("Four", 400) ]
sql = "update TestArrayDML set StringCol = :1 where IntCol2 = :2"
self.cursor.executemany(sql, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 1L, 3L, 2L])
def testInsertWithBatchError(self):
@ -109,8 +109,8 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(actualErrors, expectedErrors)
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 1L, 0L, 1L, 0L])
def testBatchErrorFalse(self):
@ -121,7 +121,7 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, "Third", 300) ]
sql = "insert into TestArrayDML (IntCol, StringCol, IntCol2) " \
"values (:1, :2, :3)"
self.failUnlessRaises(cx_Oracle.IntegrityError,
self.assertRaises(cx_Oracle.IntegrityError,
self.cursor.executemany, sql, rows, batcherrors = False)
def testUpdatewithBatchError(self):
@ -144,7 +144,7 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.assertEqual(actualErrors, expectedErrors)
rows = [ (101, "First"),
(201, "Second"),
(3000, "Third"),
@ -159,8 +159,8 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(actualErrors, expectedErrors)
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 2L, 0L, 0L, 1L])
self.failUnlessEqual(self.cursor.rowcount, 4)
self.assertEqual(self.cursor.rowcount, 4)

10
test/BooleanVar.py
View File

@ -6,30 +6,30 @@ class TestBooleanVar(BaseTestCase):
"test binding in a False value"
result = self.cursor.callfunc("pkg_TestBooleans.GetStringRep", str,
(False,))
self.failUnlessEqual(result, "FALSE")
self.assertEqual(result, "FALSE")
def testBindNull(self):
"test binding in a null value"
self.cursor.setinputsizes(None, bool)
result = self.cursor.callfunc("pkg_TestBooleans.GetStringRep", str,
(None,))
self.failUnlessEqual(result, "NULL")
self.assertEqual(result, "NULL")
def testBindOutFalse(self):
"test binding out a boolean value (False)"
result = self.cursor.callfunc("pkg_TestBooleans.IsLessThan10",
cx_Oracle.BOOLEAN, (15,))
self.failUnlessEqual(result, False)
self.assertEqual(result, False)
def testBindOutTrue(self):
"test binding out a boolean value (True)"
result = self.cursor.callfunc("pkg_TestBooleans.IsLessThan10", bool,
(5,))
self.failUnlessEqual(result, True)
self.assertEqual(result, True)
def testBindTrue(self):
"test binding in a True value"
result = self.cursor.callfunc("pkg_TestBooleans.GetStringRep", str,
(True,))
self.failUnlessEqual(result, "TRUE")
self.assertEqual(result, "TRUE")

24
test/Connection.py
View File

@ -11,7 +11,7 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute("select count(*) from TestNumbers")
count, = cursor.fetchone()
self.failUnlessEqual(count, 10)
self.assertEqual(count, 10)
def setUp(self):
self.username = USERNAME
@ -19,9 +19,9 @@ class TestConnection(TestCase):
self.tnsentry = TNSENTRY
def verifyArgs(self, connection):
self.failUnlessEqual(connection.username, self.username,
self.assertEqual(connection.username, self.username,
"user name differs")
self.failUnlessEqual(connection.tnsentry, self.tnsentry,
self.assertEqual(connection.tnsentry, self.tnsentry,
"tnsentry differs")
def testAllArgs(self):
@ -32,16 +32,16 @@ class TestConnection(TestCase):
def testBadConnectString(self):
"connection to database with bad connect string"
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username)
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username + "@" + self.tnsentry)
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username + "@" + self.tnsentry + "/" + self.password)
def testBadPassword(self):
"connection to database with bad password"
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username, self.password + "X", self.tnsentry)
def testExceptionOnClose(self):
@ -49,7 +49,7 @@ class TestConnection(TestCase):
connection = cx_Oracle.connect(self.username, self.password,
self.tnsentry)
connection.close()
self.failUnlessRaises(cx_Oracle.InterfaceError, connection.rollback)
self.assertRaises(cx_Oracle.InterfaceError, connection.rollback)
def testMakeDSN(self):
"test making a data source name from host, port and sid"
@ -57,7 +57,7 @@ class TestConnection(TestCase):
"(HOST=%s)(PORT=%d)))(CONNECT_DATA=(SID=%s)))"
args = ("hostname", 1521, "TEST")
result = cx_Oracle.makedsn(*args)
self.failUnlessEqual(result, formatString % args)
self.assertEqual(result, formatString % args)
def testSingleArg(self):
"connection to database with user, password, TNS together"
@ -69,7 +69,7 @@ class TestConnection(TestCase):
"connection version is a string"
connection = cx_Oracle.connect(self.username, self.password,
self.tnsentry)
self.failUnless(isinstance(connection.version, str))
self.assertTrue(isinstance(connection.version, str))
def testRollbackOnClose(self):
"connection rolls back before close"
@ -84,7 +84,7 @@ class TestConnection(TestCase):
otherConnection.close()
cursor.execute("select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testRollbackOnDel(self):
"connection rolls back before destruction"
@ -100,7 +100,7 @@ class TestConnection(TestCase):
del otherConnection
cursor.execute("select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testThreading(self):
"connection to database with multiple threads"

82
test/Cursor.py
View File

@ -8,11 +8,11 @@ class TestCursor(BaseTestCase):
def testExecuteNoArgs(self):
"""test executing a statement without any arguments"""
result = self.cursor.execute("begin null; end;")
self.failUnlessEqual(result, None)
self.assertEqual(result, None)
def testExecuteNoStatementWithArgs(self):
"""test executing a None statement with bind variables"""
self.failUnlessRaises(cx_Oracle.ProgrammingError, self.cursor.execute,
self.assertRaises(cx_Oracle.ProgrammingError, self.cursor.execute,
None, x = 5)
def testExecuteEmptyKeywordArgs(self):
@ -21,59 +21,59 @@ class TestCursor(BaseTestCase):
args = [simpleVar]
kwArgs = {}
result = self.cursor.execute("begin :1 := 25; end;", args, **kwArgs)
self.failUnlessEqual(result, None)
self.failUnlessEqual(simpleVar.getvalue(), 25)
self.assertEqual(result, None)
self.assertEqual(simpleVar.getvalue(), 25)
def testExecuteKeywordArgs(self):
"""test executing a statement with keyword arguments"""
simpleVar = self.cursor.var(cx_Oracle.NUMBER)
result = self.cursor.execute("begin :value := 5; end;",
value = simpleVar)
self.failUnlessEqual(result, None)
self.failUnlessEqual(simpleVar.getvalue(), 5)
self.assertEqual(result, None)
self.assertEqual(simpleVar.getvalue(), 5)
def testExecuteDictionaryArg(self):
"""test executing a statement with a dictionary argument"""
simpleVar = self.cursor.var(cx_Oracle.NUMBER)
dictArg = { "value" : simpleVar }
result = self.cursor.execute("begin :value := 10; end;", dictArg)
self.failUnlessEqual(result, None)
self.failUnlessEqual(simpleVar.getvalue(), 10)
self.assertEqual(result, None)
self.assertEqual(simpleVar.getvalue(), 10)
def testExecuteMultipleMethod(self):
"""test executing a statement with both a dict arg and keyword args"""
simpleVar = self.cursor.var(cx_Oracle.NUMBER)
dictArg = { "value" : simpleVar }
self.failUnlessRaises(cx_Oracle.InterfaceError, self.cursor.execute,
self.assertRaises(cx_Oracle.InterfaceError, self.cursor.execute,
"begin :value := 15; end;", dictArg, value = simpleVar)
def testExecuteAndModifyArraySize(self):
"""test executing a statement and then changing the array size"""
self.cursor.execute("select IntCol from TestNumbers")
self.cursor.arraysize = 20
self.failUnlessEqual(len(self.cursor.fetchall()), 10)
self.assertEqual(len(self.cursor.fetchall()), 10)
def testCallProc(self):
"""test executing a stored procedure"""
var = self.cursor.var(cx_Oracle.NUMBER)
results = self.cursor.callproc("proc_Test", ("hi", 5, var))
self.failUnlessEqual(results, ["hi", 10, 2.0])
self.assertEqual(results, ["hi", 10, 2.0])
def testCallProcNoArgs(self):
"""test executing a stored procedure without any arguments"""
results = self.cursor.callproc("proc_TestNoArgs")
self.failUnlessEqual(results, [])
self.assertEqual(results, [])
def testCallFunc(self):
"""test executing a stored function"""
results = self.cursor.callfunc("func_Test", cx_Oracle.NUMBER,
("hi", 5))
self.failUnlessEqual(results, 7)
self.assertEqual(results, 7)
def testCallFuncNoArgs(self):
"""test executing a stored function without any arguments"""
results = self.cursor.callfunc("func_TestNoArgs", cx_Oracle.NUMBER)
self.failUnlessEqual(results, 712)
self.assertEqual(results, 712)
def testExecuteManyByName(self):
"""test executing a statement multiple times (named args)"""
@ -85,7 +85,7 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute("select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyByPosition(self):
"""test executing a statement multiple times (positional args)"""
@ -97,7 +97,7 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute("select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyWithPrepare(self):
"""test executing a statement multiple times (with prepare)"""
@ -110,7 +110,7 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute("select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyWithRebind(self):
"""test executing a statement multiple times (with rebind)"""
@ -123,7 +123,7 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute("select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyWithResize(self):
"""test executing a statement multiple times (with resize)"""
@ -142,8 +142,8 @@ class TestCursor(BaseTestCase):
var = self.cursor.bindvars[1]
self.cursor.execute("select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.failUnlessEqual(var.maxlength,
self.assertEqual(count, len(rows))
self.assertEqual(var.maxlength,
100 * self.connection.maxBytesPerCharacter)
def testExecuteManyWithExecption(self):
@ -151,29 +151,29 @@ class TestCursor(BaseTestCase):
self.cursor.execute("truncate table TestExecuteMany")
rows = [ { "value" : n } for n in (1, 2, 3, 2, 5) ]
statement = "insert into TestExecuteMany (IntCol) values (:value)"
self.failUnlessRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
self.assertRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
statement, rows)
self.failUnlessEqual(self.cursor.rowcount, 3)
self.assertEqual(self.cursor.rowcount, 3)
def testPrepare(self):
"""test preparing a statement and executing it multiple times"""
self.failUnlessEqual(self.cursor.statement, None)
self.assertEqual(self.cursor.statement, None)
statement = "begin :value := :value + 5; end;"
self.cursor.prepare(statement)
var = self.cursor.var(cx_Oracle.NUMBER)
self.failUnlessEqual(self.cursor.statement, statement)
self.assertEqual(self.cursor.statement, statement)
var.setvalue(0, 2)
self.cursor.execute(None, value = var)
self.failUnlessEqual(var.getvalue(), 7)
self.assertEqual(var.getvalue(), 7)
self.cursor.execute(None, value = var)
self.failUnlessEqual(var.getvalue(), 12)
self.assertEqual(var.getvalue(), 12)
self.cursor.execute("begin :value2 := 3; end;", value2 = var)
self.failUnlessEqual(var.getvalue(), 3)
self.assertEqual(var.getvalue(), 3)
def testExceptionOnClose(self):
"confirm an exception is raised after closing a cursor"
self.cursor.close()
self.failUnlessRaises(cx_Oracle.InterfaceError, self.cursor.execute,
self.assertRaises(cx_Oracle.InterfaceError, self.cursor.execute,
"select 1 from dual")
def testIterators(self):
@ -186,7 +186,7 @@ class TestCursor(BaseTestCase):
rows = []
for row in self.cursor:
rows.append(row[0])
self.failUnlessEqual(rows, [1, 2, 3])
self.assertEqual(rows, [1, 2, 3])
def testIteratorsInterrupted(self):
"""test iterators (with intermediate execute)"""
@ -203,42 +203,42 @@ class TestCursor(BaseTestCase):
value, = testIter.next()
self.cursor.execute("insert into TestExecuteMany (IntCol) values (1)")
if sys.version_info[0] >= 3:
self.failUnlessRaises(cx_Oracle.InterfaceError, next, testIter)
self.assertRaises(cx_Oracle.InterfaceError, next, testIter)
else:
self.failUnlessRaises(cx_Oracle.InterfaceError, testIter.next)
self.assertRaises(cx_Oracle.InterfaceError, testIter.next)
def testBindNames(self):
"""test that bindnames() works correctly."""
self.failUnlessRaises(cx_Oracle.ProgrammingError,
self.assertRaises(cx_Oracle.ProgrammingError,
self.cursor.bindnames)
self.cursor.prepare("begin null; end;")
self.failUnlessEqual(self.cursor.bindnames(), [])
self.assertEqual(self.cursor.bindnames(), [])
self.cursor.prepare("begin :retval := :inval + 5; end;")
self.failUnlessEqual(self.cursor.bindnames(), ["RETVAL", "INVAL"])
self.assertEqual(self.cursor.bindnames(), ["RETVAL", "INVAL"])
self.cursor.prepare("begin :retval := :a * :a + :b * :b; end;")
self.failUnlessEqual(self.cursor.bindnames(), ["RETVAL", "A", "B"])
self.assertEqual(self.cursor.bindnames(), ["RETVAL", "A", "B"])
self.cursor.prepare("begin :a := :b + :c + :d + :e + :f + :g + " + \
":h + :i + :j + :k + :l; end;")
self.failUnlessEqual(self.cursor.bindnames(),
self.assertEqual(self.cursor.bindnames(),
["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"])
def testBadPrepare(self):
"""test that subsequent executes succeed after bad prepare"""
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.execute,
"begin raise_application_error(-20000, 'this); end;")
self.cursor.execute("begin null; end;")
def testBadExecute(self):
"""test that subsequent fetches fail after bad execute"""
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.execute, "select y from dual")
self.failUnlessRaises(cx_Oracle.InterfaceError,
self.assertRaises(cx_Oracle.InterfaceError,
self.cursor.fetchall)
def testSetInputSizesMultipleMethod(self):
"""test setting input sizes with both positional and keyword args"""
self.failUnlessRaises(cx_Oracle.InterfaceError,
self.assertRaises(cx_Oracle.InterfaceError,
self.cursor.setinputsizes, 5, x = 5)
def testSetInputSizesByPosition(self):
@ -249,5 +249,5 @@ class TestCursor(BaseTestCase):
begin
:1 := :2 || to_char(:3) || :4 || to_char(:5) || to_char(:6);
end;""", [var, 'test_', 5, '_second_', 3, 7])
self.failUnlessEqual(var.getvalue(), "test_5_second_37")
self.assertEqual(var.getvalue(), "test_5_second_37")

18
test/CursorVar.py
View File

@ -8,25 +8,25 @@ class TestCursorVar(BaseTestCase):
def testBindCursor(self):
"test binding in a cursor"
cursor = self.connection.cursor()
self.failUnlessEqual(cursor.description, None)
self.assertEqual(cursor.description, None)
self.cursor.execute("""
begin
open :cursor for select 'X' StringValue from dual;
end;""",
cursor = cursor)
self.failUnlessEqual(cursor.description,
self.assertEqual(cursor.description,
[ ('STRINGVALUE', cx_Oracle.FIXED_CHAR, 1, 1, 0, 0, 1) ])
self.failUnlessEqual(cursor.fetchall(), [('X',)])
self.assertEqual(cursor.fetchall(), [('X',)])
def testBindCursorInPackage(self):
"test binding in a cursor from a package"
cursor = self.connection.cursor()
self.failUnlessEqual(cursor.description, None)
self.assertEqual(cursor.description, None)
self.cursor.callproc("pkg_TestOutCursors.TestOutCursor", (2, cursor))
self.failUnlessEqual(cursor.description,
self.assertEqual(cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('STRINGCOL', cx_Oracle.STRING, 20, 20, 0, 0, 0) ])
self.failUnlessEqual(cursor.fetchall(),
self.assertEqual(cursor.fetchall(),
[ (1, 'String 1'), (2, 'String 2') ])
def testFetchCursor(self):
@ -38,11 +38,11 @@ class TestCursorVar(BaseTestCase):
from TestNumbers
order by IntCol""")
size = struct.calcsize('P')
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('CURSORVALUE', cx_Oracle.CURSOR, -1, size, 0, 0, 1) ])
for i in range(1, 11):
number, cursor = self.cursor.fetchone()
self.failUnlessEqual(number, i)
self.failUnlessEqual(cursor.fetchall(), [(i + 1,)])
self.assertEqual(number, i)
self.assertEqual(cursor.fetchall(), [(i + 1,)])

50
test/DateTimeVar.py
View File

@ -29,7 +29,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = cx_Oracle.Timestamp(2002, 12, 13, 9, 36, 0))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[4]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[4]])
def testBindDateTime(self):
"test binding in a Python 2.3 and higher date time"
@ -37,7 +37,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = datetime.datetime(2002, 12, 13, 9, 36, 0))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[4]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[4]])
def testBindDateAfterString(self):
"test binding in a date after setting input sizes to a string"
@ -46,7 +46,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = cx_Oracle.Timestamp(2002, 12, 14, 12, 0, 0))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindNull(self):
"test binding in a null"
@ -55,7 +55,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindDateArrayDirect(self):
"test binding in a date array"
@ -71,13 +71,13 @@ class TestDateTimeVar(BaseTestCase):
startValue = 5,
baseDate = cx_Oracle.Date(2002, 12, 12),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 35.5)
self.assertEqual(returnValue.getvalue(), 35.5)
array = array + array[:5]
self.cursor.execute(statement,
startValue = 7,
baseDate = cx_Oracle.Date(2002, 12, 13),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 24.0)
self.assertEqual(returnValue.getvalue(), 24.0)
def testBindDateArrayBySizes(self):
"test binding in a date array (with setinputsizes)"
@ -93,7 +93,7 @@ class TestDateTimeVar(BaseTestCase):
startValue = 6,
baseDate = cx_Oracle.Date(2002, 12, 13),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 26.5)
self.assertEqual(returnValue.getvalue(), 26.5)
def testBindDateArrayByVar(self):
"test binding in a date array (with arrayvar)"
@ -109,7 +109,7 @@ class TestDateTimeVar(BaseTestCase):
startValue = 7,
baseDate = cx_Oracle.Date(2002, 12, 14),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 17.5)
self.assertEqual(returnValue.getvalue(), 17.5)
def testBindInOutDateArrayByVar(self):
"test binding in/out a date array (with arrayvar)"
@ -122,7 +122,7 @@ class TestDateTimeVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(),
self.assertEqual(array.getvalue(),
[ cx_Oracle.Timestamp(2002, 12, 17, 2, 24, 0),
cx_Oracle.Timestamp(2002, 12, 18, 4, 48, 0),
cx_Oracle.Timestamp(2002, 12, 19, 7, 12, 0),
@ -139,7 +139,7 @@ class TestDateTimeVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(),
self.assertEqual(array.getvalue(),
[ cx_Oracle.Timestamp(2002, 12, 13, 4, 48, 0),
cx_Oracle.Timestamp(2002, 12, 14, 9, 36, 0),
cx_Oracle.Timestamp(2002, 12, 15, 14, 24, 0),
@ -154,7 +154,7 @@ class TestDateTimeVar(BaseTestCase):
begin
:value := to_date(20021209, 'YYYYMMDD');
end;""")
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 9))
def testBindInOutSetInputSizes(self):
@ -165,7 +165,7 @@ class TestDateTimeVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = cx_Oracle.Timestamp(2002, 12, 12, 10, 0, 0))
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 17, 16, 0, 0))
def testBindOutVar(self):
@ -177,7 +177,7 @@ class TestDateTimeVar(BaseTestCase):
'YYYYMMDD HH24:MI:SS');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 31, 12, 31, 0))
def testBindInOutVarDirectSet(self):
@ -189,13 +189,13 @@ class TestDateTimeVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 14, 12, 0, 0))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestDates")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('DATECOL', cx_Oracle.DATETIME, 23, 7, 0, 0, 0),
('NULLABLECOL', cx_Oracle.DATETIME, 23, 7, 0, 0, 1) ])
@ -203,17 +203,17 @@ class TestDateTimeVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestDates order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestDates order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -222,7 +222,7 @@ class TestDateTimeVar(BaseTestCase):
from TestDates
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

36
test/IntervalVar.py
View File

@ -28,7 +28,7 @@ class TestIntervalVar(BaseTestCase):
where IntervalCol = :value""",
value = datetime.timedelta(days = 5, hours = 5, minutes = 10,
seconds = 15))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindNull(self):
"test binding in a null"
@ -37,7 +37,7 @@ class TestIntervalVar(BaseTestCase):
select * from TestIntervals
where IntervalCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizes(self):
"test binding out with set input sizes defined"
@ -46,7 +46,7 @@ class TestIntervalVar(BaseTestCase):
begin
:value := to_dsinterval('8 09:24:18.123789');
end;""")
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
datetime.timedelta(days = 8, hours = 9, minutes = 24,
seconds = 18, microseconds = 123789))
@ -58,7 +58,7 @@ class TestIntervalVar(BaseTestCase):
:value := :value + to_dsinterval('5 08:30:00');
end;""",
value = datetime.timedelta(days = 5, hours = 2, minutes = 15))
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
datetime.timedelta(days = 10, hours = 10, minutes = 45))
def testBindInOutFractionalSecond(self):
@ -69,7 +69,7 @@ class TestIntervalVar(BaseTestCase):
:value := :value + to_dsinterval('5 08:30:00');
end;""",
value = datetime.timedelta(days = 5, seconds=12.123789))
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
datetime.timedelta(days = 10, hours = 8, minutes = 30,
seconds=12, microseconds=123789))
@ -81,7 +81,7 @@ class TestIntervalVar(BaseTestCase):
:value := to_dsinterval('15 18:35:45.586');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
datetime.timedelta(days = 15, hours = 18, minutes = 35,
seconds = 45, milliseconds = 586))
@ -94,13 +94,13 @@ class TestIntervalVar(BaseTestCase):
:value := :value + to_dsinterval('8 05:15:00');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
datetime.timedelta(days = 9, hours = 6, minutes = 5))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestIntervals")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('INTERVALCOL', cx_Oracle.INTERVAL, -1, 11, 0, 0, 0),
('NULLABLECOL', cx_Oracle.INTERVAL, -1, 11, 0, 0, 1) ])
@ -108,17 +108,17 @@ class TestIntervalVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestIntervals order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestIntervals order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -127,7 +127,7 @@ class TestIntervalVar(BaseTestCase):
from TestIntervals
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

28
test/LobVar.py
View File

@ -38,11 +38,11 @@ class TestLobVar(BaseTestCase):
for row in self.cursor:
integerValue, lob = row
if integerValue == 0:
self.failUnlessEqual(lob.size(), 0)
self.assertEqual(lob.size(), 0)
expectedValue = ""
if type == "BLOB" and sys.version_info[0] >= 3:
expectedValue = expectedValue.encode("ascii")
self.failUnlessEqual(lob.read(), expectedValue)
self.assertEqual(lob.read(), expectedValue)
else:
char = chr(ord('A') + integerValue - 1)
prevChar = chr(ord('A') + integerValue - 2)
@ -53,15 +53,15 @@ class TestLobVar(BaseTestCase):
prevChar = prevChar.encode("ascii")
else:
actualValue = longString
self.failUnlessEqual(lob.size(), len(actualValue))
self.failUnlessEqual(lob.read(), actualValue)
self.assertEqual(lob.size(), len(actualValue))
self.assertEqual(lob.read(), actualValue)
if type == "CLOB":
self.failUnlessEqual(str(lob), actualValue)
self.failUnlessEqual(lob.read(len(actualValue)), char)
self.assertEqual(str(lob), actualValue)
self.assertEqual(lob.read(len(actualValue)), char)
if integerValue > 1:
offset = (integerValue - 1) * 25000 - 4
string = prevChar * 5 + char * 5
self.failUnlessEqual(lob.read(offset, 10), string)
self.assertEqual(lob.read(offset, 10), string)
def __TestTrim(self, type):
self.cursor.execute("truncate table Test%ss" % type)
@ -84,16 +84,16 @@ class TestLobVar(BaseTestCase):
from Test%ss
where IntCol = 1""" % (type, type))
lob, = self.cursor.fetchone()
self.failUnlessEqual(lob.size(), 75000)
self.assertEqual(lob.size(), 75000)
lob.trim(25000)
self.failUnlessEqual(lob.size(), 25000)
self.assertEqual(lob.size(), 25000)
lob.trim()
self.failUnlessEqual(lob.size(), 0)
self.assertEqual(lob.size(), 0)
def testBLOBCursorDescription(self):
"test cursor description is accurate for BLOBs"
self.cursor.execute("select * from TestBLOBs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('BLOBCOL', cx_Oracle.BLOB, -1, 4000, 0, 0, 0) ])
@ -112,7 +112,7 @@ class TestLobVar(BaseTestCase):
def testCLOBCursorDescription(self):
"test cursor description is accurate for CLOBs"
self.cursor.execute("select * from TestCLOBs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('CLOBCOL', cx_Oracle.CLOB, -1, 4000, 0, 0, 0) ])
@ -133,12 +133,12 @@ class TestLobVar(BaseTestCase):
self.cursor.arraysize = 1
self.cursor.execute("select CLOBCol from TestCLOBS")
rows = self.cursor.fetchall()
self.failUnlessRaises(cx_Oracle.ProgrammingError, rows[1][0].read)
self.assertRaises(cx_Oracle.ProgrammingError, rows[1][0].read)
def testNCLOBCursorDescription(self):
"test cursor description is accurate for NCLOBs"
self.cursor.execute("select * from TestNCLOBs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('NCLOBCOL', cx_Oracle.NCLOB, -1, 4000, 0, 0, 0) ])

22
test/LongVar.py
View File

@ -43,8 +43,8 @@ class TestLongVar(BaseTestCase):
actualValue = longString.encode("ascii")
else:
actualValue = longString
self.failUnlessEqual(len(fetchedValue), integerValue * 25000)
self.failUnlessEqual(fetchedValue, actualValue)
self.assertEqual(len(fetchedValue), integerValue * 25000)
self.assertEqual(fetchedValue, actualValue)
def testLongs(self):
"test binding and fetching long data"
@ -57,14 +57,14 @@ class TestLongVar(BaseTestCase):
def testLongCursorDescription(self):
"test cursor description is accurate for longs"
self.cursor.execute("select * from TestLongs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('LONGCOL', cx_Oracle.LONG_STRING, -1, 0, 0, 0, 0) ])
def testLongRawCursorDescription(self):
"test cursor description is accurate for long raws"
self.cursor.execute("select * from TestLongRaws")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('LONGRAWCOL', cx_Oracle.LONG_BINARY, -1, 0, 0, 0, 0) ])
@ -73,16 +73,16 @@ class TestLongVar(BaseTestCase):
self.cursor.setoutputsize(25000)
self.cursor.execute("select * from TestLongRaws")
longVar = self.cursor.fetchvars[1]
self.failUnlessEqual(longVar.size, 25000)
self.failUnlessEqual(longVar.bufferSize, 25004)
self.assertEqual(longVar.size, 25000)
self.assertEqual(longVar.bufferSize, 25004)
def testSetOutputSizesWrongColumn(self):
"test setoutputsizes is valid (wrong column)"
self.cursor.setoutputsize(25000, 1)
self.cursor.execute("select * from TestLongs")
longVar = self.cursor.fetchvars[1]
self.failUnlessEqual(longVar.size, 131072)
self.failUnlessEqual(longVar.bufferSize,
self.assertEqual(longVar.size, 131072)
self.assertEqual(longVar.bufferSize,
131072 * self.connection.maxBytesPerCharacter + 4)
def testSetOutputSizesRightColumn(self):
@ -90,12 +90,12 @@ class TestLongVar(BaseTestCase):
self.cursor.setoutputsize(35000, 2)
self.cursor.execute("select * from TestLongRaws")
longVar = self.cursor.fetchvars[1]
self.failUnlessEqual(longVar.size, 35000)
self.failUnlessEqual(longVar.bufferSize, 35004)
self.assertEqual(longVar.size, 35000)
self.assertEqual(longVar.bufferSize, 35004)
def testArraySizeTooLarge(self):
"test array size too large generates an exception"
self.cursor.arraysize = 65536
self.failUnlessRaises(ValueError, self.cursor.execute,
self.assertRaises(ValueError, self.cursor.execute,
"select * from TestLongRaws")

54
test/NCharVar.py
View File

@ -26,7 +26,7 @@ class TestNCharVar(BaseTestCase):
end;""",
value = u"InVal \u3042",
retval = returnValue)
self.failUnlessEqual(returnValue.getvalue(), 7)
self.assertEqual(returnValue.getvalue(), 7)
def testBindUnicode(self):
"test binding in a unicode"
@ -34,7 +34,7 @@ class TestNCharVar(BaseTestCase):
select * from TestUnicodes
where UnicodeCol = :value""",
value = u"Unicode \u3042 5")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindDifferentVar(self):
"test binding a different variable on second execution"
@ -42,10 +42,10 @@ class TestNCharVar(BaseTestCase):
retval_2 = self.cursor.var(cx_Oracle.NCHAR, 30)
self.cursor.execute(r"begin :retval := unistr('Called \3042'); end;",
retval = retval_1)
self.failUnlessEqual(retval_1.getvalue(), u"Called \u3042")
self.assertEqual(retval_1.getvalue(), u"Called \u3042")
self.cursor.execute("begin :retval := 'Called'; end;",
retval = retval_2)
self.failUnlessEqual(retval_2.getvalue(), "Called")
self.assertEqual(retval_2.getvalue(), "Called")
def testBindUnicodeAfterNumber(self):
"test binding in a unicode after setting input sizes to a number"
@ -54,7 +54,7 @@ class TestNCharVar(BaseTestCase):
select * from TestUnicodes
where UnicodeCol = :value""",
value = u"Unicode \u3042 6")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[6]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[6]])
def testBindUnicodeArrayDirect(self):
"test binding in a unicode array"
@ -69,12 +69,12 @@ class TestNCharVar(BaseTestCase):
retval = returnValue,
integerValue = 5,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 116)
self.assertEqual(returnValue.getvalue(), 116)
array = [ u"Unicode - \u3042 %d" % i for i in range(15) ]
self.cursor.execute(statement,
integerValue = 8,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 208)
self.assertEqual(returnValue.getvalue(), 208)
def testBindUnicodeArrayBySizes(self):
"test binding in a unicode array (with setinputsizes)"
@ -89,7 +89,7 @@ class TestNCharVar(BaseTestCase):
retval = returnValue,
integerValue = 6,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 117)
self.assertEqual(returnValue.getvalue(), 117)
def testBindUnicodeArrayByVar(self):
"test binding in a unicode array (with arrayvar)"
@ -104,7 +104,7 @@ class TestNCharVar(BaseTestCase):
retval = returnValue,
integerValue = 7,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 118)
self.assertEqual(returnValue.getvalue(), 118)
def testBindInOutUnicodeArrayByVar(self):
"test binding in/out a unicode array (with arrayvar)"
@ -120,7 +120,7 @@ class TestNCharVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutUnicodeArrayByVar(self):
"test binding out a unicode array (with arrayvar)"
@ -133,7 +133,7 @@ class TestNCharVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindNull(self):
"test binding in a null"
@ -141,7 +141,7 @@ class TestNCharVar(BaseTestCase):
select * from TestUnicodes
where UnicodeCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizesByType(self):
"test binding out with set input sizes defined (by type)"
@ -150,7 +150,7 @@ class TestNCharVar(BaseTestCase):
begin
:value := unistr('TSI \3042');
end;""")
self.failUnlessEqual(vars["value"].getvalue(), u"TSI \u3042")
self.assertEqual(vars["value"].getvalue(), u"TSI \u3042")
def testBindInOutSetInputSizesByType(self):
"test binding in/out with set input sizes defined (by type)"
@ -160,7 +160,7 @@ class TestNCharVar(BaseTestCase):
:value := :value || unistr(' TSI \3042');
end;""",
value = u"InVal \u3041")
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
u"InVal \u3041 TSI \u3042")
def testBindOutVar(self):
@ -171,7 +171,7 @@ class TestNCharVar(BaseTestCase):
:value := unistr('TSI (VAR) \3042');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), u"TSI (VAR) \u3042")
self.assertEqual(var.getvalue(), u"TSI (VAR) \u3042")
def testBindInOutVarDirectSet(self):
"test binding in/out with cursor.var() method"
@ -182,12 +182,12 @@ class TestNCharVar(BaseTestCase):
:value := :value || unistr(' TSI (VAR) \3042');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), u"InVal \u3041 TSI (VAR) \u3042")
self.assertEqual(var.getvalue(), u"InVal \u3041 TSI (VAR) \u3042")
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestUnicodes")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('UNICODECOL', cx_Oracle.NCHAR, 20, 40, 0, 0, 0),
('FIXEDUNICODECOL', cx_Oracle.FIXED_NCHAR, 40, 80, 0, 0, 0),
@ -196,17 +196,17 @@ class TestNCharVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestUnicodes order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestUnicodes order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -215,7 +215,7 @@ class TestNCharVar(BaseTestCase):
from TestUnicodes
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

64
test/NumberVar.py
View File

@ -28,7 +28,7 @@ class TestNumberVar(BaseTestCase):
where NumberCol - :value1 - :value2 = trunc(NumberCol)""",
value1 = decimal.Decimal("0.20"),
value2 = decimal.Decimal("0.05"))
self.failUnlessEqual(self.cursor.fetchall(),
self.assertEqual(self.cursor.fetchall(),
[self.dataByKey[1], self.dataByKey[5], self.dataByKey[9]])
def testBindFloat(self):
@ -37,7 +37,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where NumberCol - :value = trunc(NumberCol)""",
value = 0.25)
self.failUnlessEqual(self.cursor.fetchall(),
self.assertEqual(self.cursor.fetchall(),
[self.dataByKey[1], self.dataByKey[5], self.dataByKey[9]])
def testBindInteger(self):
@ -46,7 +46,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 2)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[2]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[2]])
def testBindSmallLong(self):
"test binding in a small long integer"
@ -54,7 +54,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 3L)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindLargeLong(self):
"test binding in a large long integer"
@ -66,7 +66,7 @@ class TestNumberVar(BaseTestCase):
end;""",
value = valueVar)
value = valueVar.getvalue()
self.failUnlessEqual(value, 6088343249)
self.assertEqual(value, 6088343249)
def testBindIntegerAfterString(self):
"test binding in an number after setting input sizes to a string"
@ -75,7 +75,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 3)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindNull(self):
"test binding in a null"
@ -83,7 +83,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindNumberArrayDirect(self):
"test binding in a number array"
@ -98,12 +98,12 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
startValue = 5,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 73.75)
self.assertEqual(returnValue.getvalue(), 73.75)
array = range(15)
self.cursor.execute(statement,
startValue = 10,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 115.0)
self.assertEqual(returnValue.getvalue(), 115.0)
def testBindNumberArrayBySizes(self):
"test binding in a number array (with setinputsizes)"
@ -118,7 +118,7 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
startValue = 6,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 74.75)
self.assertEqual(returnValue.getvalue(), 74.75)
def testBindNumberArrayByVar(self):
"test binding in a number array (with arrayvar)"
@ -134,7 +134,7 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
integerValue = 7,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 75.75)
self.assertEqual(returnValue.getvalue(), 75.75)
def testBindZeroLengthNumberArrayByVar(self):
"test binding in a zero length number array (with arrayvar)"
@ -148,8 +148,8 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
integerValue = 8,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 8.0)
self.failUnlessEqual(array.getvalue(), [])
self.assertEqual(returnValue.getvalue(), 8.0)
self.assertEqual(array.getvalue(), [])
def testBindInOutNumberArrayByVar(self):
"test binding in/out a number array (with arrayvar)"
@ -164,7 +164,7 @@ class TestNumberVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutNumberArrayByVar(self):
"test binding out a Number array (with arrayvar)"
@ -176,7 +176,7 @@ class TestNumberVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutSetInputSizes(self):
"test binding out with set input sizes defined"
@ -185,7 +185,7 @@ class TestNumberVar(BaseTestCase):
begin
:value := 5;
end;""")
self.failUnlessEqual(vars["value"].getvalue(), 5)
self.assertEqual(vars["value"].getvalue(), 5)
def testBindInOutSetInputSizes(self):
"test binding in/out with set input sizes defined"
@ -195,7 +195,7 @@ class TestNumberVar(BaseTestCase):
:value := :value + 5;
end;""",
value = 1.25)
self.failUnlessEqual(vars["value"].getvalue(), 6.25)
self.assertEqual(vars["value"].getvalue(), 6.25)
def testBindOutVar(self):
"test binding out with cursor.var() method"
@ -205,7 +205,7 @@ class TestNumberVar(BaseTestCase):
:value := 5;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), 5)
self.assertEqual(var.getvalue(), 5)
def testBindInOutVarDirectSet(self):
"test binding in/out with cursor.var() method"
@ -216,12 +216,12 @@ class TestNumberVar(BaseTestCase):
:value := :value + 5;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), 7.25)
self.assertEqual(var.getvalue(), 7.25)
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestNumbers")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('NUMBERCOL', cx_Oracle.NUMBER, 13, 22, 9, 2, 0),
('FLOATCOL', cx_Oracle.NUMBER, 127, 22, 126, -127, 0),
@ -231,17 +231,17 @@ class TestNumberVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestNumbers order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestNumbers order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -250,9 +250,9 @@ class TestNumberVar(BaseTestCase):
from TestNumbers
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)
def testReturnAsLong(self):
"test that fetching a long integer returns such in Python"
@ -261,11 +261,11 @@ class TestNumberVar(BaseTestCase):
from TestNumbers
where IntCol = 9""")
col, = self.cursor.fetchone()
self.failUnless(isinstance(col, long), "long integer not returned")
self.assertTrue(isinstance(col, long), "long integer not returned")
def testReturnAsFloat(self):
"test that fetching a floating point number returns such in Python"
self.cursor.execute("select 1.25 from dual")
result, = self.cursor.fetchone()
self.failUnlessEqual(result, 1.25)
self.assertEqual(result, 1.25)

14
test/ObjectVar.py
View File

@ -13,9 +13,9 @@ class TestObjectVar(BaseTestCase):
value = getattr(objectValue, attribute.name)
attributeValues.append(value)
objectValue = tuple(attributeValues)
self.failUnlessEqual(intValue, expectedIntValue)
self.failUnlessEqual(objectValue, expectedObjectValue)
self.failUnlessEqual(arrayValue, expectedArrayValue)
self.assertEqual(intValue, expectedIntValue)
self.assertEqual(objectValue, expectedObjectValue)
self.assertEqual(arrayValue, expectedArrayValue)
def testFetchData(self):
"test fetching objects"
@ -26,7 +26,7 @@ class TestObjectVar(BaseTestCase):
ArrayCol
from TestObjects
order by IntCol""")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('OBJECTCOL', cx_Oracle.OBJECT, -1, 2000, 0, 0, 1),
('ARRAYCOL', cx_Oracle.OBJECT, -1, 2000, 0, 0, 1) ])
@ -46,8 +46,8 @@ class TestObjectVar(BaseTestCase):
where ObjectCol is not null
and rownum <= 1""")
objValue, = self.cursor.fetchone()
self.failUnlessEqual(objValue.type.schema,
self.assertEqual(objValue.type.schema,
self.connection.username.upper())
self.failUnlessEqual(objValue.type.name, "UDT_OBJECT")
self.failUnlessEqual(objValue.type.attributes[0].name, "NUMBERVALUE")
self.assertEqual(objValue.type.name, "UDT_OBJECT")
self.assertEqual(objValue.type.attributes[0].name, "NUMBERVALUE")

44
test/SessionPool.py
View File

@ -10,49 +10,49 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute("select count(*) from TestNumbers")
count, = cursor.fetchone()
self.failUnlessEqual(count, 10)
self.assertEqual(count, 10)
def __ConnectAndGenerateError(self):
"""Connect to the database, perform a query which raises an error"""
connection = self.pool.acquire()
cursor = connection.cursor()
self.failUnlessRaises(cx_Oracle.DatabaseError, cursor.execute,
self.assertRaises(cx_Oracle.DatabaseError, cursor.execute,
"select 1 / 0 from dual")
def testPool(self):
"""test that the pool is created and has the right attributes"""
pool = cx_Oracle.SessionPool(USERNAME, PASSWORD, TNSENTRY, 2, 8, 3)
self.failUnlessEqual(pool.username, USERNAME, "user name differs")
self.failUnlessEqual(pool.tnsentry, TNSENTRY, "tnsentry differs")
self.failUnlessEqual(pool.max, 8, "max differs")
self.failUnlessEqual(pool.min, 2, "min differs")
self.failUnlessEqual(pool.increment, 3, "increment differs")
self.failUnlessEqual(pool.opened, 2, "opened differs")
self.failUnlessEqual(pool.busy, 0, "busy not 0 at start")
self.assertEqual(pool.username, USERNAME, "user name differs")
self.assertEqual(pool.tnsentry, TNSENTRY, "tnsentry 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.failUnlessEqual(pool.busy, 1, "busy not 1 after acquire")
self.failUnlessEqual(pool.opened, 2, "opened not unchanged (1)")
self.assertEqual(pool.busy, 1, "busy not 1 after acquire")
self.assertEqual(pool.opened, 2, "opened not unchanged (1)")
connection_2 = pool.acquire()
self.failUnlessEqual(pool.busy, 2, "busy not 2 after acquire")
self.failUnlessEqual(pool.opened, 2, "opened not unchanged (2)")
self.assertEqual(pool.busy, 2, "busy not 2 after acquire")
self.assertEqual(pool.opened, 2, "opened not unchanged (2)")
connection_3 = pool.acquire()
self.failUnlessEqual(pool.busy, 3, "busy not 3 after acquire")
self.failUnlessEqual(pool.opened, 5, "opened not changed (3)")
self.assertEqual(pool.busy, 3, "busy not 3 after acquire")
self.assertEqual(pool.opened, 5, "opened not changed (3)")
pool.release(connection_3)
self.failUnlessEqual(pool.busy, 2, "busy not 2 after release")
self.assertEqual(pool.busy, 2, "busy not 2 after release")
del connection_2
self.failUnlessEqual(pool.busy, 1, "busy not 1 after del")
self.assertEqual(pool.busy, 1, "busy not 1 after del")
def testProxyAuth(self):
"""test that proxy authentication is possible"""
pool = cx_Oracle.SessionPool(USERNAME, PASSWORD, TNSENTRY, 2, 8, 3)
self.failUnlessEqual(pool.homogeneous, 1,
self.assertEqual(pool.homogeneous, 1,
"homogeneous should be 1 by default")
self.failUnlessRaises(cx_Oracle.ProgrammingError, pool.acquire,
self.assertRaises(cx_Oracle.ProgrammingError, pool.acquire,
user = "proxyuser")
pool = cx_Oracle.SessionPool(USERNAME, PASSWORD, TNSENTRY, 2, 8, 3,
homogeneous = False)
self.failUnlessEqual(pool.homogeneous, 0,
self.assertEqual(pool.homogeneous, 0,
"homogeneous should be 0 after setting it in the constructor")
user = "%s_proxy" % USERNAME
connection = pool.acquire(user = user)
@ -73,7 +73,7 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute("select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testRollbackOnRelease(self):
"connection rolls back before released back to the pool"
@ -88,7 +88,7 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute("select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testThreading(self):
"""test session pool to database with multiple threads"""

62
test/StringVar.py
View File

@ -24,7 +24,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = "String 5")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindDifferentVar(self):
"test binding a different variable on second execution"
@ -32,10 +32,10 @@ class TestStringVar(BaseTestCase):
retval_2 = self.cursor.var(cx_Oracle.STRING, 30)
self.cursor.execute("begin :retval := 'Called'; end;",
retval = retval_1)
self.failUnlessEqual(retval_1.getvalue(), "Called")
self.assertEqual(retval_1.getvalue(), "Called")
self.cursor.execute("begin :retval := 'Called'; end;",
retval = retval_2)
self.failUnlessEqual(retval_2.getvalue(), "Called")
self.assertEqual(retval_2.getvalue(), "Called")
def testBindStringAfterNumber(self):
"test binding in a string after setting input sizes to a number"
@ -44,7 +44,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = "String 6")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[6]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[6]])
def testBindStringArrayDirect(self):
"test binding in a string array"
@ -59,12 +59,12 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 5,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 86)
self.assertEqual(returnValue.getvalue(), 86)
array = [ "String - %d" % i for i in range(15) ]
self.cursor.execute(statement,
integerValue = 8,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 163)
self.assertEqual(returnValue.getvalue(), 163)
def testBindStringArrayBySizes(self):
"test binding in a string array (with setinputsizes)"
@ -79,7 +79,7 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 6,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 87)
self.assertEqual(returnValue.getvalue(), 87)
def testBindStringArrayByVar(self):
"test binding in a string array (with arrayvar)"
@ -94,7 +94,7 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 7,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 88)
self.assertEqual(returnValue.getvalue(), 88)
def testBindInOutStringArrayByVar(self):
"test binding in/out a string array (with arrayvar)"
@ -110,7 +110,7 @@ class TestStringVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutStringArrayByVar(self):
"test binding out a string array (with arrayvar)"
@ -122,7 +122,7 @@ class TestStringVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindRaw(self):
"test binding in a raw"
@ -131,7 +131,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where RawCol = :value""",
value = "Raw 4")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[4]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[4]])
def testBindAndFetchRowid(self):
"test binding (and fetching) a rowid"
@ -145,7 +145,7 @@ class TestStringVar(BaseTestCase):
from TestStrings
where rowid = :value""",
value = rowid)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindNull(self):
"test binding in a null"
@ -153,7 +153,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizesByType(self):
"test binding out with set input sizes defined (by type)"
@ -162,7 +162,7 @@ class TestStringVar(BaseTestCase):
begin
:value := 'TSI';
end;""")
self.failUnlessEqual(vars["value"].getvalue(), "TSI")
self.assertEqual(vars["value"].getvalue(), "TSI")
def testBindOutSetInputSizesByInteger(self):
"test binding out with set input sizes defined (by integer)"
@ -171,7 +171,7 @@ class TestStringVar(BaseTestCase):
begin
:value := 'TSI (I)';
end;""")
self.failUnlessEqual(vars["value"].getvalue(), "TSI (I)")
self.assertEqual(vars["value"].getvalue(), "TSI (I)")
def testBindInOutSetInputSizesByType(self):
"test binding in/out with set input sizes defined (by type)"
@ -181,7 +181,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI';
end;""",
value = "InVal")
self.failUnlessEqual(vars["value"].getvalue(), "InVal TSI")
self.assertEqual(vars["value"].getvalue(), "InVal TSI")
def testBindInOutSetInputSizesByInteger(self):
"test binding in/out with set input sizes defined (by integer)"
@ -191,7 +191,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI (I)';
end;""",
value = "InVal")
self.failUnlessEqual(vars["value"].getvalue(), "InVal TSI (I)")
self.assertEqual(vars["value"].getvalue(), "InVal TSI (I)")
def testBindOutVar(self):
"test binding out with cursor.var() method"
@ -201,7 +201,7 @@ class TestStringVar(BaseTestCase):
:value := 'TSI (VAR)';
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), "TSI (VAR)")
self.assertEqual(var.getvalue(), "TSI (VAR)")
def testBindInOutVarDirectSet(self):
"test binding in/out with cursor.var() method"
@ -212,7 +212,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI (VAR)';
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), "InVal TSI (VAR)")
self.assertEqual(var.getvalue(), "InVal TSI (VAR)")
def testBindLongString(self):
"test that binding a long string succeeds"
@ -231,14 +231,14 @@ class TestStringVar(BaseTestCase):
inString = "1234567890" * 9000
var.setvalue(0, inString)
outString = var.getvalue()
self.failUnlessEqual(inString, outString,
self.assertEqual(inString, outString,
"output does not match: in was %d, out was %d" % \
(len(inString), len(outString)))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestStrings")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('STRINGCOL', cx_Oracle.STRING, 20, 20, 0, 0, 0),
('RAWCOL', cx_Oracle.BINARY, 30, 30, 0, 0, 0),
@ -248,17 +248,17 @@ class TestStringVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestStrings order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestStrings order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -267,7 +267,7 @@ class TestStringVar(BaseTestCase):
from TestStrings
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

34
test/TimestampVar.py
View File

@ -38,7 +38,7 @@ class TestTimestampVar(BaseTestCase):
select * from TestTimestamps
where TimestampCol = :value""",
value = cx_Oracle.Timestamp(2002, 12, 14, 0, 0, 10, 250000))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindNull(self):
"test binding in a null"
@ -47,7 +47,7 @@ class TestTimestampVar(BaseTestCase):
select * from TestTimestamps
where TimestampCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizes(self):
"test binding out with set input sizes defined"
@ -56,7 +56,7 @@ class TestTimestampVar(BaseTestCase):
begin
:value := to_timestamp('20021209', 'YYYYMMDD');
end;""")
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 9))
def testBindInOutSetInputSizes(self):
@ -67,7 +67,7 @@ class TestTimestampVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = cx_Oracle.Timestamp(2002, 12, 12, 10, 0, 0))
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 17, 16, 0, 0))
def testBindOutVar(self):
@ -79,7 +79,7 @@ class TestTimestampVar(BaseTestCase):
'YYYYMMDD HH24:MI:SS');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 31, 12, 31, 0))
def testBindInOutVarDirectSet(self):
@ -91,13 +91,13 @@ class TestTimestampVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 14, 12, 0, 0))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute("select * from TestTimestamps")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('TIMESTAMPCOL', cx_Oracle.TIMESTAMP, -1, 11, 0, 0, 0),
('NULLABLECOL', cx_Oracle.TIMESTAMP, -1, 11, 0, 0, 1) ])
@ -105,17 +105,17 @@ class TestTimestampVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute("select * From TestTimestamps order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute("select * From TestTimestamps order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -124,7 +124,7 @@ class TestTimestampVar(BaseTestCase):
from TestTimestamps
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

30
test/uArrayDMLBatchError.py
View File

@ -9,12 +9,12 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, u"Second") ]
sql = u"insert into TestArrayDML (IntCol,StringCol) values (:1,:2)"
self.cursor.executemany(sql, rows, arraydmlrowcounts = False)
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.getarraydmlrowcounts)
rows = [ (3, u"Third"),
(4, u"Fourth") ]
self.cursor.executemany(sql, rows)
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.getarraydmlrowcounts)
def testArrayDMLRowCountsOn(self):
@ -29,11 +29,11 @@ class TestArrayDMLBatchError(BaseTestCase):
u"values (:1,:2,:3)"
self.cursor.executemany(sql, rows, arraydmlrowcounts = True)
self.connection.commit()
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 1L, 1L, 1L, 1L])
self.cursor.execute(u"select count(*) from TestArrayDML")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExceptionInIteration(self):
"test executing with arraydmlrowcounts with exception"
@ -43,9 +43,9 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, u"Third"),
(4, u"Fourth") ]
sql = u"insert into TestArrayDML (IntCol,StringCol) values (:1,:2)"
self.failUnlessRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
self.assertRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
sql, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(), [1L, 1L])
self.assertEqual(self.cursor.getarraydmlrowcounts(), [1L, 1L])
def testExecutingDelete(self):
"test executing delete statement with arraydmlrowcount mode"
@ -64,7 +64,7 @@ class TestArrayDMLBatchError(BaseTestCase):
rows = [ (200,), (300,), (400,) ]
statement = u"delete from TestArrayDML where IntCol2 = :1"
self.cursor.executemany(statement, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(), [1L, 3L, 2L])
self.assertEqual(self.cursor.getarraydmlrowcounts(), [1L, 3L, 2L])
def testExecutingUpdate(self):
"test executing update statement with arraydmlrowcount mode"
@ -86,7 +86,7 @@ class TestArrayDMLBatchError(BaseTestCase):
(u"Four", 400) ]
sql = u"update TestArrayDML set StringCol = :1 where IntCol2 = :2"
self.cursor.executemany(sql, rows, arraydmlrowcounts = True)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 1L, 3L, 2L])
def testInsertWithBatchError(self):
@ -109,8 +109,8 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(actualErrors, expectedErrors)
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 1L, 0L, 1L, 0L])
def testBatchErrorFalse(self):
@ -121,7 +121,7 @@ class TestArrayDMLBatchError(BaseTestCase):
(2, u"Third", 300) ]
sql = u"insert into TestArrayDML (IntCol, StringCol, IntCol2) " \
u"values (:1, :2, :3)"
self.failUnlessRaises(cx_Oracle.IntegrityError,
self.assertRaises(cx_Oracle.IntegrityError,
self.cursor.executemany, sql, rows, batcherrors = False)
def testUpdatewithBatchError(self):
@ -144,7 +144,7 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.assertEqual(actualErrors, expectedErrors)
rows = [ (101, u"First"),
(201, u"Second"),
(3000, u"Third"),
@ -159,8 +159,8 @@ class TestArrayDMLBatchError(BaseTestCase):
]
actualErrors = [(e.offset, e.code, e.message) \
for e in self.cursor.getbatcherrors()]
self.failUnlessEqual(actualErrors, expectedErrors)
self.failUnlessEqual(self.cursor.getarraydmlrowcounts(),
self.assertEqual(actualErrors, expectedErrors)
self.assertEqual(self.cursor.getarraydmlrowcounts(),
[1L, 2L, 0L, 0L, 1L])
self.failUnlessEqual(self.cursor.rowcount, 4)
self.assertEqual(self.cursor.rowcount, 4)

24
test/uConnection.py
View File

@ -11,7 +11,7 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute(u"select count(*) from TestNumbers")
count, = cursor.fetchone()
self.failUnlessEqual(count, 10)
self.assertEqual(count, 10)
def setUp(self):
self.username = USERNAME
@ -19,9 +19,9 @@ class TestConnection(TestCase):
self.tnsentry = TNSENTRY
def verifyArgs(self, connection):
self.failUnlessEqual(connection.username, self.username,
self.assertEqual(connection.username, self.username,
"user name differs")
self.failUnlessEqual(connection.tnsentry, self.tnsentry,
self.assertEqual(connection.tnsentry, self.tnsentry,
"tnsentry differs")
def testAllArgs(self):
@ -32,16 +32,16 @@ class TestConnection(TestCase):
def testBadConnectString(self):
"connection to database with bad connect string"
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username)
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username + u"@" + self.tnsentry)
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username + u"@" + self.tnsentry + u"/" + self.password)
def testBadPassword(self):
"connection to database with bad password"
self.failUnlessRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.assertRaises(cx_Oracle.DatabaseError, cx_Oracle.connect,
self.username, self.password + u"X", self.tnsentry)
def testExceptionOnClose(self):
@ -49,7 +49,7 @@ class TestConnection(TestCase):
connection = cx_Oracle.connect(self.username, self.password,
self.tnsentry)
connection.close()
self.failUnlessRaises(cx_Oracle.InterfaceError, connection.rollback)
self.assertRaises(cx_Oracle.InterfaceError, connection.rollback)
def testMakeDSN(self):
"test making a data source name from host, port and sid"
@ -57,7 +57,7 @@ class TestConnection(TestCase):
u"(PROTOCOL=TCP)(HOST=%s)(PORT=%d)))(CONNECT_DATA=(SID=%s)))"
args = (u"hostname", 1521, u"TEST")
result = cx_Oracle.makedsn(*args)
self.failUnlessEqual(result, formatString % args)
self.assertEqual(result, formatString % args)
def testSingleArg(self):
"connection to database with user, password, TNS together"
@ -69,7 +69,7 @@ class TestConnection(TestCase):
"connection version is a string"
connection = cx_Oracle.connect(self.username, self.password,
self.tnsentry)
self.failUnless(isinstance(connection.version, str))
self.assertTrue(isinstance(connection.version, str))
def testRollbackOnClose(self):
"connection rolls back before close"
@ -84,7 +84,7 @@ class TestConnection(TestCase):
otherConnection.close()
cursor.execute(u"select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testRollbackOnDel(self):
"connection rolls back before destruction"
@ -100,7 +100,7 @@ class TestConnection(TestCase):
del otherConnection
cursor.execute(u"select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testThreading(self):
"connection to database with multiple threads"

76
test/uCursor.py
View File

@ -7,11 +7,11 @@ class TestCursor(BaseTestCase):
def testExecuteNoArgs(self):
"""test executing a statement without any arguments"""
result = self.cursor.execute(u"begin null; end;")
self.failUnlessEqual(result, None)
self.assertEqual(result, None)
def testExecuteNoStatementWithArgs(self):
"""test executing a None statement with bind variables"""
self.failUnlessRaises(cx_Oracle.ProgrammingError, self.cursor.execute,
self.assertRaises(cx_Oracle.ProgrammingError, self.cursor.execute,
None, x = 5)
def testExecuteEmptyKeywordArgs(self):
@ -20,59 +20,59 @@ class TestCursor(BaseTestCase):
args = [simpleVar]
kwArgs = {}
result = self.cursor.execute(u"begin :1 := 25; end;", args, **kwArgs)
self.failUnlessEqual(result, None)
self.failUnlessEqual(simpleVar.getvalue(), 25)
self.assertEqual(result, None)
self.assertEqual(simpleVar.getvalue(), 25)
def testExecuteKeywordArgs(self):
"""test executing a statement with keyword arguments"""
simpleVar = self.cursor.var(cx_Oracle.NUMBER)
result = self.cursor.execute(u"begin :value := 5; end;",
value = simpleVar)
self.failUnlessEqual(result, None)
self.failUnlessEqual(simpleVar.getvalue(), 5)
self.assertEqual(result, None)
self.assertEqual(simpleVar.getvalue(), 5)
def testExecuteDictionaryArg(self):
"""test executing a statement with a dictionary argument"""
simpleVar = self.cursor.var(cx_Oracle.NUMBER)
dictArg = { u"value" : simpleVar }
result = self.cursor.execute(u"begin :value := 10; end;", dictArg)
self.failUnlessEqual(result, None)
self.failUnlessEqual(simpleVar.getvalue(), 10)
self.assertEqual(result, None)
self.assertEqual(simpleVar.getvalue(), 10)
def testExecuteMultipleMethod(self):
"""test executing a statement with both a dict arg and keyword args"""
simpleVar = self.cursor.var(cx_Oracle.NUMBER)
dictArg = { u"value" : simpleVar }
self.failUnlessRaises(cx_Oracle.InterfaceError, self.cursor.execute,
self.assertRaises(cx_Oracle.InterfaceError, self.cursor.execute,
u"begin :value := 15; end;", dictArg, value = simpleVar)
def testExecuteAndModifyArraySize(self):
"""test executing a statement and then changing the array size"""
self.cursor.execute(u"select IntCol from TestNumbers")
self.cursor.arraysize = 20
self.failUnlessEqual(len(self.cursor.fetchall()), 10)
self.assertEqual(len(self.cursor.fetchall()), 10)
def testCallProc(self):
"""test executing a stored procedure"""
var = self.cursor.var(cx_Oracle.NUMBER)
results = self.cursor.callproc(u"proc_Test", (u"hi", 5, var))
self.failUnlessEqual(results, [u"hi", 10, 2.0])
self.assertEqual(results, [u"hi", 10, 2.0])
def testCallProcNoArgs(self):
"""test executing a stored procedure without any arguments"""
results = self.cursor.callproc(u"proc_TestNoArgs")
self.failUnlessEqual(results, [])
self.assertEqual(results, [])
def testCallFunc(self):
"""test executing a stored function"""
results = self.cursor.callfunc(u"func_Test", cx_Oracle.NUMBER,
(u"hi", 5))
self.failUnlessEqual(results, 7)
self.assertEqual(results, 7)
def testCallFuncNoArgs(self):
"""test executing a stored function without any arguments"""
results = self.cursor.callfunc(u"func_TestNoArgs", cx_Oracle.NUMBER)
self.failUnlessEqual(results, 712)
self.assertEqual(results, 712)
def testExecuteManyByName(self):
"""test executing a statement multiple times (named args)"""
@ -84,7 +84,7 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute(u"select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyByPosition(self):
"""test executing a statement multiple times (positional args)"""
@ -96,7 +96,7 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute(u"select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyWithPrepare(self):
"""test executing a statement multiple times (with prepare)"""
@ -109,7 +109,7 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute(u"select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyWithRebind(self):
"""test executing a statement multiple times (with rebind)"""
@ -122,36 +122,36 @@ class TestCursor(BaseTestCase):
self.connection.commit()
self.cursor.execute(u"select count(*) from TestExecuteMany")
count, = self.cursor.fetchone()
self.failUnlessEqual(count, len(rows))
self.assertEqual(count, len(rows))
def testExecuteManyWithExecption(self):
"""test executing a statement multiple times (with exception)"""
self.cursor.execute(u"truncate table TestExecuteMany")
rows = [ { u"value" : n } for n in (1, 2, 3, 2, 5) ]
statement = u"insert into TestExecuteMany (IntCol) values (:value)"
self.failUnlessRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
self.assertRaises(cx_Oracle.DatabaseError, self.cursor.executemany,
statement, rows)
self.failUnlessEqual(self.cursor.rowcount, 3)
self.assertEqual(self.cursor.rowcount, 3)
def testPrepare(self):
"""test preparing a statement and executing it multiple times"""
self.failUnlessEqual(self.cursor.statement, None)
self.assertEqual(self.cursor.statement, None)
statement = u"begin :value := :value + 5; end;"
self.cursor.prepare(statement)
var = self.cursor.var(cx_Oracle.NUMBER)
self.failUnlessEqual(self.cursor.statement, statement)
self.assertEqual(self.cursor.statement, statement)
var.setvalue(0, 2)
self.cursor.execute(None, value = var)
self.failUnlessEqual(var.getvalue(), 7)
self.assertEqual(var.getvalue(), 7)
self.cursor.execute(None, value = var)
self.failUnlessEqual(var.getvalue(), 12)
self.assertEqual(var.getvalue(), 12)
self.cursor.execute(u"begin :value2 := 3; end;", value2 = var)
self.failUnlessEqual(var.getvalue(), 3)
self.assertEqual(var.getvalue(), 3)
def testExceptionOnClose(self):
"confirm an exception is raised after closing a cursor"
self.cursor.close()
self.failUnlessRaises(cx_Oracle.InterfaceError, self.cursor.execute,
self.assertRaises(cx_Oracle.InterfaceError, self.cursor.execute,
u"select 1 from dual")
def testIterators(self):
@ -164,7 +164,7 @@ class TestCursor(BaseTestCase):
rows = []
for row in self.cursor:
rows.append(row[0])
self.failUnlessEqual(rows, [1, 2, 3])
self.assertEqual(rows, [1, 2, 3])
def testIteratorsInterrupted(self):
"""test iterators (with intermediate execute)"""
@ -177,41 +177,41 @@ class TestCursor(BaseTestCase):
testIter = iter(self.cursor)
value, = testIter.next()
self.cursor.execute(u"insert into TestExecuteMany (IntCol) values (1)")
self.failUnlessRaises(cx_Oracle.InterfaceError, testIter.next)
self.assertRaises(cx_Oracle.InterfaceError, testIter.next)
def testBindNames(self):
"""test that bindnames() works correctly."""
self.failUnlessRaises(cx_Oracle.ProgrammingError,
self.assertRaises(cx_Oracle.ProgrammingError,
self.cursor.bindnames)
self.cursor.prepare(u"begin null; end;")
self.failUnlessEqual(self.cursor.bindnames(), [])
self.assertEqual(self.cursor.bindnames(), [])
self.cursor.prepare(u"begin :retval := :inval + 5; end;")
self.failUnlessEqual(self.cursor.bindnames(), ["RETVAL", "INVAL"])
self.assertEqual(self.cursor.bindnames(), ["RETVAL", "INVAL"])
self.cursor.prepare(u"begin :retval := :a * :a + :b * :b; end;")
self.failUnlessEqual(self.cursor.bindnames(), ["RETVAL", "A", "B"])
self.assertEqual(self.cursor.bindnames(), ["RETVAL", "A", "B"])
self.cursor.prepare(u"begin :a := :b + :c + :d + :e + :f + :g + " + \
":h + :i + :j + :k + :l; end;")
self.failUnlessEqual(self.cursor.bindnames(),
self.assertEqual(self.cursor.bindnames(),
[u"A", u"B", u"C", u"D", u"E", u"F", u"G", u"H", u"I", u"J",
u"K", u"L"])
def testBadPrepare(self):
"""test that subsequent executes succeed after bad prepare"""
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.execute,
u"begin raise_application_error(-20000, 'this); end;")
self.cursor.execute(u"begin null; end;")
def testBadExecute(self):
"""test that subsequent fetches fail after bad execute"""
self.failUnlessRaises(cx_Oracle.DatabaseError,
self.assertRaises(cx_Oracle.DatabaseError,
self.cursor.execute, u"select y from dual")
self.failUnlessRaises(cx_Oracle.InterfaceError,
self.assertRaises(cx_Oracle.InterfaceError,
self.cursor.fetchall)
def testSetInputSizesMultipleMethod(self):
"""test setting input sizes with both positional and keyword args"""
self.failUnlessRaises(cx_Oracle.InterfaceError,
self.assertRaises(cx_Oracle.InterfaceError,
self.cursor.setinputsizes, 5, x = 5)
def testSetInputSizesByPosition(self):
@ -222,5 +222,5 @@ class TestCursor(BaseTestCase):
begin
:1 := :2 || to_char(:3) || :4 || to_char(:5) || to_char(:6);
end;""", [var, u'test_', 5, u'_second_', 3, 7])
self.failUnlessEqual(var.getvalue(), u"test_5_second_37")
self.assertEqual(var.getvalue(), u"test_5_second_37")

18
test/uCursorVar.py
View File

@ -8,25 +8,25 @@ class TestCursorVar(BaseTestCase):
def testBindCursor(self):
"test binding in a cursor"
cursor = self.connection.cursor()
self.failUnlessEqual(cursor.description, None)
self.assertEqual(cursor.description, None)
self.cursor.execute(u"""
begin
open :cursor for select 'X' StringValue from dual;
end;""",
cursor = cursor)
self.failUnlessEqual(cursor.description,
self.assertEqual(cursor.description,
[ ('STRINGVALUE', cx_Oracle.FIXED_CHAR, 1, 1, 0, 0, 1) ])
self.failUnlessEqual(cursor.fetchall(), [('X',)])
self.assertEqual(cursor.fetchall(), [('X',)])
def testBindCursorInPackage(self):
"test binding in a cursor from a package"
cursor = self.connection.cursor()
self.failUnlessEqual(cursor.description, None)
self.assertEqual(cursor.description, None)
self.cursor.callproc(u"pkg_TestOutCursors.TestOutCursor", (2, cursor))
self.failUnlessEqual(cursor.description,
self.assertEqual(cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('STRINGCOL', cx_Oracle.STRING, 20, 20, 0, 0, 0) ])
self.failUnlessEqual(cursor.fetchall(),
self.assertEqual(cursor.fetchall(),
[ (1, 'String 1'), (2, 'String 2') ])
def testFetchCursor(self):
@ -38,11 +38,11 @@ class TestCursorVar(BaseTestCase):
from TestNumbers
order by IntCol""")
size = struct.calcsize('P')
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'CURSORVALUE', cx_Oracle.CURSOR, -1, size, 0, 0, 1) ])
for i in range(1, 11):
number, cursor = self.cursor.fetchone()
self.failUnlessEqual(number, i)
self.failUnlessEqual(cursor.fetchall(), [(i + 1,)])
self.assertEqual(number, i)
self.assertEqual(cursor.fetchall(), [(i + 1,)])

50
test/uDateTimeVar.py
View File

@ -29,7 +29,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = cx_Oracle.Timestamp(2002, 12, 13, 9, 36, 0))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[4]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[4]])
def testBindDateTime(self):
"test binding in a Python 2.3 and higher date time"
@ -37,7 +37,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = datetime.datetime(2002, 12, 13, 9, 36, 0))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[4]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[4]])
def testBindDateAfterString(self):
"test binding in a date after setting input sizes to a string"
@ -46,7 +46,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = cx_Oracle.Timestamp(2002, 12, 14, 12, 0, 0))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindNull(self):
"test binding in a null"
@ -55,7 +55,7 @@ class TestDateTimeVar(BaseTestCase):
select * from TestDates
where DateCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindDateArrayDirect(self):
"test binding in a date array"
@ -71,13 +71,13 @@ class TestDateTimeVar(BaseTestCase):
startValue = 5,
baseDate = cx_Oracle.Date(2002, 12, 12),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 35.5)
self.assertEqual(returnValue.getvalue(), 35.5)
array = array + array[:5]
self.cursor.execute(statement,
startValue = 7,
baseDate = cx_Oracle.Date(2002, 12, 13),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 24.0)
self.assertEqual(returnValue.getvalue(), 24.0)
def testBindDateArrayBySizes(self):
"test binding in a date array (with setinputsizes)"
@ -93,7 +93,7 @@ class TestDateTimeVar(BaseTestCase):
startValue = 6,
baseDate = cx_Oracle.Date(2002, 12, 13),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 26.5)
self.assertEqual(returnValue.getvalue(), 26.5)
def testBindDateArrayByVar(self):
"test binding in a date array (with arrayvar)"
@ -109,7 +109,7 @@ class TestDateTimeVar(BaseTestCase):
startValue = 7,
baseDate = cx_Oracle.Date(2002, 12, 14),
array = array)
self.failUnlessEqual(returnValue.getvalue(), 17.5)
self.assertEqual(returnValue.getvalue(), 17.5)
def testBindInOutDateArrayByVar(self):
"test binding in/out a date array (with arrayvar)"
@ -122,7 +122,7 @@ class TestDateTimeVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(),
self.assertEqual(array.getvalue(),
[ cx_Oracle.Timestamp(2002, 12, 17, 2, 24, 0),
cx_Oracle.Timestamp(2002, 12, 18, 4, 48, 0),
cx_Oracle.Timestamp(2002, 12, 19, 7, 12, 0),
@ -139,7 +139,7 @@ class TestDateTimeVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(),
self.assertEqual(array.getvalue(),
[ cx_Oracle.Timestamp(2002, 12, 13, 4, 48, 0),
cx_Oracle.Timestamp(2002, 12, 14, 9, 36, 0),
cx_Oracle.Timestamp(2002, 12, 15, 14, 24, 0),
@ -154,7 +154,7 @@ class TestDateTimeVar(BaseTestCase):
begin
:value := to_date(20021209, 'YYYYMMDD');
end;""")
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 9))
def testBindInOutSetInputSizes(self):
@ -165,7 +165,7 @@ class TestDateTimeVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = cx_Oracle.Timestamp(2002, 12, 12, 10, 0, 0))
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 17, 16, 0, 0))
def testBindOutVar(self):
@ -177,7 +177,7 @@ class TestDateTimeVar(BaseTestCase):
'YYYYMMDD HH24:MI:SS');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 31, 12, 31, 0))
def testBindInOutVarDirectSet(self):
@ -189,13 +189,13 @@ class TestDateTimeVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 14, 12, 0, 0))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute(u"select * from TestDates")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'DATECOL', cx_Oracle.DATETIME, 23, 7, 0, 0, 0),
(u'NULLABLECOL', cx_Oracle.DATETIME, 23, 7, 0, 0, 1) ])
@ -203,17 +203,17 @@ class TestDateTimeVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute(u"select * From TestDates order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute(u"select * From TestDates order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -222,7 +222,7 @@ class TestDateTimeVar(BaseTestCase):
from TestDates
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

34
test/uIntervalVar.py
View File

@ -28,7 +28,7 @@ class TestIntervalVar(BaseTestCase):
where IntervalCol = :value""",
value = datetime.timedelta(days = 5, hours = 5, minutes = 10,
seconds = 15))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindNull(self):
"test binding in a null"
@ -37,7 +37,7 @@ class TestIntervalVar(BaseTestCase):
select * from TestIntervals
where IntervalCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizes(self):
"test binding out with set input sizes defined"
@ -46,7 +46,7 @@ class TestIntervalVar(BaseTestCase):
begin
:value := to_dsinterval('8 09:24:18.123789');
end;""")
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
datetime.timedelta(days = 8, hours = 9, minutes = 24,
seconds = 18, microseconds = 123789))
@ -58,7 +58,7 @@ class TestIntervalVar(BaseTestCase):
:value := :value + to_dsinterval('5 08:30:00');
end;""",
value = datetime.timedelta(days = 5, hours = 2, minutes = 15))
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
datetime.timedelta(days = 10, hours = 10, minutes = 45))
def testBindOutVar(self):
@ -69,7 +69,7 @@ class TestIntervalVar(BaseTestCase):
:value := to_dsinterval('15 18:35:45.586');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
datetime.timedelta(days = 15, hours = 18, minutes = 35,
seconds = 45, milliseconds = 586))
@ -82,13 +82,13 @@ class TestIntervalVar(BaseTestCase):
:value := :value + to_dsinterval('8 05:15:00');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
datetime.timedelta(days = 9, hours = 6, minutes = 5))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute(u"select * from TestIntervals")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('INTERVALCOL', cx_Oracle.INTERVAL, -1, 11, 0, 0, 0),
('NULLABLECOL', cx_Oracle.INTERVAL, -1, 11, 0, 0, 1) ])
@ -96,17 +96,17 @@ class TestIntervalVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute(u"select * From TestIntervals order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute(u"select * From TestIntervals order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -115,7 +115,7 @@ class TestIntervalVar(BaseTestCase):
from TestIntervals
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

28
test/uLobVar.py
View File

@ -38,8 +38,8 @@ class TestLobVar(BaseTestCase):
for row in self.cursor:
integerValue, lob = row
if integerValue == 0:
self.failUnlessEqual(lob.size(), 0)
self.failUnlessEqual(lob.read(), "")
self.assertEqual(lob.size(), 0)
self.assertEqual(lob.read(), "")
else:
if type.endswith("CLOB"):
char = unichr(ord('A') + integerValue - 1)
@ -50,14 +50,14 @@ class TestLobVar(BaseTestCase):
prevChar = chr(ord('A') + integerValue - 2)
actualValue = str(lob)
longString += char * 25000
self.failUnlessEqual(lob.size(), len(longString))
self.failUnlessEqual(lob.read(), longString)
self.failUnlessEqual(actualValue, longString)
self.failUnlessEqual(lob.read(len(longString)), char)
self.assertEqual(lob.size(), len(longString))
self.assertEqual(lob.read(), longString)
self.assertEqual(actualValue, longString)
self.assertEqual(lob.read(len(longString)), char)
if integerValue > 1:
offset = (integerValue - 1) * 25000 - 4
string = prevChar * 5 + char * 5
self.failUnlessEqual(lob.read(offset, 10), string)
self.assertEqual(lob.read(offset, 10), string)
def __TestTrim(self, type):
self.cursor.execute(u"truncate table Test%ss" % type)
@ -80,16 +80,16 @@ class TestLobVar(BaseTestCase):
from Test%ss
where IntCol = 1""" % (type, type))
lob, = self.cursor.fetchone()
self.failUnlessEqual(lob.size(), 75000)
self.assertEqual(lob.size(), 75000)
lob.trim(25000)
self.failUnlessEqual(lob.size(), 25000)
self.assertEqual(lob.size(), 25000)
lob.trim()
self.failUnlessEqual(lob.size(), 0)
self.assertEqual(lob.size(), 0)
def testBLOBCursorDescription(self):
"test cursor description is accurate for BLOBs"
self.cursor.execute(u"select * from TestBLOBs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'BLOBCOL', cx_Oracle.BLOB, -1, 4000, 0, 0, 0) ])
@ -108,7 +108,7 @@ class TestLobVar(BaseTestCase):
def testCLOBCursorDescription(self):
"test cursor description is accurate for CLOBs"
self.cursor.execute(u"select * from TestCLOBs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'CLOBCOL', cx_Oracle.CLOB, -1, 4000, 0, 0, 0) ])
@ -129,12 +129,12 @@ class TestLobVar(BaseTestCase):
self.cursor.arraysize = 1
self.cursor.execute(u"select CLOBCol from TestCLOBS")
rows = self.cursor.fetchall()
self.failUnlessRaises(cx_Oracle.ProgrammingError, rows[1][0].read)
self.assertRaises(cx_Oracle.ProgrammingError, rows[1][0].read)
def testNCLOBCursorDescription(self):
"test cursor description is accurate for NCLOBs"
self.cursor.execute(u"select * from TestNCLOBs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'NCLOBCOL', cx_Oracle.NCLOB, -1, 4000, 0, 0, 0) ])

18
test/uLongVar.py
View File

@ -39,8 +39,8 @@ class TestLongVar(BaseTestCase):
integerValue, fetchedValue = row
char = unichr(ord('A') + integerValue - 1)
longString += char * 25000
self.failUnlessEqual(len(fetchedValue), integerValue * 25000)
self.failUnlessEqual(fetchedValue, longString)
self.assertEqual(len(fetchedValue), integerValue * 25000)
self.assertEqual(fetchedValue, longString)
def testLongs(self):
"test binding and fetching long data"
@ -53,14 +53,14 @@ class TestLongVar(BaseTestCase):
def testLongCursorDescription(self):
"test cursor description is accurate for longs"
self.cursor.execute(u"select * from TestLongs")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'LONGCOL', cx_Oracle.LONG_STRING, -1, 0, 0, 0, 0) ])
def testLongRawCursorDescription(self):
"test cursor description is accurate for long raws"
self.cursor.execute(u"select * from TestLongRaws")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'LONGRAWCOL', cx_Oracle.LONG_BINARY, -1, 0, 0, 0, 0) ])
@ -69,20 +69,20 @@ class TestLongVar(BaseTestCase):
self.cursor.setoutputsize(25000)
self.cursor.execute(u"select * from TestLongRaws")
longVar = self.cursor.fetchvars[1]
self.failUnlessEqual(longVar.size, 25000)
self.failUnlessEqual(longVar.bufferSize, 25004)
self.assertEqual(longVar.size, 25000)
self.assertEqual(longVar.bufferSize, 25004)
def testSetOutputSizesWrongColumn(self):
"test setoutputsizes is valid (wrong column)"
self.cursor.setoutputsize(25000, 1)
self.cursor.execute(u"select * from TestLongRaws")
longVar = self.cursor.fetchvars[1]
self.failUnlessEqual(longVar.size, 131072)
self.failUnlessEqual(longVar.bufferSize, 131076)
self.assertEqual(longVar.size, 131072)
self.assertEqual(longVar.bufferSize, 131076)
def testArraySizeTooLarge(self):
"test array size too large generates an exception"
self.cursor.arraysize = 65536
self.failUnlessRaises(ValueError, self.cursor.execute,
self.assertRaises(ValueError, self.cursor.execute,
u"select * from TestLongRaws")

64
test/uNumberVar.py
View File

@ -28,7 +28,7 @@ class TestNumberVar(BaseTestCase):
where NumberCol - :value1 - :value2 = trunc(NumberCol)""",
value1 = decimal.Decimal("0.20"),
value2 = decimal.Decimal("0.05"))
self.failUnlessEqual(self.cursor.fetchall(),
self.assertEqual(self.cursor.fetchall(),
[self.dataByKey[1], self.dataByKey[5], self.dataByKey[9]])
def testBindFloat(self):
@ -37,7 +37,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where NumberCol - :value = trunc(NumberCol)""",
value = 0.25)
self.failUnlessEqual(self.cursor.fetchall(),
self.assertEqual(self.cursor.fetchall(),
[self.dataByKey[1], self.dataByKey[5], self.dataByKey[9]])
def testBindInteger(self):
@ -46,7 +46,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 2)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[2]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[2]])
def testBindSmallLong(self):
"test binding in a small long integer"
@ -54,7 +54,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 3L)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindLargeLong(self):
"test binding in a large long integer"
@ -66,7 +66,7 @@ class TestNumberVar(BaseTestCase):
end;""",
value = valueVar)
value = valueVar.getvalue()
self.failUnlessEqual(value, 6088343249)
self.assertEqual(value, 6088343249)
def testBindIntegerAfterString(self):
"test binding in an number after setting input sizes to a string"
@ -75,7 +75,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = 3)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindNull(self):
"test binding in a null"
@ -83,7 +83,7 @@ class TestNumberVar(BaseTestCase):
select * from TestNumbers
where IntCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindNumberArrayDirect(self):
"test binding in a number array"
@ -98,12 +98,12 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
startValue = 5,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 73.75)
self.assertEqual(returnValue.getvalue(), 73.75)
array = range(15)
self.cursor.execute(statement,
startValue = 10,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 115.0)
self.assertEqual(returnValue.getvalue(), 115.0)
def testBindNumberArrayBySizes(self):
"test binding in a number array (with setinputsizes)"
@ -118,7 +118,7 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
startValue = 6,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 74.75)
self.assertEqual(returnValue.getvalue(), 74.75)
def testBindNumberArrayByVar(self):
"test binding in a number array (with arrayvar)"
@ -134,7 +134,7 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
integerValue = 7,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 75.75)
self.assertEqual(returnValue.getvalue(), 75.75)
def testBindZeroLengthNumberArrayByVar(self):
"test binding in a zero length number array (with arrayvar)"
@ -148,8 +148,8 @@ class TestNumberVar(BaseTestCase):
returnValue = returnValue,
integerValue = 8,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 8.0)
self.failUnlessEqual(array.getvalue(), [])
self.assertEqual(returnValue.getvalue(), 8.0)
self.assertEqual(array.getvalue(), [])
def testBindInOutNumberArrayByVar(self):
"test binding in/out a number array (with arrayvar)"
@ -164,7 +164,7 @@ class TestNumberVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutNumberArrayByVar(self):
"test binding out a Number array (with arrayvar)"
@ -176,7 +176,7 @@ class TestNumberVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutSetInputSizes(self):
"test binding out with set input sizes defined"
@ -185,7 +185,7 @@ class TestNumberVar(BaseTestCase):
begin
:value := 5;
end;""")
self.failUnlessEqual(vars["value"].getvalue(), 5)
self.assertEqual(vars["value"].getvalue(), 5)
def testBindInOutSetInputSizes(self):
"test binding in/out with set input sizes defined"
@ -195,7 +195,7 @@ class TestNumberVar(BaseTestCase):
:value := :value + 5;
end;""",
value = 1.25)
self.failUnlessEqual(vars["value"].getvalue(), 6.25)
self.assertEqual(vars["value"].getvalue(), 6.25)
def testBindOutVar(self):
"test binding out with cursor.var() method"
@ -205,7 +205,7 @@ class TestNumberVar(BaseTestCase):
:value := 5;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), 5)
self.assertEqual(var.getvalue(), 5)
def testBindInOutVarDirectSet(self):
"test binding in/out with cursor.var() method"
@ -216,12 +216,12 @@ class TestNumberVar(BaseTestCase):
:value := :value + 5;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), 7.25)
self.assertEqual(var.getvalue(), 7.25)
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute(u"select * from TestNumbers")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'NUMBERCOL', cx_Oracle.NUMBER, 13, 22, 9, 2, 0),
(u'FLOATCOL', cx_Oracle.NUMBER, 127, 22, 126, -127, 0),
@ -231,17 +231,17 @@ class TestNumberVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute(u"select * From TestNumbers order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute(u"select * From TestNumbers order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -250,9 +250,9 @@ class TestNumberVar(BaseTestCase):
from TestNumbers
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)
def testReturnAsLong(self):
"test that fetching a long integer returns such in Python"
@ -261,11 +261,11 @@ class TestNumberVar(BaseTestCase):
from TestNumbers
where IntCol = 9""")
col, = self.cursor.fetchone()
self.failUnless(isinstance(col, long), "long integer not returned")
self.assertTrue(isinstance(col, long), "long integer not returned")
def testReturnAsFloat(self):
"test that fetching a floating point number returns such in Python"
self.cursor.execute(u"select 1.25 from dual")
result, = self.cursor.fetchone()
self.failUnlessEqual(result, 1.25)
self.assertEqual(result, 1.25)

14
test/uObjectVar.py
View File

@ -13,9 +13,9 @@ class TestObjectVar(BaseTestCase):
value = getattr(objectValue, attribute.name)
attributeValues.append(value)
objectValue = tuple(attributeValues)
self.failUnlessEqual(intValue, expectedIntValue)
self.failUnlessEqual(objectValue, expectedObjectValue)
self.failUnlessEqual(arrayValue, expectedArrayValue)
self.assertEqual(intValue, expectedIntValue)
self.assertEqual(objectValue, expectedObjectValue)
self.assertEqual(arrayValue, expectedArrayValue)
def testFetchData(self):
"test fetching objects"
@ -26,7 +26,7 @@ class TestObjectVar(BaseTestCase):
ArrayCol
from TestObjects
order by IntCol""")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'OBJECTCOL', cx_Oracle.OBJECT, -1, 2000, 0, 0, 1),
(u'ARRAYCOL', cx_Oracle.OBJECT, -1, 2000, 0, 0, 1) ])
@ -46,8 +46,8 @@ class TestObjectVar(BaseTestCase):
where ObjectCol is not null
and rownum <= 1""")
objValue, = self.cursor.fetchone()
self.failUnlessEqual(objValue.type.schema,
self.assertEqual(objValue.type.schema,
self.connection.username.upper())
self.failUnlessEqual(objValue.type.name, u"UDT_OBJECT")
self.failUnlessEqual(objValue.type.attributes[0].name, "NUMBERVALUE")
self.assertEqual(objValue.type.name, u"UDT_OBJECT")
self.assertEqual(objValue.type.attributes[0].name, "NUMBERVALUE")

42
test/uSessionPool.py
View File

@ -10,42 +10,42 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute(u"select count(*) from TestNumbers")
count, = cursor.fetchone()
self.failUnlessEqual(count, 10)
self.assertEqual(count, 10)
def testPool(self):
"""test that the pool is created and has the right attributes"""
pool = cx_Oracle.SessionPool(USERNAME, PASSWORD, TNSENTRY, 2, 8, 3)
self.failUnlessEqual(pool.username, USERNAME, "user name differs")
self.failUnlessEqual(pool.tnsentry, TNSENTRY, "tnsentry differs")
self.failUnlessEqual(pool.max, 8, "max differs")
self.failUnlessEqual(pool.min, 2, "min differs")
self.failUnlessEqual(pool.increment, 3, "increment differs")
self.failUnlessEqual(pool.opened, 2, "opened differs")
self.failUnlessEqual(pool.busy, 0, "busy not 0 at start")
self.assertEqual(pool.username, USERNAME, "user name differs")
self.assertEqual(pool.tnsentry, TNSENTRY, "tnsentry 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.failUnlessEqual(pool.busy, 1, "busy not 1 after acquire")
self.failUnlessEqual(pool.opened, 2, "opened not unchanged (1)")
self.assertEqual(pool.busy, 1, "busy not 1 after acquire")
self.assertEqual(pool.opened, 2, "opened not unchanged (1)")
connection_2 = pool.acquire()
self.failUnlessEqual(pool.busy, 2, "busy not 2 after acquire")
self.failUnlessEqual(pool.opened, 2, "opened not unchanged (2)")
self.assertEqual(pool.busy, 2, "busy not 2 after acquire")
self.assertEqual(pool.opened, 2, "opened not unchanged (2)")
connection_3 = pool.acquire()
self.failUnlessEqual(pool.busy, 3, "busy not 3 after acquire")
self.failUnlessEqual(pool.opened, 5, "opened not changed (3)")
self.assertEqual(pool.busy, 3, "busy not 3 after acquire")
self.assertEqual(pool.opened, 5, "opened not changed (3)")
pool.release(connection_3)
self.failUnlessEqual(pool.busy, 2, "busy not 2 after release")
self.assertEqual(pool.busy, 2, "busy not 2 after release")
del connection_2
self.failUnlessEqual(pool.busy, 1, "busy not 1 after del")
self.assertEqual(pool.busy, 1, "busy not 1 after del")
def testProxyAuth(self):
"""test that proxy authentication is possible"""
pool = cx_Oracle.SessionPool(USERNAME, PASSWORD, TNSENTRY, 2, 8, 3)
self.failUnlessEqual(pool.homogeneous, 1,
self.assertEqual(pool.homogeneous, 1,
"homogeneous should be 1 by default")
self.failUnlessRaises(cx_Oracle.ProgrammingError, pool.acquire,
self.assertRaises(cx_Oracle.ProgrammingError, pool.acquire,
user = "proxyuser")
pool = cx_Oracle.SessionPool(USERNAME, PASSWORD, TNSENTRY, 2, 8, 3,
homogeneous = False)
self.failUnlessEqual(pool.homogeneous, 0,
self.assertEqual(pool.homogeneous, 0,
"homogeneous should be 0 after setting it in the constructor")
user = u"%s_proxy" % USERNAME
connection = pool.acquire(user = user)
@ -66,7 +66,7 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute(u"select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testRollbackOnRelease(self):
"connection rolls back before released back to the pool"
@ -81,7 +81,7 @@ class TestConnection(TestCase):
cursor = connection.cursor()
cursor.execute(u"select count(*) from TestExecuteMany")
count, = cursor.fetchone()
self.failUnlessEqual(count, 0)
self.assertEqual(count, 0)
def testThreading(self):
"""test session pool to database with multiple threads"""

58
test/uStringVar.py
View File

@ -24,7 +24,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = u"String 5")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindDifferentVar(self):
"test binding a different variable on second execution"
@ -32,10 +32,10 @@ class TestStringVar(BaseTestCase):
retval_2 = self.cursor.var(cx_Oracle.STRING, 30)
self.cursor.execute(u"begin :retval := 'Called'; end;",
retval = retval_1)
self.failUnlessEqual(retval_1.getvalue(), u"Called")
self.assertEqual(retval_1.getvalue(), u"Called")
self.cursor.execute(u"begin :retval := 'Called'; end;",
retval = retval_2)
self.failUnlessEqual(retval_2.getvalue(), u"Called")
self.assertEqual(retval_2.getvalue(), u"Called")
def testBindStringAfterNumber(self):
"test binding in a string after setting input sizes to a number"
@ -44,7 +44,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = u"String 6")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[6]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[6]])
def testBindStringArrayBySizes(self):
"test binding in a string array (with setinputsizes)"
@ -59,7 +59,7 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 6,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 87)
self.assertEqual(returnValue.getvalue(), 87)
def testBindStringArrayByVar(self):
"test binding in a string array (with arrayvar)"
@ -74,7 +74,7 @@ class TestStringVar(BaseTestCase):
returnValue = returnValue,
integerValue = 7,
array = array)
self.failUnlessEqual(returnValue.getvalue(), 88)
self.assertEqual(returnValue.getvalue(), 88)
def testBindInOutStringArrayByVar(self):
"test binding in/out a string array (with arrayvar)"
@ -90,7 +90,7 @@ class TestStringVar(BaseTestCase):
end;""",
numElems = 5,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindOutStringArrayByVar(self):
"test binding out a string array (with arrayvar)"
@ -102,7 +102,7 @@ class TestStringVar(BaseTestCase):
end;""",
numElems = 6,
array = array)
self.failUnlessEqual(array.getvalue(), expectedData)
self.assertEqual(array.getvalue(), expectedData)
def testBindRaw(self):
"test binding in a raw"
@ -111,7 +111,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where RawCol = :value""",
value = "Raw 4")
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[4]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[4]])
def testBindAndFetchRowid(self):
"test binding (and fetching) a rowid"
@ -125,7 +125,7 @@ class TestStringVar(BaseTestCase):
from TestStrings
where rowid = :value""",
value = rowid)
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[3]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[3]])
def testBindNull(self):
"test binding in a null"
@ -133,7 +133,7 @@ class TestStringVar(BaseTestCase):
select * from TestStrings
where StringCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizesByType(self):
"test binding out with set input sizes defined (by type)"
@ -142,7 +142,7 @@ class TestStringVar(BaseTestCase):
begin
:value := 'TSI';
end;""")
self.failUnlessEqual(vars["value"].getvalue(), u"TSI")
self.assertEqual(vars["value"].getvalue(), u"TSI")
def testBindOutSetInputSizesByInteger(self):
"test binding out with set input sizes defined (by integer)"
@ -151,7 +151,7 @@ class TestStringVar(BaseTestCase):
begin
:value := 'TSI (I)';
end;""")
self.failUnlessEqual(vars["value"].getvalue(), u"TSI (I)")
self.assertEqual(vars["value"].getvalue(), u"TSI (I)")
def testBindInOutSetInputSizesByType(self):
"test binding in/out with set input sizes defined (by type)"
@ -161,7 +161,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI';
end;""",
value = u"InVal")
self.failUnlessEqual(vars["value"].getvalue(), u"InVal TSI")
self.assertEqual(vars["value"].getvalue(), u"InVal TSI")
def testBindInOutSetInputSizesByInteger(self):
"test binding in/out with set input sizes defined (by integer)"
@ -171,7 +171,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI (I)';
end;""",
value = u"InVal")
self.failUnlessEqual(vars["value"].getvalue(), u"InVal TSI (I)")
self.assertEqual(vars["value"].getvalue(), u"InVal TSI (I)")
def testBindOutVar(self):
"test binding out with cursor.var() method"
@ -181,7 +181,7 @@ class TestStringVar(BaseTestCase):
:value := 'TSI (VAR)';
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), u"TSI (VAR)")
self.assertEqual(var.getvalue(), u"TSI (VAR)")
def testBindInOutVarDirectSet(self):
"test binding in/out with cursor.var() method"
@ -192,7 +192,7 @@ class TestStringVar(BaseTestCase):
:value := :value || ' TSI (VAR)';
end;""",
value = var)
self.failUnlessEqual(var.getvalue(), u"InVal TSI (VAR)")
self.assertEqual(var.getvalue(), u"InVal TSI (VAR)")
def testBindLongString(self):
"test that binding a long string succeeds"
@ -210,14 +210,14 @@ class TestStringVar(BaseTestCase):
inString = u"1234567890" * 9000
var.setvalue(0, inString)
outString = var.getvalue()
self.failUnlessEqual(inString, outString,
self.assertEqual(inString, outString,
"output does not match: in was %d, out was %d" % \
(len(inString), len(outString)))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute(u"select * from TestStrings")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ (u'INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
(u'STRINGCOL', cx_Oracle.STRING, 20, 20, 0, 0, 0),
(u'RAWCOL', cx_Oracle.BINARY, 30, 30, 0, 0, 0),
@ -227,17 +227,17 @@ class TestStringVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute(u"select * From TestStrings order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute(u"select * From TestStrings order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -246,7 +246,7 @@ class TestStringVar(BaseTestCase):
from TestStrings
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)

34
test/uTimestampVar.py
View File

@ -38,7 +38,7 @@ class TestTimestampVar(BaseTestCase):
select * from TestTimestamps
where TimestampCol = :value""",
value = cx_Oracle.Timestamp(2002, 12, 14, 0, 0, 10, 250000))
self.failUnlessEqual(self.cursor.fetchall(), [self.dataByKey[5]])
self.assertEqual(self.cursor.fetchall(), [self.dataByKey[5]])
def testBindNull(self):
"test binding in a null"
@ -47,7 +47,7 @@ class TestTimestampVar(BaseTestCase):
select * from TestTimestamps
where TimestampCol = :value""",
value = None)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), [])
def testBindOutSetInputSizes(self):
"test binding out with set input sizes defined"
@ -56,7 +56,7 @@ class TestTimestampVar(BaseTestCase):
begin
:value := to_timestamp('20021209', 'YYYYMMDD');
end;""")
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 9))
def testBindInOutSetInputSizes(self):
@ -67,7 +67,7 @@ class TestTimestampVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = cx_Oracle.Timestamp(2002, 12, 12, 10, 0, 0))
self.failUnlessEqual(vars["value"].getvalue(),
self.assertEqual(vars["value"].getvalue(),
cx_Oracle.Timestamp(2002, 12, 17, 16, 0, 0))
def testBindOutVar(self):
@ -79,7 +79,7 @@ class TestTimestampVar(BaseTestCase):
'YYYYMMDD HH24:MI:SS');
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 31, 12, 31, 0))
def testBindInOutVarDirectSet(self):
@ -91,13 +91,13 @@ class TestTimestampVar(BaseTestCase):
:value := :value + 5.25;
end;""",
value = var)
self.failUnlessEqual(var.getvalue(),
self.assertEqual(var.getvalue(),
cx_Oracle.Timestamp(2002, 12, 14, 12, 0, 0))
def testCursorDescription(self):
"test cursor description is accurate"
self.cursor.execute(u"select * from TestTimestamps")
self.failUnlessEqual(self.cursor.description,
self.assertEqual(self.cursor.description,
[ ('INTCOL', cx_Oracle.NUMBER, 10, 22, 9, 0, 0),
('TIMESTAMPCOL', cx_Oracle.TIMESTAMP, -1, 11, 0, 0, 0),
('NULLABLECOL', cx_Oracle.TIMESTAMP, -1, 11, 0, 0, 1) ])
@ -105,17 +105,17 @@ class TestTimestampVar(BaseTestCase):
def testFetchAll(self):
"test that fetching all of the data returns the correct results"
self.cursor.execute(u"select * From TestTimestamps order by IntCol")
self.failUnlessEqual(self.cursor.fetchall(), self.rawData)
self.failUnlessEqual(self.cursor.fetchall(), [])
self.assertEqual(self.cursor.fetchall(), self.rawData)
self.assertEqual(self.cursor.fetchall(), [])
def testFetchMany(self):
"test that fetching data in chunks returns the correct results"
self.cursor.execute(u"select * From TestTimestamps order by IntCol")
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.failUnlessEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.failUnlessEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.failUnlessEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.failUnlessEqual(self.cursor.fetchmany(3), [])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[0:3])
self.assertEqual(self.cursor.fetchmany(2), self.rawData[3:5])
self.assertEqual(self.cursor.fetchmany(4), self.rawData[5:9])
self.assertEqual(self.cursor.fetchmany(3), self.rawData[9:])
self.assertEqual(self.cursor.fetchmany(3), [])
def testFetchOne(self):
"test that fetching a single row returns the correct results"
@ -124,7 +124,7 @@ class TestTimestampVar(BaseTestCase):
from TestTimestamps
where IntCol in (3, 4)
order by IntCol""")
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[3])
self.failUnlessEqual(self.cursor.fetchone(), self.dataByKey[4])
self.failUnlessEqual(self.cursor.fetchone(), None)
self.assertEqual(self.cursor.fetchone(), self.dataByKey[3])
self.assertEqual(self.cursor.fetchone(), self.dataByKey[4])
self.assertEqual(self.cursor.fetchone(), None)