django-dbdiff 0.9.6__py3-none-any.whl

dbdiff/tests/project/settings.py

@@ -0,0 +1,107 @@
+"""
+Django settings for project project.
+
+Generated by 'django-admin startproject' using Django 1.8.3.dev20150604012123.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/dev/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/dev/ref/settings/
+"""
+
+# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
+import os
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/dev/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = '9kq$zffboob0)(sn_mr+^cw*3hair=vp=@616u#gk!31dymqgo'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = []
+
+
+# Application definition
+
+INSTALLED_APPS = (
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'dbdiff',
+
+    'dbdiff.tests.decimal_test',
+    'dbdiff.tests.nonintpk',
+    'dbdiff.tests.inheritance',
+)
+
+MIDDLEWARE_CLASSES = (
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+)
+
+ROOT_URLCONF = 'dbdiff.tests.project.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'dbdiff.tests.project.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/dev/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
+    }
+}
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/dev/topics/i18n/
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_L10N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/dev/howto/static-files/
+
+STATIC_URL = '/static/'

dbdiff/tests/project/settings_mysql.py

@@ -0,0 +1,21 @@
+from .settings import *  # noqa
+
+import os
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.mysql',
+        'HOST': os.environ.get('DB_HOST', ''),
+        'NAME': os.environ.get('DB_NAME', 'dbdiff_test'),
+        'USER': os.environ.get('DB_USER', 'root'),
+        'PASSWORD': os.environ.get('DB_PASSWORD', ''),
+        'PORT': os.environ.get('DB_PORT', ''),
+        'OPTIONS': {
+            'charset': 'utf8mb4',
+        },
+        'TEST':{
+            'CHARSET': 'utf8mb4',
+            'COLLATION': 'utf8mb4_unicode_ci',
+        }
+    }
+}

dbdiff/tests/project/settings_postgresql.py

@@ -0,0 +1,16 @@
+from .settings import *  # noqa
+
+import os
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.postgresql_psycopg2',
+        'HOST': os.environ.get('DB_HOST', ''),
+        'NAME': os.environ.get('DB_NAME', 'dbdiff_test'),
+        'USER': os.environ.get('DB_USER', 'postgres'),
+        'PASSWORD': os.environ.get('DB_PASSWORD', ''),
+        'PORT': os.environ.get('DB_PORT', '5432'),
+        'OPTIONS': {},
+        
+    }
+}

dbdiff/tests/project/settings_sqlite.py

@@ -0,0 +1,8 @@
+from .settings import *  # noqa
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': ':memory:',
+    }
+}

dbdiff/tests/project/urls.py

@@ -0,0 +1 @@
+urlpatterns = []

dbdiff/tests/test_compare.py

@@ -0,0 +1,102 @@
+"""Public API tests."""
+
+import os
+import tempfile
+
+from django import test
+from django.contrib.auth.models import Group
+
+from ..exceptions import DiffFound, FixtureCreated
+from ..fixture import Fixture
+
+
+class SmokeTest(test.TransactionTestCase):
+    def setUp(self):
+        fd, self.fixture_path = tempfile.mkstemp(suffix='_dbdiff')
+
+    def test_000_fixture_auto_create(self):
+        fixture = Fixture(self.fixture_path, models=[Group])
+
+        # Should auto-create the diff
+        if fixture.exists:
+            os.unlink(fixture.path)
+
+        Group.objects.create(name='testgroup')
+
+        with self.assertRaises(FixtureCreated):
+            fixture.assertNoDiff()
+
+        assert fixture.exists
+
+        with open(self.fixture_path, 'r') as f:
+            result = f.read()
+
+        expected = '''[
+{
+    "fields": {
+        "name": "testgroup",
+        "permissions": []
+    },
+    "model": "auth.group",
+    "pk": 1
+}
+]'''
+
+        assert expected.strip() == result.strip()
+
+        # It should pass now
+        fixture.assertNoDiff()
+
+        # It should break now !
+        Group.objects.all().update(name='BOOM')
+        expected = '''
+1 instance(s) of auth.group have not expected fields
+#1:
+  name:
+- 'testgroup'
++ 'BOOM'
+'''
+
+        with self.assertRaises(DiffFound) as result:
+            fixture.assertNoDiff()
+        self.assert_message_is(expected, result)
+
+        # Excluding the name parameter, there should be no diff
+        fixture.assertNoDiff(exclude={'auth.group': ['name']})
+
+        # Assert it finds unexpected model
+        Group.objects.create(name='unexpected')
+        expected = '''
+1 unexpected instance(s) of auth.group found in the dump:
+#2:
+{'name': 'unexpected', 'permissions': []}
+1 instance(s) of auth.group have not expected fields
+#1:
+  name:
+- 'testgroup'
++ 'BOOM'
+'''
+
+        with self.assertRaises(DiffFound) as result:
+            fixture.assertNoDiff()
+        self.assert_message_is(expected, result)
+
+        # Assert it finds missing model
+        Group.objects.get(pk=1).delete()
+        expected = '''
+1 unexpected instance(s) of auth.group found in the dump:
+#2:
+{'name': 'unexpected', 'permissions': []}
+1 expected instance(s) of auth.group missing from dump:
+#1:
+{'name': 'testgroup', 'permissions': []}
+'''
+
+        with self.assertRaises(DiffFound) as result:
+            fixture.assertNoDiff()
+        self.assert_message_is(expected, result)
+
+    def assert_message_is(self, expected, result):
+        msg = result.exception.args[0]
+        out = '\n'.join(msg.split('\n')[1:])
+        assert out.strip() == expected.strip()

