From a924bfe40ab1acbd6b5831819dcbc8d502896f82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Barrois?= Date: Thu, 1 Sep 2016 14:17:44 +0200 Subject: django: Replace south with django.db.migrations Update tests accordingly. --- semantic_version/django_fields.py | 31 ++----- tests/setup_django.py | 21 +++++ tests/test_django.py | 185 +++++++++++++++++--------------------- 3 files changed, 110 insertions(+), 127 deletions(-) create mode 100644 tests/setup_django.py 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) -- cgit v1.2.1