Changeset 690 for branches/4.x


Ignore:
Timestamp:
Jan 2, 2016, 6:25:14 PM (4 years ago)
Author:
cito
Message:

Amend tests so that they can run with PostgreSQL < 9.0

Note that we do not need to make these amendments in the trunk,
because we assume PostgreSQL >= 9.0 for PyGreSQL version 5.0.

Location:
branches/4.x/module
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/4.x/module/pg.py

    r663 r690  
    198198        a different database connection to avoid a collision.
    199199
     200        The payload parameter is only supported in PostgreSQL >= 9.0.
     201
    200202        """
    201203        if not db:
  • branches/4.x/module/setup.py

    r653 r690  
    129129        if self.default_vars:
    130130            define_macros.append(('DEFAULT_VARS', None))
    131         if self.escaping_funcs:
     131        if self.escaping_funcs and pg_version[0] >= 9:
    132132            define_macros.append(('ESCAPING_FUNCS', None))
    133133        if sys.platform == 'win32':
    134134            bits = platform.architecture()[0]
    135             if bits == '64bit': # we need to find libpq64
     135            if bits == '64bit':  # we need to find libpq64
    136136                for path in os.environ['PATH'].split(os.pathsep) + [
    137137                        r'C:\Program Files\PostgreSQL\libpq64']:
     
    150150                    if include_dir not in include_dirs:
    151151                        include_dirs.insert(1, include_dir)
    152                     libraries[0] += 'dll' # libpqdll instead of libpq
     152                    libraries[0] += 'dll'  # libpqdll instead of libpq
    153153                    break
    154154            compiler = self.get_compiler()
    155             if compiler == 'mingw32': # MinGW
    156                 if bits == '64bit': # needs MinGW-w64
     155            if compiler == 'mingw32':  # MinGW
     156                if bits == '64bit':  # needs MinGW-w64
    157157                    define_macros.append(('MS_WIN64', None))
    158             elif compiler == 'msvc': # Microsoft Visual C++
     158            elif compiler == 'msvc':  # Microsoft Visual C++
    159159                libraries[0] = 'lib' + libraries[0]
    160160
     
    164164    version=version,
    165165    description="Python PostgreSQL Interfaces",
    166     long_description=__doc__.split('\n\n', 2)[1], # first passage
     166    long_description=__doc__.split('\n\n', 2)[1],  # first passage
    167167    keywords="pygresql postgresql database api dbapi",
    168168    author="D'Arcy J. M. Cain",
  • branches/4.x/module/tests/test_classic.py

    r650 r690  
    250250        two_payloads = options.get('two_payloads')
    251251        db = opendb()
     252        if db.server_version < 90000:  # PostgreSQL < 9.0
     253            self.skipTest('Notify with payload not supported')
    252254        # Get function under test, can be standalone or DB method.
    253255        if run_as_method:
     
    337339        for run_as_method in False, True:
    338340            db = opendb()
     341            if db.server_version < 90000:  # PostgreSQL < 9.0
     342                self.skipTest('Notify with payload not supported')
    339343            # Get function under test, can be standalone or DB method.
    340344            if run_as_method:
  • branches/4.x/module/tests/test_classic_connection.py

    r650 r690  
    8787            inserttable locreate loimport parameter putline query reset
    8888            set_notice_receiver source transaction'''.split()
     89        if self.connection.server_version < 90000:  # PostgreSQL < 9.0
     90            methods.remove('escape_identifier')
     91            methods.remove('escape_literal')
    8992        connection_methods = [a for a in dir(self.connection)
    9093            if callable(eval("self.connection." + a))]
     
    559562        self.assertEqual(query("select 1, $1::integer", (2,)
    560563            ).getresult(), [(1, 2)])
    561         self.assertEqual(query("select 1 union select $1", (2,)
     564        self.assertEqual(query("select 1 union select $1::integer", (2,)
    562565            ).getresult(), [(1,), (2,)])
    563566        self.assertEqual(query("select $1::integer+$2", (1, 2)
     
    817820                if i < n:
    818821                    self.assertEqual(v, '%d\t%s' % data[i])
    819                 elif i == n:
     822                elif i == n or self.c.server_version < 90000:
    820823                    self.assertEqual(v, '\\.')
    821824                else:
     
    843846
    844847    def testGetNotify(self):
     848        if self.c.server_version < 90000:  # PostgreSQL < 9.0
     849            self.skipTest('Notify with payload not supported')
    845850        getnotify = self.c.getnotify
    846851        query = self.c.query
     
    859864            self.assertEqual(r[2], '')
    860865            self.assertIsNone(self.c.getnotify())
    861             try:
    862                 query("notify test_notify, 'test_payload'")
    863             except pg.ProgrammingError:  # PostgreSQL < 9.0
    864                 pass
    865             else:
    866                 r = getnotify()
    867                 self.assertTrue(isinstance(r, tuple))
    868                 self.assertEqual(len(r), 3)
    869                 self.assertIsInstance(r[0], str)
    870                 self.assertIsInstance(r[1], int)
    871                 self.assertIsInstance(r[2], str)
    872                 self.assertEqual(r[0], 'test_notify')
    873                 self.assertEqual(r[2], 'test_payload')
    874                 self.assertIsNone(getnotify())
     866            query("notify test_notify, 'test_payload'")
     867            r = getnotify()
     868            self.assertTrue(isinstance(r, tuple))
     869            self.assertEqual(len(r), 3)
     870            self.assertIsInstance(r[0], str)
     871            self.assertIsInstance(r[1], int)
     872            self.assertIsInstance(r[2], str)
     873            self.assertEqual(r[0], 'test_notify')
     874            self.assertEqual(r[2], 'test_payload')
     875            self.assertIsNone(getnotify())
    875876        finally:
    876877            query('unlisten test_notify')
     
    984985        de_locales = 'de', 'de_DE', 'de_DE.utf8', 'de_DE.UTF-8'
    985986        de_money = ('34,25€', '34,25 €', '€34,25' '€ 34,25',
    986             '34,25 EUR', '34,25 Euro', '34,25 DM')
     987            'EUR34,25', 'EUR 34,25', '34,25 EUR', '34,25 Euro', '34,25 DM')
    987988        # first try with English localization (using the point)
    988989        for lc in en_locales:
  • branches/4.x/module/tests/test_classic_dbwrapper.py

    r650 r690  
    121121            'user',
    122122        ]
     123        if self.db.server_version < 90000:  # PostgreSQL < 9.0
     124            attributes.remove('escape_identifier')
     125            attributes.remove('escape_literal')
    123126        db_attributes = [a for a in dir(self.db)
    124127            if not a.startswith('_')]
     
    191194
    192195    def testMethodEscapeLiteral(self):
     196        if self.db.server_version < 90000:  # PostgreSQL < 9.0
     197            self.skipTest('Escaping functions not supported')
    193198        self.assertEqual(self.db.escape_literal(''), "''")
    194199
    195200    def testMethodEscapeIdentifier(self):
     201        if self.db.server_version < 90000:  # PostgreSQL < 9.0
     202            self.skipTest('Escaping functions not supported')
    196203        self.assertEqual(self.db.escape_identifier(''), '""')
    197204
     
    290297        query('set client_encoding=utf8')
    291298        query('set standard_conforming_strings=on')
    292         query('set bytea_output=hex')
    293299        query("set lc_monetary='C'")
     300        query("set datestyle='ISO,YMD'")
     301        try:
     302            query('set bytea_output=hex')
     303        except pg.ProgrammingError:  # PostgreSQL < 9.0
     304            pass
    294305
    295306    def tearDown(self):
     
    297308
    298309    def testEscapeLiteral(self):
     310        if self.db.server_version < 90000:  # PostgreSQL < 9.0
     311            self.skipTest('Escaping functions not supported')
    299312        f = self.db.escape_literal
    300313        self.assertEqual(f("plain"), "'plain'")
     
    306319
    307320    def testEscapeIdentifier(self):
     321        if self.db.server_version < 90000:  # PostgreSQL < 9.0
     322            self.skipTest('Escaping functions not supported')
    308323        f = self.db.escape_identifier
    309324        self.assertEqual(f("plain"), '"plain"')
     
    323338    def testEscapeBytea(self):
    324339        f = self.db.escape_bytea
    325         # note that escape_byte always returns hex output since Pg 9.0,
     340        # note that escape_byte always returns hex output since PostgreSQL 9.0,
    326341        # regardless of the bytea_output setting
    327         self.assertEqual(f("plain"), r"\x706c61696e")
    328         self.assertEqual(f("that's k\xe4se"), r"\x746861742773206be47365")
    329         self.assertEqual(f('O\x00ps\xff!'), r"\x4f007073ff21")
     342        if self.db.server_version < 90000:
     343            self.assertEqual(f("plain"), r"plain")
     344            self.assertEqual(f("that's k\xe4se"), r"that''s k\344se")
     345            self.assertEqual(f('O\x00ps\xff!'), r"O\000ps\377!")
     346        else:
     347            self.assertEqual(f("plain"), r"\x706c61696e")
     348            self.assertEqual(f("that's k\xe4se"), r"\x746861742773206be47365")
     349            self.assertEqual(f('O\x00ps\xff!'), r"\x4f007073ff21")
    330350
    331351    def testUnescapeBytea(self):
     
    690710        insert = self.db.insert
    691711        query = self.db.query
     712        server_version = self.db.server_version
    692713        for table in ('insert_test_table', 'test table for insert'):
    693714            query('drop table if exists "%s"' % table)
     
    717738                dict(m=None), (dict(m=''), dict(m=None)),
    718739                dict(m=Decimal('-1234.56')),
    719                 (dict(m=('-1234.56')), dict(m=Decimal('-1234.56'))),
     740                (dict(m='-1234.56'), dict(m=Decimal('-1234.56'))),
    720741                dict(m=Decimal('1234.56')), dict(m=Decimal('123456')),
    721742                (dict(m='1234.56'), dict(m=Decimal('1234.56'))),
     
    752773                expect = data.copy()
    753774                expect.update(change)
     775                if data.get('m') and server_version < 910000:
     776                    # PostgreSQL < 9.1 cannot directly convert numbers to money
     777                    data['m'] = "'%s'::money" % data['m']
    754778                self.assertEqual(insert(table, data), data)
    755779                self.assertIn(oid_table, data)
  • branches/4.x/module/tests/test_dbapi20.py

    r667 r690  
    8686        try:
    8787            cur = con.cursor()
     88            cur.execute("set datestyle to 'iso'")
    8889            cur.execute("create table %s ("
    8990                "stringtest varchar,"
Note: See TracChangeset for help on using the changeset viewer.