add tests for low level util.py

migrate/versioning/schema.py

@@ -8,7 +8,7 @@ from sqlalchemy import exceptions as sa_exceptions
 
 from migrate.versioning import exceptions, genmodel, schemadiff
 from migrate.versioning.repository import Repository
-from migrate.versioning.util import loadModel
+from migrate.versioning.util import load_model
 from migrate.versioning.version import VerNum
 
 
@@ -121,7 +121,7 @@ class ControlledSchema(object):
         """
         if isinstance(repository, basestring):
             repository=Repository(repository)
-        model = loadModel(model)
+        model = load_model(model)
         diff = schemadiff.getDiffOfModelAgainstDatabase(
             model, engine, excludeTables=[repository.version_table])
         return diff
@@ -143,7 +143,7 @@ class ControlledSchema(object):
         """
         if isinstance(self.repository, basestring):
             self.repository=Repository(self.repository)
-        model = loadModel(model)
+        model = load_model(model)
         diff = schemadiff.getDiffOfModelAgainstDatabase(
             model, self.engine, excludeTables=[self.repository.version_table])
         genmodel.ModelGenerator(diff).applyModel()

migrate/versioning/script/py.py

@@ -9,7 +9,7 @@ from migrate.versioning import exceptions, genmodel, schemadiff
 from migrate.versioning.base import operations
 from migrate.versioning.template import template
 from migrate.versioning.script import base
-from migrate.versioning.util import import_path, loadModel, construct_engine
+from migrate.versioning.util import import_path, load_model, construct_engine
 
 class PythonScript(base.BaseScript):
 
@@ -35,8 +35,8 @@ class PythonScript(base.BaseScript):
             # oh dear, an import cycle!
             from migrate.versioning.repository import Repository
             repository = Repository(repository)
-        oldmodel = loadModel(oldmodel)
-        model = loadModel(model)
+        oldmodel = load_model(oldmodel)
+        model = load_model(model)
         diff = schemadiff.getDiffOfModelAgainstModel(
             oldmodel,
             model,

migrate/versioning/script/sql.py

@@ -2,7 +2,7 @@ from migrate.versioning.script import base
 
 class SqlScript(base.BaseScript):
     """A file containing plain SQL statements."""
-    def run(self,engine,step):
+    def run(self, engine, step):
         text = self.source()
         # Don't rely on SA's autocommit here
         # (SA uses .startswith to check if a commit is needed. What if script

migrate/versioning/util/__init__.py

@@ -12,7 +12,7 @@ from migrate.versioning.util.keyedinstance import KeyedInstance
 from migrate.versioning.util.importpath import import_path
 
 
-def loadModel(dotted_name):
+def load_model(dotted_name):
     ''' Import module and use module-level variable -- assume model is of form "mod1.mod2:varname". '''
     if isinstance(dotted_name, basestring):
         if ':' not in dotted_name:
@@ -45,13 +45,13 @@ def guess_obj_type(obj):
     result = None
 
     try:
-        result = asbool(obj)
+        result = int(obj)
     except:
         pass
 
     if result is None:
         try:
-            result = int(obj)
+            result = asbool(obj)
         except:
             pass
 

test/versioning/test_shell.py

@@ -159,26 +159,6 @@ class TestShellCommands(Shell):
         self.assert_(os.path.exists('%s/versions/002_postgres_upgrade.sql' % repos))
         self.assert_(os.path.exists('%s/versions/002_postgres_downgrade.sql' % repos))
 
-    def test_construct_engine(self):
-        """Construct engine the smart way"""
-        url = 'sqlite://'
-
-        engine = api.construct_engine(url)
-        self.assert_(engine.name == 'sqlite')
-
-        # keyword arg
-        engine = api.construct_engine(url, engine_arg_assert_unicode=True)
-        self.assertTrue(engine.dialect.assert_unicode)
-
-        # dict
-        engine = api.construct_engine(url, engine_dict={'assert_unicode': True})
-        self.assertTrue(engine.dialect.assert_unicode)
-
-        # test precedance
-        engine = api.construct_engine(url, engine_dict={'assert_unicode': False},
-            engine_arg_assert_unicode=True)
-        self.assertTrue(engine.dialect.assert_unicode)
-
     def test_manage(self):
         """Create a project management script"""
         script = self.tmp_py()

test/versioning/test_util.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from test import fixture
+from migrate.versioning.util import *
+
+
+class TestUtil(fixture.Pathed):
+
+    def test_construct_engine(self):
+        """Construct engine the smart way"""
+        url = 'sqlite://'
+
+        engine = construct_engine(url)
+        self.assert_(engine.name == 'sqlite')
+
+        # keyword arg
+        engine = construct_engine(url, engine_arg_assert_unicode=True)
+        self.assertTrue(engine.dialect.assert_unicode)
+
+        # dict
+        engine = construct_engine(url, engine_dict={'assert_unicode': True})
+        self.assertTrue(engine.dialect.assert_unicode)
+
+        # test precedance
+        engine = construct_engine(url, engine_dict={'assert_unicode': False},
+            engine_arg_assert_unicode=True)
+        self.assertTrue(engine.dialect.assert_unicode)
+
+        # deprecated echo= parameter
+        engine = construct_engine(url, echo='True')
+        self.assertTrue(engine.echo)
+
+    def test_asbool(self):
+        """test asbool parsing"""
+        result = asbool(True)
+        self.assertEqual(result, True)
+
+        result = asbool(False)
+        self.assertEqual(result, False)
+
+        result = asbool('y')
+        self.assertEqual(result, True)
+
+        result = asbool('n')
+        self.assertEqual(result, False)
+
+        self.assertRaises(ValueError, asbool, 'test')
+        self.assertRaises(ValueError, asbool, object)
+
+
+    def test_load_model(self):
+        """load model from dotted name"""
+        model_path = self.tmp_named('testmodel.py')
+
+        f = open(model_path, 'w')
+        f.write("class FakeFloat(int): pass")
+        f.close()
+
+        FakeFloat = load_model('testmodel.FakeFloat')
+        self.assert_(isinstance(FakeFloat(), int))
+
+        FakeFloat = load_model('testmodel:FakeFloat')
+        self.assert_(isinstance(FakeFloat(), int))
+
+        FakeFloat = load_model(FakeFloat)
+        self.assert_(isinstance(FakeFloat(), int))
+
+    def test_guess_obj_type(self):
+        """guess object type from string"""
+        result = guess_obj_type('7')
+        self.assertEqual(result, 7)
+
+        result = guess_obj_type('y')
+        self.assertEqual(result, True)
+
+        result = guess_obj_type('test')
+        self.assertEqual(result, 'test')

test/versioning/test_version.py

@@ -1,6 +1,10 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
 from test import fixture
 from migrate.versioning.version import *
 
+
 class TestVerNum(fixture.Base):
     def test_invalid(self):
         """Disallow invalid version numbers"""