dbdiff/tests/test_decimal.py

@@ -0,0 +1,54 @@
+import os
+
+from django import test
+
+from .decimal_test.models import TestModel as DecimalTestModel
+from ..fixture import Fixture
+
+
+class DecimalDiffTest(test.TransactionTestCase):
+    reset_sequences = True
+
+    expected = os.path.join(
+        'dbdiff',
+        'tests',
+        'decimal_test',
+        'expected.json'
+    )
+    model = DecimalTestModel
+
+    def test_data_diff_is_empty_with_two_decimal_float(self):
+        self.model.objects.create(test_field=1.10)
+        Fixture(self.expected).assertNoDiff()
+
+    def test_data_diff_is_empty_with_one_decimal_float(self):
+        self.model.objects.create(test_field=1.1)
+        Fixture(self.expected).assertNoDiff()
+
+    def test_data_diff_is_empty_with_two_decimal_string(self):
+        self.model.objects.create(test_field='1.10')
+        Fixture(self.expected).assertNoDiff()
+
+    def test_data_diff_is_empty_with_one_decimal_string(self):
+        self.model.objects.create(test_field='1.1')
+        Fixture(self.expected).assertNoDiff()
+
+
+class NoReminderDecimalDiffTest(test.TransactionTestCase):
+    reset_sequences = True
+
+    expected = os.path.join(
+        'dbdiff',
+        'tests',
+        'decimal_test',
+        'expected_no_reminder.json'
+    )
+    model = DecimalTestModel
+
+    def test_data_diff_is_empty_with_no_decimal_string(self):
+        self.model.objects.create(test_field=10)
+        Fixture(self.expected).assertNoDiff()
+
+    def test_data_diff_is_empty_with_no_decimal_int(self):
+        self.model.objects.create(test_field='10')
+        Fixture(self.expected).assertNoDiff()

dbdiff/tests/test_fixture.py

@@ -0,0 +1,25 @@
+import os
+
+from django import test
+from django.contrib.auth.models import Group
+
+from ..fixture import Fixture
+
+
+class FixtureTest(test.TransactionTestCase):
+    def setUp(self):
+        self.fixture = Fixture('dbdiff/fixtures/dbdiff_test_group.json')
+
+    def test_fixture_path(self):
+        assert self.fixture.path == os.path.abspath(os.path.join(
+            os.path.dirname(__file__),
+            '..',
+            'fixtures',
+            'dbdiff_test_group.json'
+        ))
+
+    def test_indent(self):
+        assert self.fixture.indent == 4
+
+    def test_models(self):
+        assert self.fixture.models == [Group]

dbdiff/tests/test_mixin.py

