Changeset 599


Ignore:
Timestamp:
Nov 22, 2015, 8:59:01 AM (4 years ago)
Author:
cito
Message:

Fix a few Python 3 issues with the main tests

Location:
trunk/module
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/module/TEST_PyGreSQL_classic.py

    r553 r599  
    2020except ImportError:
    2121    pass
     22
    2223
    2324def opendb():
     
    3637    "DROP SCHEMA _test2",
    3738):
    38     try: db.query(q)
    39     except: pass
     39    try:
     40        db.query(q)
     41    except Exception:
     42        pass
    4043db.close()
     44
    4145
    4246class UtilityTest(unittest.TestCase):
     
    259263                thread.start()
    260264                # Wait until the thread has started.
    261                 for n in xrange(500):
     265                for n in range(500):
    262266                    if target.listening:
    263267                        break
     
    273277                    db2.query("notify event_1, 'payload 1'")
    274278                # Wait until the notification has been caught.
    275                 for n in xrange(500):
     279                for n in range(500):
    276280                    if arg_dict['called'] or self.notify_timeout:
    277281                        break
     
    292296                db2.close()
    293297                # Wait until the notification has been caught.
    294                 for n in xrange(500):
     298                for n in range(500):
    295299                    if arg_dict['called'] or self.notify_timeout:
    296300                        break
     
    332336    suite = unittest.TestSuite()
    333337
    334     if len(sys.argv) > 1: test_list = sys.argv[1:]
    335     else: test_list = unittest.getTestCaseNames(UtilityTest, 'test_')
     338    if len(sys.argv) > 1:
     339        test_list = sys.argv[1:]
     340    else:
     341        test_list = unittest.getTestCaseNames(UtilityTest, 'test_')
    336342
    337343    if len(sys.argv) == 2 and sys.argv[1] == '-l':
     
    342348        try:
    343349            suite.addTest(UtilityTest(test_name))
    344         except:
     350        except Exception:
    345351            print("\n ERROR: %s.\n" % sys.exc_value)
    346352            sys.exit(1)
    347353
    348354    rc = unittest.TextTestRunner(verbosity=1).run(suite)
    349     sys.exit(len(rc.errors+rc.failures) != 0)
    350 
     355    sys.exit(1 if rc.errors or rc.failures else 0)
  • trunk/module/TEST_PyGreSQL_dbapi20.py

    r553 r599  
    5050        cur = myCursor(con)
    5151        ret = cur.execute("select 1 as a, 2 as b")
    52         self.assert_(ret is cur, 'execute() should return cursor')
     52        self.assertTrue(ret is cur, 'execute() should return cursor')
    5353        self.assertEqual(cur.fetchone(), {'a': 1, 'b': 2})
    5454
     
    103103            cur.execute("select 1/0")
    104104        except pgdb.DatabaseError as error:
    105             self.assert_(isinstance(error, pgdb.ProgrammingError))
     105            self.assertTrue(isinstance(error, pgdb.ProgrammingError))
    106106            # the SQLSTATE error code for division by zero is 22012
    107107            self.assertEqual(error.sqlstate, '22012')
     
    110110        nan, inf = float('nan'), float('inf')
    111111        from math import isnan, isinf
    112         self.assert_(isnan(nan) and not isinf(nan))
    113         self.assert_(isinf(inf) and not isnan(inf))
     112        self.assertTrue(isnan(nan) and not isinf(nan))
     113        self.assertTrue(isinf(inf) and not isnan(inf))
    114114        values = [0, 1, 0.03125, -42.53125, nan, inf, -inf]
    115115        table = self.table_prefix + 'booze'
     
    129129        for inval, outval in zip(values, rows):
    130130            if isinf(inval):
    131                 self.assert_(isinf(outval))
     131                self.assertTrue(isinf(outval))
    132132                if inval < 0:
    133                     self.assert_(outval < 0)
     133                    self.assertTrue(outval < 0)
    134134                else:
    135                     self.assert_(outval > 0)
     135                    self.assertTrue(outval > 0)
    136136            elif isnan(inval):
    137                 self.assert_(isnan(outval))
     137                self.assertTrue(isnan(outval))
    138138            else:
    139139                self.assertEqual(inval, outval)
     
    141141    def test_set_decimal_type(self):
    142142        decimal_type = pgdb.decimal_type()
    143         self.assert_(decimal_type is not None and callable(decimal_type))
    144         con = self._connect()
    145         try:
    146             cur = con.cursor()
    147             self.assert_(pgdb.decimal_type(int) is int)
     143        self.assertTrue(decimal_type is not None and callable(decimal_type))
     144        con = self._connect()
     145        try:
     146            cur = con.cursor()
     147            self.assertTrue(pgdb.decimal_type(int) is int)
    148148            cur.execute('select 42')
    149149            value = cur.fetchone()[0]
    150             self.assert_(isinstance(value, int))
     150            self.assertTrue(isinstance(value, int))
    151151            self.assertEqual(value, 42)
    152             self.assert_(pgdb.decimal_type(float) is float)
     152            self.assertTrue(pgdb.decimal_type(float) is float)
    153153            cur.execute('select 4.25')
    154154            value = cur.fetchone()[0]
    155             self.assert_(isinstance(value, float))
     155            self.assertTrue(isinstance(value, float))
    156156            self.assertEqual(value, 4.25)
    157157        finally:
    158158            con.close()
    159159            pgdb.decimal_type(decimal_type)
    160         self.assert_(pgdb.decimal_type() is decimal_type)
     160        self.assertTrue(pgdb.decimal_type() is decimal_type)
    161161
    162162    def test_nextset(self):
     
    248248        self.assertNotEqual('int4', pgdb.LONG)
    249249        self.assertEqual('int8', pgdb.LONG)
    250         self.assert_('char' in pgdb.STRING)
    251         self.assert_(pgdb.NUMERIC <= pgdb.NUMBER)
    252         self.assert_(pgdb.NUMBER >= pgdb.INTEGER)
    253         self.assert_(pgdb.TIME <= pgdb.DATETIME)
    254         self.assert_(pgdb.DATETIME >= pgdb.DATE)
     250        self.assertTrue('char' in pgdb.STRING)
     251        self.assertTrue(pgdb.NUMERIC <= pgdb.NUMBER)
     252        self.assertTrue(pgdb.NUMBER >= pgdb.INTEGER)
     253        self.assertTrue(pgdb.TIME <= pgdb.DATETIME)
     254        self.assertTrue(pgdb.DATETIME >= pgdb.DATE)
    255255
    256256
  • trunk/module/dbapi20.py

    r521 r599  
    160160            threadsafety = self.driver.threadsafety
    161161            # Must be a valid value
    162             self.failUnless(threadsafety in (0,1,2,3))
     162            self.assertTrue(threadsafety in (0,1,2,3))
    163163        except AttributeError:
    164164            self.fail("Driver doesn't define threadsafety")
     
    169169            paramstyle = self.driver.paramstyle
    170170            # Must be a valid value
    171             self.failUnless(paramstyle in (
     171            self.assertTrue(paramstyle in (
    172172                'qmark','numeric','named','format','pyformat'
    173173                ))
     
    179179        defined hierarchy.
    180180        """
    181         self.failUnless(issubclass(self.driver.Warning,Exception))
    182         self.failUnless(issubclass(self.driver.Error,Exception))
    183         self.failUnless(
     181        self.assertTrue(issubclass(self.driver.Warning,Exception))
     182        self.assertTrue(issubclass(self.driver.Error,Exception))
     183        self.assertTrue(
    184184            issubclass(self.driver.InterfaceError,self.driver.Error)
    185185            )
    186         self.failUnless(
     186        self.assertTrue(
    187187            issubclass(self.driver.DatabaseError,self.driver.Error)
    188188            )
    189         self.failUnless(
     189        self.assertTrue(
    190190            issubclass(self.driver.OperationalError,self.driver.Error)
    191191            )
    192         self.failUnless(
     192        self.assertTrue(
    193193            issubclass(self.driver.IntegrityError,self.driver.Error)
    194194            )
    195         self.failUnless(
     195        self.assertTrue(
    196196            issubclass(self.driver.InternalError,self.driver.Error)
    197197            )
    198         self.failUnless(
     198        self.assertTrue(
    199199            issubclass(self.driver.ProgrammingError,self.driver.Error)
    200200            )
    201         self.failUnless(
     201        self.assertTrue(
    202202            issubclass(self.driver.NotSupportedError,self.driver.Error)
    203203            )
     
    214214        con = self._connect()
    215215        drv = self.driver
    216         self.failUnless(con.Warning is drv.Warning)
    217         self.failUnless(con.Error is drv.Error)
    218         self.failUnless(con.InterfaceError is drv.InterfaceError)
    219         self.failUnless(con.DatabaseError is drv.DatabaseError)
    220         self.failUnless(con.OperationalError is drv.OperationalError)
    221         self.failUnless(con.IntegrityError is drv.IntegrityError)
    222         self.failUnless(con.InternalError is drv.InternalError)
    223         self.failUnless(con.ProgrammingError is drv.ProgrammingError)
    224         self.failUnless(con.NotSupportedError is drv.NotSupportedError)
     216        self.assertTrue(con.Warning is drv.Warning)
     217        self.assertTrue(con.Error is drv.Error)
     218        self.assertTrue(con.InterfaceError is drv.InterfaceError)
     219        self.assertTrue(con.DatabaseError is drv.DatabaseError)
     220        self.assertTrue(con.OperationalError is drv.OperationalError)
     221        self.assertTrue(con.IntegrityError is drv.IntegrityError)
     222        self.assertTrue(con.InternalError is drv.InternalError)
     223        self.assertTrue(con.ProgrammingError is drv.ProgrammingError)
     224        self.assertTrue(con.NotSupportedError is drv.NotSupportedError)
    225225
    226226    def test_commit(self):
     
    313313                self.table_prefix
    314314                ))
    315             self.failUnless(cur.rowcount in (-1,1),
     315            self.assertTrue(cur.rowcount in (-1,1),
    316316                'cursor.rowcount should == number or rows inserted, or '
    317317                'set to -1 after executing an insert statement'
    318318                )
    319319            cur.execute("select name from %sbooze" % self.table_prefix)
    320             self.failUnless(cur.rowcount in (-1,1),
     320            self.assertTrue(cur.rowcount in (-1,1),
    321321                'cursor.rowcount should == number of rows returned, or '
    322322                'set to -1 after executing a select statement'
     
    381381            self.table_prefix
    382382            ))
    383         self.failUnless(cur.rowcount in (-1,1))
     383        self.assertTrue(cur.rowcount in (-1,1))
    384384
    385385        if self.driver.paramstyle == 'qmark':
     
    410410        else:
    411411            self.fail('Invalid paramstyle')
    412         self.failUnless(cur.rowcount in (-1,1))
     412        self.assertTrue(cur.rowcount in (-1,1))
    413413
    414414        cur.execute('select name from %sbooze' % self.table_prefix)
     
    462462            else:
    463463                self.fail('Unknown paramstyle')
    464             self.failUnless(cur.rowcount in (-1,2),
     464            self.assertTrue(cur.rowcount in (-1,2),
    465465                'insert using cursor.executemany set cursor.rowcount to '
    466466                'incorrect value %r' % cur.rowcount
     
    497497                'no rows'
    498498                )
    499             self.failUnless(cur.rowcount in (-1,0))
     499            self.assertTrue(cur.rowcount in (-1,0))
    500500
    501501            # cursor.fetchone should raise an Error if called after
     
    517517                'cursor.fetchone should return None if no more rows available'
    518518                )
    519             self.failUnless(cur.rowcount in (-1,1))
     519            self.assertTrue(cur.rowcount in (-1,1))
    520520        finally:
    521521            con.close()
     
    573573                'results are exhausted'
    574574            )
    575             self.failUnless(cur.rowcount in (-1,6))
     575            self.assertTrue(cur.rowcount in (-1,6))
    576576
    577577            # Same as above, using cursor.arraysize
     
    586586            r = cur.fetchmany() # Should be an empty sequence
    587587            self.assertEqual(len(r),0)
    588             self.failUnless(cur.rowcount in (-1,6))
     588            self.assertTrue(cur.rowcount in (-1,6))
    589589
    590590            cur.arraysize=6
    591591            cur.execute('select name from %sbooze' % self.table_prefix)
    592592            rows = cur.fetchmany() # Should get all rows
    593             self.failUnless(cur.rowcount in (-1,6))
     593            self.assertTrue(cur.rowcount in (-1,6))
    594594            self.assertEqual(len(rows),6)
    595595            self.assertEqual(len(rows),6)
     
    608608                'called after the whole result set has been fetched'
    609609                )
    610             self.failUnless(cur.rowcount in (-1,6))
     610            self.assertTrue(cur.rowcount in (-1,6))
    611611
    612612            self.executeDDL2(cur)
     
    617617                'query retrieved no rows'
    618618                )
    619             self.failUnless(cur.rowcount in (-1,0))
     619            self.assertTrue(cur.rowcount in (-1,0))
    620620
    621621        finally:
     
    641641            cur.execute('select name from %sbooze' % self.table_prefix)
    642642            rows = cur.fetchall()
    643             self.failUnless(cur.rowcount in (-1,len(self.samples)))
     643            self.assertTrue(cur.rowcount in (-1,len(self.samples)))
    644644            self.assertEqual(len(rows),len(self.samples),
    645645                'cursor.fetchall did not retrieve all rows'
     
    657657                'after the whole result set has been fetched'
    658658                )
    659             self.failUnless(cur.rowcount in (-1,len(self.samples)))
     659            self.assertTrue(cur.rowcount in (-1,len(self.samples)))
    660660
    661661            self.executeDDL2(cur)
    662662            cur.execute('select name from %sbarflys' % self.table_prefix)
    663663            rows = cur.fetchall()
    664             self.failUnless(cur.rowcount in (-1,0))
     664            self.assertTrue(cur.rowcount in (-1,0))
    665665            self.assertEqual(len(rows),0,
    666666                'cursor.fetchall should return an empty list if '
     
    684684            rows4  = cur.fetchone()
    685685            rows56 = cur.fetchall()
    686             self.failUnless(cur.rowcount in (-1,6))
     686            self.assertTrue(cur.rowcount in (-1,6))
    687687            self.assertEqual(len(rows23),2,
    688688                'fetchmany returned incorrect number of rows'
     
    763763        try:
    764764            cur = con.cursor()
    765             self.failUnless(hasattr(cur,'arraysize'),
     765            self.assertTrue(hasattr(cur,'arraysize'),
    766766                'cursor.arraysize must be defined'
    767767                )
     
    832832
    833833    def test_STRING(self):
    834         self.failUnless(hasattr(self.driver,'STRING'),
     834        self.assertTrue(hasattr(self.driver,'STRING'),
    835835            'module.STRING must be defined'
    836836            )
    837837
    838838    def test_BINARY(self):
    839         self.failUnless(hasattr(self.driver,'BINARY'),
     839        self.assertTrue(hasattr(self.driver,'BINARY'),
    840840            'module.BINARY must be defined.'
    841841            )
    842842
    843843    def test_NUMBER(self):
    844         self.failUnless(hasattr(self.driver,'NUMBER'),
     844        self.assertTrue(hasattr(self.driver,'NUMBER'),
    845845            'module.NUMBER must be defined.'
    846846            )
    847847
    848848    def test_DATETIME(self):
    849         self.failUnless(hasattr(self.driver,'DATETIME'),
     849        self.assertTrue(hasattr(self.driver,'DATETIME'),
    850850            'module.DATETIME must be defined.'
    851851            )
    852852
    853853    def test_ROWID(self):
    854         self.failUnless(hasattr(self.driver,'ROWID'),
     854        self.assertTrue(hasattr(self.driver,'ROWID'),
    855855            'module.ROWID must be defined.'
    856856            )
  • trunk/module/pgdb.py

    r553 r599  
    7070from decimal import Decimal
    7171from math import isnan, isinf
     72
     73try:
     74    long
     75except NameError:  # Python >= 3.0
     76    long = int
     77
     78try:
     79    basestring
     80except NameError:  # Python >= 3.0
     81    basestring = (str, bytes)
    7282
    7383set_decimal(Decimal)
     
    229239        if isinstance(val, (datetime, date, time, timedelta)):
    230240            val = str(val)
    231         elif isinstance(val, unicode):
     241        elif isinstance(val, str) and str is not bytes:
    232242            val = val.encode('utf8')
    233         if isinstance(val, str):
     243        if isinstance(val, bytes):
    234244            if isinstance(val, Binary):
    235245                val = self._cnx.escape_bytea(val)
     
    595605    """
    596606
    597     if frozenset.__module__ == '__builtin__':
    598         def __new__(cls, values):
    599             if isinstance(values, basestring):
    600                 values = values.split()
    601             return super(pgdbType, cls).__new__(cls, values)
    602     else:  # Python < 2.4
    603         def __init__(self, values):
    604             if isinstance(values, basestring):
    605                 values = values.split()
    606             super(pgdbType, self).__init__(values)
     607    def __new__(cls, values):
     608        if isinstance(values, basestring):
     609            values = values.split()
     610        return super(pgdbType, cls).__new__(cls, values)
    607611
    608612    def __eq__(self, other):
Note: See TracChangeset for help on using the changeset viewer.