django: Replace south with django.db.migrations

Update tests accordingly.

3 files changed, 110 insertions, 127 deletions

diff --git a/semantic_version/django_fields.py b/semantic_version/django_fields.py
index 599929a..478cf7b 100644
--- a/semantic_version/django_fields.py
+++ b/semantic_version/django_fields.py
@@ -58,6 +58,13 @@ class VersionField(SemVerField):
         self.coerce = kwargs.pop('coerce', False)
         super(VersionField, self).__init__(*args, **kwargs)
 
+    def deconstruct(self):
+        """Handle django.db.migrations."""
+        name, path, args, kwargs = super(VersionField, self).deconstruct()
+        kwargs['partial'] = self.partial
+        kwargs['coerce'] = self.coerce
+        return name, path, args, kwargs
+
     def to_python(self, value):
         """Converts any value to a base.Version field."""
         if value is None or value == '':
@@ -83,27 +90,3 @@ class SpecField(SemVerField):
         if isinstance(value, base.Spec):
             return value
         return base.Spec(value)
-
-
-def add_south_rules():
-    from south.modelsinspector import add_introspection_rules
-
-    add_introspection_rules([
-        (
-            (VersionField,),
-            [],
-            {
-                'partial': ('partial', {'default': False}),
-                'coerce': ('coerce', {'default': False}),
-            },
-        ),
-    ], ["semantic_version\.django_fields"])
-
-
-try:  # pragma: no cover
-    import south
-except ImportError:  # pragma: no cover
-    south = None
-
-if south:  # pragma: no cover
-    add_south_rules()
diff --git a/tests/setup_django.py b/tests/setup_django.py
new file mode 100644
index 0000000..e0469bc
--- /dev/null
+++ b/tests/setup_django.py
@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) The python-semanticversion project
+
+try:  # pragma: no cover
+    import django
+    django_loaded = True
+except ImportError:  # pragma: no cover
+    django_loaded = False
+    django = None
+
+
+if django_loaded:
+    from django.conf import settings
+    if not settings.configured:
+        settings.configure(
+            DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3'}},
+            INSTALLED_APPS=['tests.django_test_app'],
+            MIDDLEWARE_CLASSES=[],
+        )
+    django.setup()
+
diff --git a/tests/test_django.py b/tests/test_django.py
index 478c657..93ea810 100644
--- a/tests/test_django.py
+++ b/tests/test_django.py
@@ -4,31 +4,54 @@
 
 from __future__ import unicode_literals
 
-try:  # pragma: no cover
-    import unittest2 as unittest
-except ImportError:  # pragma: no cover
-    import unittest
-
+import unittest
 import semantic_version
 
-try:  # pragma: no cover
+from .setup_django import django_loaded
+
+
+if django_loaded:  # pragma: no cover
+    from semantic_version import django_fields
+    from .django_test_app import models
+
     import django
     from django.conf import settings
-    from .django_test_app import models
     from django.core import serializers
-    django_loaded = True
-except ImportError:  # pragma: no cover
-    django_loaded = False
-
-south = None
-# south has reached end of life, and it does not work with django 1.7 and newer
-if django_loaded and django.VERSION < (1, 7):  # pragma: no cover
-    try:
-        import south
-        import south.creator.freezer
-        import south.modelsinspector
-    except ImportError:
-        pass
+    from django.core.management import call_command
+    from django.db import connection
+    from django.test import TestCase as DjangoTestCase
+    from django.test import TransactionTestCase
+    from django.test import runner as django_test_runner
+    from django.test import utils as django_test_utils
+
+else:
+    DjangoTestCase = unittest.TestCase
+    TransactionTestCase = unittest.TestCase
+
+
+test_state = {}
+
+
+def setUpModule():
+    if not django_loaded:  # pragma: no cover
+        raise unittest.SkipTest("Django not installed")
+    django_test_utils.setup_test_environment()
+    runner = django_test_runner.DiscoverRunner()
+    runner_state = runner.setup_databases()
+    test_state.update({
+        'runner': runner,
+        'runner_state': runner_state,
+    })
+
+
+def tearDownModule():
+    if not django_loaded:  # pragma: no cover
+        return
+    runner = test_state['runner']
+    runner_state = test_state['runner_state']
+    runner.teardown_databases(runner_state)
+    django_test_utils.teardown_test_environment()
+
 
 # the refresh_from_db method only came in with 1.8, so in order to make this
 # work will all supported versions we have our own function.
@@ -183,95 +206,51 @@ class DjangoFieldTestCase(unittest.TestCase):
         self.assertEqual(o2.optional, obj2.object.optional)
 
 
