Ticket #1235: test_mysql_incompatibility.py

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""Unit test for incompatibility between MySQLdb 1.0 and MySQL 4.1+ as seen
on RHEL 4 (Update 4). The main problem is that the Timestamp format changed
in MySQL 4.1 and MySQLdb 1.0 does not support this MySQL version.

A detailled explanation can be found in the ticket #1235:
http://trac.turbogears.org/ticket/1235

This test requires a proper environment (RHEL 4.4) and a real MySQL 
environment which makes this a bit tedious to test.
""" 

import unittest

from sqlobject import MixedCaseStyle, SQLObject

from turbogears.database import PackageHub, _mysql_timestamp_converter
import turbogears

user = "root"
host = "localhost"
database_name = "test"

connection_string = "mysql://%s@%s/%s" % (user, host, database_name)
workaround_optionname = 'turbogears.enable_mysql41_timestamp_workaround'

MySQLdb = None
__connection__ = None
FooBarKlass = None


class TestTimestampWorkaround(unittest.TestCase):
    """Test that TurboGears has workarounds for incompatible MySQL
    libraries.""" 

    def delete_table(self):
        "Delete the table if it exists."
        self.cursor.execute("DROP TABLE IF EXISTS `FooBarObject`")


    def setup_database(self):
        "Create the table manually and inserts one item."
        if MySQLdb != None:
            self.connection = MySQLdb.connect(user=user, db=database_name, 
                                              host=host)
            self.cursor = self.connection.cursor()
            self.delete_table()
            self.cursor.execute("CREATE TABLE FooBarObject (" + 
                                "ID int(11) NOT NULL auto_increment PRIMARY KEY, "+
                                "time timestamp(14) NOT NULL)")
            self.cursor.execute("INSERT INTO FooBarObject SET time=NOW()")


    def define_class(self):
        """Define the SQLObject class dynamically so that the database 
        configuration can be done first in the setUp method (SQLObject has
        a class init method which tries to connect to the database as soon
        the class is being defined which causes problems in this test."""
        global FooBarKlass
        if FooBarKlass == None:
            class FooBarObject(SQLObject):
                class sqlmeta:
                    fromDatabase = True
                    style = MixedCaseStyle()
            FooBarKlass = FooBarObject 


    def load_mysql_module(self):
        "Loads the MySQLdb module but catches ImportErrors"
        global MySQLdb
        if MySQLdb is None:
            try:
                import MySQLdb
            except ImportError:
                # no MySQLdb module, do not execute this test 
                pass


    def prepare_mysql(self):
        """Install a package hub, setup a database, define the test class.
        This method should not be called from setUp but from the actual test
        case because the PackageHub does connect immediately and the 
        workaround configuration option must be set at this time already."""
        global __connection__
        if MySQLdb != None:
            self.hub = PackageHub("turbogears.mysql")
            __connection__ = self.hub
            self.setup_database()
            self.define_class()

            
    def setUp(self): # pylint: disable-msg=C0103,C0111
        self.load_mysql_module()
        self._original_configuration = \
            turbogears.config.get(workaround_optionname, False)
        self._original_dburi = turbogears.config.get('turbogears.mysql.dburi', None)
        turbogears.config.update({'turbogears.mysql.dburi': connection_string })
        self.cursor = None
        self.hub = None
       

    def tearDown(self): # pylint: disable-msg=C0103,C0111
        if MySQLdb != None:
            if self.cursor != None:
                self.delete_table()
                self.cursor.close()
                self.connection.close()
            if self.cursor != None:
                # Felix Schwarz: accessing private members is ugly, I know. But
                # we have to disable SQLObject's pooling in order to force it
                # really to make a new connection for every test case here!
                connection = self.hub.threadingLocal.connection._dbConnection
                connection._pool = None
                self.hub.reset()
            turbogears.config.update(
                {'turbogears.mysql.dburi': self._original_dburi,
                 workaround_optionname: self._original_configuration })


    def is_interesting_version(self):
        "Return True only if version of MySQLdb <= 1.0."
        module_version = MySQLdb.version_info[0:2]
        major = module_version[0]
        minor = module_version[1]
        # we can't use Decimal here because it is only available for Python 2.4
        return (major < 1 or (major == 1 and minor < 2))

    
    def test_timestamp_workarounds(self):
        """Test that TurboGears has custom converters for incompatible MySQL
        timestamp formats."""
        if MySQLdb != None and self.is_interesting_version():
            turbogears.config.update({ workaround_optionname: True })
            self.prepare_mysql()
            for i in FooBarKlass.select():
                pass
                
    def test_timestamp_configuration(self):
        "Test that the configuration must be explicitely enabled."
        self.prepare_mysql()
        if MySQLdb != None and self.is_interesting_version():
            try:
                for i in FooBarKlass.select(): pass
                self.fail("No exception although no workaround was enabled.")
            except ValueError, e:
                self.assertEqual("invalid literal for int(): 1-", e.args[0] )

    def test_converter(self):
        "Test that the actual converter function is ok."
        self.assertEquals(1168789874.0, 
                          _mysql_timestamp_converter("2007-01-14 16:51:14"))
        # Felix Schwarz: I'm not quite sure about this format, never saw it 
        # myself but got it from http://bugs.mysql.com/bug.php?id=20288 so I
        # think it is correct. 
        # The second assertion ensures that connecting to old databases is 
        # still okay.
        self.assertEquals(1168789874.0, 
                          _mysql_timestamp_converter("20070114165114"))
        

if __name__ == "__main__":
    unittest.main()