Merge pull request #134 from madscientist/master

Fix test suite.
Update to newer versions in Travis.
Bump the release to 2.3.3

Author: madscientist

.travis.yml

@@ -1,8 +1,10 @@
+dist: xenial
+
 language: python
 
 python:
   - "2.7"
-  - "3.6"
+  - "3.7"
 
 env:
   global:
@@ -11,8 +13,8 @@ env:
     - NUO_ADD_DOMAIN_PASS=yes
     - NUO_START_AGENT=yes
   matrix:
-    - NUO_VERSION=3.1.2.1
-    - NUO_VERSION=3.2.0.2
+    - NUO_VERSION=3.2.2.1
+    - NUO_VERSION=3.3.0.1
 
 notifications:
   recipients:
@@ -23,10 +25,6 @@ before_install:
   - echo madvise | sudo tee /sys/kernel/mm/transparent_hugepage/enabled >/dev/null
   - echo madvise | sudo tee /sys/kernel/mm/transparent_hugepage/defrag >/dev/null
 
-  # There's a bug in the Trusty images where this gives a syntax error
-  # See https://github.com/travis-ci/travis-ci/issues/8906
-  - sudo mv /opt/jdk_switcher/jdk_switcher.sh /tmp
-
   - wget -q "http://download.nuohub.org/nuodb-ce_${NUO_VERSION}_amd64.deb" --output-document=/var/tmp/nuodb.deb
   - sudo dpkg -i /var/tmp/nuodb.deb
 

pynuodb/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '2.3.2'
+__version__ = '2.3.3'
 
 from .connection import *
 from .datatype import *

tests/dbapi20.py

@@ -171,7 +171,7 @@ def test_threadsafety(self):
             # Must exist
             threadsafety = self.driver.threadsafety
             # Must be a valid value
-            self.failUnless(threadsafety in (0,1,2,3))
+            self.assertIn(threadsafety, (0,1,2,3))
         except AttributeError:
             self.fail("Driver doesn't define threadsafety")
 
@@ -180,7 +180,7 @@ def test_paramstyle(self):
             # Must exist
             paramstyle = self.driver.paramstyle
             # Must be a valid value