-@unittest.skipIf(not django_loaded or south is None, "Couldn't import south and django")
-class SouthTestCase(unittest.TestCase):
-    def test_freezing_version_model(self):
-        frozen = south.modelsinspector.get_model_fields(models.VersionModel)
-
-        self.assertEqual(frozen['version'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200'}))
-
-        self.assertEqual(frozen['spec'],
-            ('semantic_version.django_fields.SpecField', [], {'max_length': '200'}))
-
-    def test_freezing_partial_version_model(self):
-        frozen = south.modelsinspector.get_model_fields(models.PartialVersionModel)
-
-        self.assertEqual(frozen['partial'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'partial': 'True'}))
-
-        self.assertEqual(frozen['optional'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'blank': 'True', 'null': 'True'}))
-
-        self.assertEqual(frozen['optional_spec'],
-            ('semantic_version.django_fields.SpecField', [], {'max_length': '200', 'blank': 'True', 'null': 'True'}))
-
-    def test_freezing_coerce_version_model(self):
-        frozen = south.modelsinspector.get_model_fields(models.CoerceVersionModel)
-
-        self.assertEqual(frozen['version'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'coerce': 'True'}))
-
-        self.assertEqual(frozen['partial'],
-                ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'partial': 'True', 'coerce': 'True'}))
-
-    def test_freezing_app(self):
-        frozen = south.creator.freezer.freeze_apps('django_test_app')
-
-        # Test VersionModel
-        self.assertEqual(frozen['django_test_app.versionmodel']['version'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200'}))
-
-        self.assertEqual(frozen['django_test_app.versionmodel']['spec'],
-            ('semantic_version.django_fields.SpecField', [], {'max_length': '200'}))
-
-        # Test PartialVersionModel
-        self.assertEqual(frozen['django_test_app.partialversionmodel']['partial'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'partial': 'True'}))
-
-        self.assertEqual(frozen['django_test_app.partialversionmodel']['optional'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'blank': 'True', 'null': 'True'}))
-
-        self.assertEqual(frozen['django_test_app.partialversionmodel']['optional_spec'],
-            ('semantic_version.django_fields.SpecField', [], {'max_length': '200', 'blank': 'True', 'null': 'True'}))
-
-        # Test CoerceVersionModel
-        self.assertEqual(frozen['django_test_app.coerceversionmodel']['version'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'coerce': 'True'}))
-
-        self.assertEqual(frozen['django_test_app.coerceversionmodel']['partial'],
-            ('semantic_version.django_fields.VersionField', [], {'max_length': '200', 'partial': 'True', 'coerce': 'True'}))
-
+@unittest.skipIf(not django_loaded, "Django not installed")
+class FieldMigrationTests(DjangoTestCase):
+    def test_version_field(self):
+        field = django_fields.VersionField(
+            partial=True,
+            coerce=True,
+        )
+        self.assertEqual(
+            field.deconstruct()[3],
+            {'coerce': True, 'partial': True, 'max_length': 200},
+        )
 
-if django_loaded:
-    from django.test import TestCase
-    if django.VERSION[:2] < (1, 6):
-        from django.test.simple import DjangoTestSuiteRunner as TestRunner
-    else:
-        from django.test.runner import DiscoverRunner as TestRunner
+    def test_spec_field(self):
+        field = django_fields.SpecField()
+        self.assertEqual(
+            field.deconstruct()[3],
+            {'max_length': 200},
+        )
 
-    class DbInteractingTestCase(TestCase):
 
-        @classmethod
-        def setUpClass(cls):
-            cls.old_state = TestRunner().setup_databases()
+@unittest.skipIf(not django_loaded, "Django not installed")
+class FullMigrateTests(TransactionTestCase):
+    def test_migrate(self):
+        # Let's check that this does not crash
+        call_command('makemigrations', verbosity=0)
+        call_command('migrate', verbosity=0)
+        with connection.cursor() as cursor:
+            table_list = connection.introspection.get_table_list(cursor)
+            if django.VERSION[:2] >= (1, 8):
+                table_list = [t.name for t in connection.introspection.get_table_list(cursor)]
+            self.assertIn('django_test_app_versionmodel', table_list)
 
-        @classmethod
-        def tearDownClass(cls):
-            TestRunner().teardown_databases(cls.old_state)
 
-        def test_db_interaction(self):
-            o1 = models.VersionModel(version=Version('0.1.1'), spec=Spec('<0.2.4-rc42'))
-            o2 = models.VersionModel(version=Version('0.4.3-rc3+build3'), spec=Spec('==0.4.3'))
+@unittest.skipIf(not django_loaded, "Django not installed")
+class DbInteractingTestCase(DjangoTestCase):
 
-            o1.save()
-            o2.save()
+    def test_db_interaction(self):
+        o1 = models.VersionModel(version=Version('0.1.1'), spec=Spec('<0.2.4-rc42'))
+        o2 = models.VersionModel(version=Version('0.4.3-rc3+build3'), spec=Spec('==0.4.3'))
 
-            obj1 = models.VersionModel.objects.get(pk=o1.pk)
-            self.assertEqual(o1.version, obj1.version)
+        o1.save()
+        o2.save()
 
-            obj2 = models.VersionModel.objects.get(pk=o2.pk)
-            self.assertEqual(o2.version, obj2.version)
+        obj1 = models.VersionModel.objects.get(pk=o1.pk)
+        self.assertEqual(o1.version, obj1.version)
 
-else:  # pragma: no cover
-    pass
+        obj2 = models.VersionModel.objects.get(pk=o2.pk)
+        self.assertEqual(o2.version, obj2.version)