@@ -0,0 +1,22 @@
+from dbdiff.test import DbdiffTestMixin
+
+from django import test
+from django.contrib.contenttypes.models import ContentType
+from django.db import connection
+
+
+class ContentTypeTestCase(DbdiffTestMixin, test.TestCase):
+    dbdiff_models = [ContentType]
+    dbdiff_exclude = {'*': ['created']}
+    dbdiff_reset_sequences = True
+    dbdiff_expected = 'dbdiff/tests/test_mixin.json'
+
+    def test_db_import(self):
+        if connection.vendor != 'postgresql':
+            return  # not supported for now
+        super(ContentTypeTestCase, self).test_db_import()
+        self.assertTrue(self.dbdiff_test_executed)
+
+    def dbdiff_test(self):
+        ContentType.objects.create()
+        self.dbdiff_test_executed = True

dbdiff/tests/test_plugin.py

@@ -0,0 +1,34 @@
+from dbdiff.tests.decimal_test.models import TestModel as DecimalModel
+from dbdiff.tests.inheritance.models import Child, Parent
+from dbdiff.tests.nonintpk.models import Nonintpk
+
+import pytest
+
+
+@pytest.mark.dbdiff(models=[DecimalModel])
+def test_insert_first():
+    assert DecimalModel.objects.count() == 0
+    assert DecimalModel.objects.create(test_field=1).pk == 1
+
+
+@pytest.mark.dbdiff(models=[DecimalModel])
+def test_still_first_pk():
+    assert DecimalModel.objects.count() == 0
+    assert DecimalModel.objects.create(test_field=1).pk == 1
+
+
+@pytest.mark.dbdiff(models=[DecimalModel, Nonintpk])
+def test_doesnt_reset_nonintpk_which_would_fail():
+    assert DecimalModel.objects.count() == 0
+
+
+@pytest.mark.dbdiff(models=[Child])
+def test_inheritance_sequence_reset():
+    assert Child.objects.count() == 0
+    assert Child.objects.create(name='1').pk == 1
+
+
+@pytest.mark.dbdiff(models=[Child])
+def test_inheritance_sequence_reset_again():
+    assert Parent.objects.count() == 0
+    assert Child.objects.create(name='1').pk == 1

dbdiff/tests/test_utils.py

@@ -0,0 +1,49 @@
+import os
+
+from dbdiff.utils import diff, get_absolute_path, get_model_names
+
+from django.contrib.auth.models import Group
+
+
+def test_diff_ignore_pk():
+    """With ignore_pk=True, records are matched by content, not pk."""
+    expected = {
+        'auth.group': {
+            1: {'name': 'testgroup', 'permissions': []},
+        },
+    }
+    result = {
+        'auth.group': {
+            99: {'name': 'testgroup', 'permissions': []},  # same content, diff pk
+        },
+    }
+    unexpected, missing, different = diff(expected, result, ignore_pk=True)
+    assert not unexpected and not missing and not different
+
+
+def test_diff_with_pk_by_default():
+    """With ignore_pk=False, same content but different pk yields missing/unexpected."""
+    expected = {
+        'auth.group': {
+            1: {'name': 'testgroup', 'permissions': []},
+        },
+    }
+    result = {
+        'auth.group': {
+            99: {'name': 'testgroup', 'permissions': []},
+        },
+    }
+    unexpected, missing, different = diff(expected, result, ignore_pk=False)
+    assert missing == {'auth.group': {1: {'name': 'testgroup', 'permissions': []}}}
+    assert unexpected == {'auth.group': {99: {'name': 'testgroup', 'permissions': []}}}
+
+
+def test_get_model_names():
+    assert get_model_names([Group, 'auth.user']) == ['auth.group', 'auth.user']
+
+
+def test_get_absolute_path_starting_with_dot():
+    assert get_absolute_path('./foo') == os.path.join(
+        os.path.abspath(os.path.dirname('__file__')),
+        'foo',
+    )

dbdiff/utils.py