-            self.failUnless(paramstyle in (
+            self.assertIn(paramstyle, (
                 'qmark','numeric','named','format','pyformat'
                 ))
         except AttributeError:
@@ -189,28 +189,28 @@ def test_paramstyle(self):
     def test_Exceptions(self):
         # Make sure required exceptions exist, and are in the
         # defined heirarchy.
-        self.failUnless(issubclass(self.driver.Warning,Exception))
-        self.failUnless(issubclass(self.driver.Error,Exception))
+        self.assertTrue(issubclass(self.driver.Warning,Exception))
+        self.assertTrue(issubclass(self.driver.Error,Exception))
 
-        self.failUnless(
+        self.assertTrue(
             issubclass(self.driver.InterfaceError,self.driver.Error)
             )
-        self.failUnless(
+        self.assertTrue(
             issubclass(self.driver.DatabaseError,self.driver.Error)
             )
-        self.failUnless(
+        self.assertTrue(
             issubclass(self.driver.OperationalError,self.driver.Error)
             )
-        self.failUnless(
+        self.assertTrue(
             issubclass(self.driver.IntegrityError,self.driver.Error)
             )
-        self.failUnless(
+        self.assertTrue(
             issubclass(self.driver.InternalError,self.driver.Error)
             )
-        self.failUnless(
+        self.assertTrue(
             issubclass(self.driver.ProgrammingError,self.driver.Error)
             )
-        self.failUnless(
+        self.assertTrue(
             issubclass(self.driver.NotSupportedError,self.driver.Error)
             )
 
@@ -223,15 +223,15 @@ def test_ExceptionsAsConnectionAttributes(self):
         # by default.
         con = self._connect()
         drv = self.driver
-        self.failUnless(con.Warning is drv.Warning)
-        self.failUnless(con.Error is drv.Error)
-        self.failUnless(con.InterfaceError is drv.InterfaceError)
-        self.failUnless(con.DatabaseError is drv.DatabaseError)
-        self.failUnless(con.OperationalError is drv.OperationalError)
-        self.failUnless(con.IntegrityError is drv.IntegrityError)
-        self.failUnless(con.InternalError is drv.InternalError)
-        self.failUnless(con.ProgrammingError is drv.ProgrammingError)
-        self.failUnless(con.NotSupportedError is drv.NotSupportedError)
+        self.assertIs(con.Warning, drv.Warning)
+        self.assertIs(con.Error, drv.Error)
+        self.assertIs(con.InterfaceError, drv.InterfaceError)
+        self.assertIs(con.DatabaseError, drv.DatabaseError)
+        self.assertIs(con.OperationalError, drv.OperationalError)
+        self.assertIs(con.IntegrityError, drv.IntegrityError)
+        self.assertIs(con.InternalError, drv.InternalError)
+        self.assertIs(con.ProgrammingError, drv.ProgrammingError)
+        self.assertIs(con.NotSupportedError, drv.NotSupportedError)
 
 
     def test_commit(self):
@@ -323,12 +323,12 @@ def test_rowcount(self):
             cur.execute("insert into %sbooze values ('Victoria Bitter')" % (
                 self.table_prefix
                 ))
-            self.failUnless(cur.rowcount in (-1,1),
+            self.assertIn(cur.rowcount, (-1,1),
                 'cursor.rowcount should == number or rows inserted, or '
                 'set to -1 after executing an insert statement'
                 )
             cur.execute("select name from %sbooze" % self.table_prefix)
-            self.failUnless(cur.rowcount in (-1,1),
+            self.assertIn(cur.rowcount, (-1,1),
                 'cursor.rowcount should == number of rows returned, or '
                 'set to -1 after executing a select statement'
                 )
@@ -391,7 +391,7 @@ def _paraminsert(self,cur):
         cur.execute("insert into %sbooze values ('Victoria Bitter')" % (
             self.table_prefix
             ))
-        self.failUnless(cur.rowcount in (-1,1))
+        self.assertIn(cur.rowcount, (-1,1))
 
         if self.driver.paramstyle == 'qmark':
             cur.execute(
@@ -420,7 +420,7 @@ def _paraminsert(self,cur):
                 )
         else:
             self.fail('Invalid paramstyle')
-        self.failUnless(cur.rowcount in (-1,1))
+        self.assertIn(cur.rowcount, (-1,1))
 
         cur.execute('select name from %sbooze' % self.table_prefix)
         res = cur.fetchall()
@@ -471,7 +471,7 @@ def test_executemany(self):
                     )
             else:
                 self.fail('Unknown paramstyle')
-            self.failUnless(cur.rowcount in (-1,2),
+            self.assertIn(cur.rowcount, (-1,2),
                 'insert using cursor.executemany set cursor.rowcount to '
                 'incorrect value %r' % cur.rowcount
                 )
@@ -506,7 +506,7 @@ def test_fetchone(self):
                 'cursor.fetchone should return None if a query retrieves '
                 'no rows'
                 )
-            self.failUnless(cur.rowcount in (-1,0))
+            self.assertIn(cur.rowcount, (-1,0))
 
             # cursor.fetchone should raise an Error if called after
             # executing a query that cannnot return rows
@@ -526,7 +526,7 @@ def test_fetchone(self):
             self.assertEqual(cur.fetchone(),None,
                 'cursor.fetchone should return None if no more rows available'
                 )
-            self.failUnless(cur.rowcount in (-1,1))
+            self.assertIn(cur.rowcount, (-1,1))
         finally:
             con.close()
 
@@ -582,7 +582,7 @@ def test_fetchmany(self):
                 'cursor.fetchmany should return an empty sequence after '
                 'results are exhausted'
             )
-            self.failUnless(cur.rowcount in (-1,6))
+            self.assertIn(cur.rowcount, (-1,6))
 
             # Same as above, using cursor.arraysize
             cur.arraysize=4
@@ -595,12 +595,12 @@ def test_fetchmany(self):
             self.assertEqual(len(r),2)
             r = cur.fetchmany() # Should be an empty sequence
             self.assertEqual(len(r),0)
-            self.failUnless(cur.rowcount in (-1,6))
+            self.assertIn(cur.rowcount, (-1,6))
 
             cur.arraysize=6
             cur.execute('select name from %sbooze' % self.table_prefix)
             rows = cur.fetchmany() # Should get all rows
-            self.failUnless(cur.rowcount in (-1,6))
+            self.assertIn(cur.rowcount, (-1,6))
             self.assertEqual(len(rows),6)
             self.assertEqual(len(rows),6)
             rows = [r[0] for r in rows]
@@ -617,7 +617,7 @@ def test_fetchmany(self):
                 'cursor.fetchmany should return an empty sequence if '
                 'called after the whole result set has been fetched'
                 )
-            self.failUnless(cur.rowcount in (-1,6))
+            self.assertIn(cur.rowcount, (-1,6))
 
             self.executeDDL2(cur)
             cur.execute('select name from %sbarflys' % self.table_prefix)
@@ -626,7 +626,7 @@ def test_fetchmany(self):
                 'cursor.fetchmany should return an empty sequence if '
                 'query retrieved no rows'
                 )
-            self.failUnless(cur.rowcount in (-1,0))
+            self.assertIn(cur.rowcount, (-1,0))
 
         finally:
             con.close()
@@ -650,7 +650,7 @@ def test_fetchall(self):
 
             cur.execute('select name from %sbooze' % self.table_prefix)
             rows = cur.fetchall()
-            self.failUnless(cur.rowcount in (-1,len(self.samples)))
+            self.assertIn(cur.rowcount, (-1,len(self.samples)))
             self.assertEqual(len(rows),len(self.samples),
                 'cursor.fetchall did not retrieve all rows'
                 )
@@ -666,12 +666,12 @@ def test_fetchall(self):
                 'cursor.fetchall should return an empty list if called '
                 'after the whole result set has been fetched'
                 )
-            self.failUnless(cur.rowcount in (-1,len(self.samples)))
+            self.assertIn(cur.rowcount, (-1,len(self.samples)))
 
             self.executeDDL2(cur)
             cur.execute('select name from %sbarflys' % self.table_prefix)
             rows = cur.fetchall()
-            self.failUnless(cur.rowcount in (-1,0))
+            self.assertIn(cur.rowcount, (-1,0))
             self.assertEqual(len(rows),0,
                 'cursor.fetchall should return an empty list if '
                 'a select query returns no rows'
@@ -693,7 +693,7 @@ def test_mixedfetch(self):
             rows23 = cur.fetchmany(2)
             rows4  = cur.fetchone()
             rows56 = cur.fetchall()
-            self.failUnless(cur.rowcount in (-1,6))
+            self.assertIn(cur.rowcount, (-1,6))
             self.assertEqual(len(rows23),2,
                 'fetchmany returned incorrect number of rows'
                 )
@@ -772,7 +772,7 @@ def test_arraysize(self):
         con = self._connect()
         try:
             cur = con.cursor()
-            self.failUnless(hasattr(cur,'arraysize'),
+            self.assertTrue(hasattr(cur,'arraysize'),
                 'cursor.arraysize must be defined'
                 )
         finally:
@@ -841,26 +841,26 @@ def test_Binary(self):
         b = self.driver.Binary(str2bytes(''))
 
     def test_STRING(self):
-        self.failUnless(hasattr(self.driver,'STRING'),
+        self.assertTrue(hasattr(self.driver,'STRING'),
             'module.STRING must be defined'
             )
 
     def test_BINARY(self):
-        self.failUnless(hasattr(self.driver,'BINARY'),
+        self.assertTrue(hasattr(self.driver,'BINARY'),
             'module.BINARY must be defined.'
             )
 
     def test_NUMBER(self):
-        self.failUnless(hasattr(self.driver,'NUMBER'),
+        self.assertTrue(hasattr(self.driver,'NUMBER'),
             'module.NUMBER must be defined.'
             )
 
     def test_DATETIME(self):
-        self.failUnless(hasattr(self.driver,'DATETIME'),
+        self.assertTrue(hasattr(self.driver,'DATETIME'),
             'module.DATETIME must be defined.'
             )
 
     def test_ROWID(self):
-        self.failUnless(hasattr(self.driver,'ROWID'),
+        self.assertTrue(hasattr(self.driver,'ROWID'),
             'module.ROWID must be defined.'
             )

tests/dbapi20_tpc.py

@@ -28,15 +28,15 @@ def test_xid(self):
         except self.driver.NotSupportedError:
             self.fail("Driver does not support transaction IDs.")
 
-        self.assertEquals(xid[0], 42)
-        self.assertEquals(xid[1], "global")
-        self.assertEquals(xid[2], "bqual")
+        self.assertEqual(xid[0], 42)
+        self.assertEqual(xid[1], "global")
+        self.assertEqual(xid[2], "bqual")
 
         # Try some extremes for the transaction ID:
         xid = con.xid(0, "", "")
-        self.assertEquals(tuple(xid), (0, "", ""))
+        self.assertEqual(tuple(xid), (0, "", ""))
         xid = con.xid(0x7fffffff, "a" * 64, "b" * 64)
-        self.assertEquals(tuple(xid), (0x7fffffff, "a" * 64, "b" * 64))
+        self.assertEqual(tuple(xid), (0x7fffffff, "a" * 64, "b" * 64))
 
     def test_tpc_begin(self):
         con = self.connect()

tests/nuodb_basic_test.py

@@ -155,13 +155,16 @@ def _test_faulty_decimal_fixture(self, value, precision, scale):
         cursor.execute("DROP TABLE CASCADE t IF EXISTS")
         try:
             cursor.execute("CREATE TABLE t (x NUMERIC(%s,%s))" % (precision, scale))
-            DataError
             cursor.execute("INSERT INTO t (x) VALUES (?)", (value,))
             cursor.execute("SELECT * FROM t")
             self.fail("Incorrectly inserted %s as NUMERIC(%s,%s)" % (str(value), str(precision), str(scale)))
 
         except DataError as err:
-            self.assertIn("CONSTRAINT_ERROR", str(err))
+            # Older versions of NuoDB would throw a CONSTRAINT_ERROR.
+            # Newer versions throw a CONVERSION_ERROR.
+            msg = str(err)
+            if not 'CONSTRAINT_ERROR' in msg and not 'CONVERSION_ERROR' in msg:
+                self.fail("Unexpected DataError: %s" % (msg))
 
         finally:
             try:

tests/nuodb_blob_test.py

@@ -23,8 +23,8 @@ def test_blob_prepared(self):
         if systemVersion is '3':
             currentRow = bytes(currentRow, 'latin-1')
         array2 = unpack('hhl', currentRow)
-        self.assertEquals(len(array2), 3)
-        self.assertEquals(array2[2], 3)
+        self.assertEqual(len(array2), 3)
+        self.assertEqual(array2[2], 3)
 
 
 if __name__ == '__main__':