@@ -0,0 +1,179 @@
+"""Utils for dbdiff."""
+
+import os
+
+from django.apps import apps
+from django.db import connections
+
+from importlib.util import find_spec
+
+def get_tree(dump, exclude=None):
+    """Return a tree of model -> pk -> fields."""
+    exclude = exclude or {}
+    tree = {}
+
+    for instance in dump:
+        if instance['model'] not in tree:
+            tree[instance['model']] = {}
+
+        exclude_fields = exclude.get(instance['model'], [])
+        exclude_fields += exclude.get('*', [])
+
+        tree[instance['model']][instance['pk']] = {
+            name: value for name, value in instance['fields'].items()
+            if name not in exclude_fields
+        }
+
+    return tree
+
+
+def _get_unexpected(expected, result):
+    unexpected = {}
+
+    for model, result_instances in result.items():
+        expected_pks = expected.get(model, {}).keys()
+
+        for pk, result_fields in result_instances.items():
+            if pk in expected_pks:
+                continue
+
+            unexpected.setdefault(model, {})
+            unexpected[model][pk] = result_fields
+
+    return unexpected
+
+
+def diff(expected, result, ignore_pk=False):
+    """Return unexpected, missing and diff between expected and result.
+
+    When ignore_pk is True, records are matched by their field values (content)
+    instead of primary key. Records with the same content but different pks
+    are considered matching.
+    """
+    missing, different = {}, {}
+
+    if ignore_pk:
+        unexpected, missing, different = _diff_by_content(expected, result)
+        return unexpected, missing, different
+
+    unexpected = _get_unexpected(expected, result)
+
+    for model, expected_instances in expected.items():
+        for pk, expected_fields in expected_instances.items():
+            if pk not in result.get(model, {}):
+                missing.setdefault(model, {})
+                missing[model][pk] = expected_fields
+                continue
+
+            result_fields = result[model][pk]
+            if expected_fields == result_fields:
+                continue
+
+            different.setdefault(model, {})
+            different[model].setdefault(pk, {})
+
+            for expected_field, expected_value in expected_fields.items():
+                result_value = result_fields[expected_field]
+
+                if expected_value == result_value:
+                    continue
+
+                different[model][pk][expected_field] = (
+                    expected_value,
+                    result_value
+                )
+    return unexpected, missing, different
+
+
+def _diff_by_content(expected, result):
+    """Diff by matching records on field content instead of primary key."""
+    unexpected, missing, different = {}, {}, {}
+
+    for model in set(expected.keys()) | set(result.keys()):
+        expected_list = list(expected.get(model, {}).items())
+        result_list = list(result.get(model, {}).items())
+        matched_result_indices = set()
+
+        for exp_pk, exp_fields in expected_list:
+            found = False
+            for i, (res_pk, res_fields) in enumerate(result_list):
+                if i in matched_result_indices:
+                    continue
+                if exp_fields == res_fields:
+                    matched_result_indices.add(i)
+                    found = True
+                    break
+            if not found:
+                missing.setdefault(model, {})
+                missing[model][exp_pk] = exp_fields
+
+        for i, (res_pk, res_fields) in enumerate(result_list):
+            if i not in matched_result_indices:
+                unexpected.setdefault(model, {})
+                unexpected[model][res_pk] = res_fields
+
+    return unexpected, missing, different
+
+
+def get_absolute_path(path):
+    """Return the absolute path to an app-relative path."""
+    if path.startswith('/'):
+        return path
+
+    if path.startswith('.'):
+        module_path = '.'
+    else:
+        module_path = find_spec(path.split('/')[0]).submodule_search_locations[0]
+
+    return os.path.abspath(os.path.join(
+        module_path,
+        *path.split('/')[1:]
+    ))
+
+
+def get_model_names(model_classes):
+    """Return model names for model classes."""
+    return [
+        m if isinstance(m, str)
+        else '%s.%s' % (m._meta.app_label, m._meta.model_name)
+        for m in model_classes
+    ]
+
+
+def get_models_tables(models):
+    """Return the list of tables for the given models."""
+    tables = set()
+
+    for model in models:
+        tables.add(model._meta.db_table)
+        tables.update(f.m2m_db_table() for f in
+                      model._meta.local_many_to_many)
+
+    return list(tables)
+
+
+def patch_transaction_test_case():
+    """Monkeypatch TransactionTestCase._reset_sequences to support SQLite."""
+    from django.test.testcases import TransactionTestCase
+    TransactionTestCase.old_reset_sequences = \
+        TransactionTestCase._reset_sequences
+
+    def new_reset_sequences(self, db_name):
+        self.old_reset_sequences(db_name)
+        connection = connections[db_name]
+
+        if connection.vendor != 'sqlite':
+            return
+
+        tables = get_models_tables(apps.get_models())
+        statements = [
+            "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='%s';" % t
+            for t in tables
+        ]
+
+        cursor = connection.cursor()
+
+        for statement in statements:
+            cursor.execute(statement)
+
+    TransactionTestCase._reset_sequences = new_reset_sequences