django-dbdiff 0.9.4__tar.gz → 0.9.6__tar.gz

django-dbdiff-0.9.6/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: django-dbdiff
+Version: 0.9.6
+Summary: Database data diffing against fixtures for testing
+Home-page: https://github.com/yourlabs/django-dbdiff
+Author: James Pic
+Author-email: jamespic@gmail.com
+License: MIT
+Keywords: django test database fixture diff
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: ijson
+Requires-Dist: json_delta
+
+.. image:: https://travis-ci.org/yourlabs/django-dbdiff.svg
+    :target: https://travis-ci.org/yourlabs/django-dbdiff
+.. image:: https://codecov.io/github/yourlabs/django-dbdiff/coverage.svg?branch=master
+    :target: https://codecov.io/github/yourlabs/django-dbdiff?branch=master
+.. image:: https://badge.fury.io/py/django-dbdiff.png
+   :target: http://badge.fury.io/py/django-dbdiff
+
+django-dbdiff
+~~~~~~~~~~~~~
+
+I'm pretty lazy when it comes to writing tests for existing code, however, I'm
+even lazier when it comes to repetitive manual testing action.
+
+This package aims at de-duplicating the data import tests from
+django-representatives and django-representatives-votes which is re-used in
+django-cities-light.
+
+Database state assertion
+========================
+
+A nice way to test a data import script is to create a source data fixture with
+a subset of data, ie. with only 10 cities instead of 28K or only 3 european
+parliament representatives instead of 3600, feed the import function with that
+and then compare the database state with a django fixture. This looks like what
+I was used to do:
+
+- use such a command to create a small data extract
+  `shuf -n3 cities15000.txt > cities_light/tests/cities_test_fixture.txt`,
+- use it against the import script on a clean database,
+- verify the database manually, and run
+  `django-admin dumpdata --indent=4 cities_light > cities_light/tests/cities_test_expected.txt`
+- then, make a test case that calls the import script against the fixture,
+- write and maintain some funny (fuzzy ?) repetitive test code to ensure that
+  the database is in the expected state.
+
+When a bug is fixed, just add the case to the fixture and repeat the process to
+create new expected data dumps, use coverage to ensure no case is missed.
+
+With django-dbdiff, I just need to maintain to initial data extract, and test
+it with ``Fixture('appname/path/to/fixture',
+models=[YourModelToTest]).assertNoDiff()`` in a
+``django.test.TransactionTestCase`` which has ``reset_sequences=True``:
+
+- if the fixture in question doesn't exist, it'll be automatically created on
+  with dumpdata for the concerned models on the first run, raising
+  "FixtureCreated" exception to fail the test and inform of the path of the
+  created fixture, so that it doesn't mislead the user in thinking the test
+  passed with an existing fixture,
+- if the fixture exists, it'll run dumpdata on the models concerned and GNU
+  diff it against the fixture, if there's any output it'll be raised in the
+  "DiffFound" exception, failing the test and printing the diff.
+
+Usage
+=====
+
+Example:
+
+.. code-block:: python
+
+    from django import TransactionTestCase
+    from dbdiff.fixture import Fixture
+
+
+    class YourImportTest(test.TransactionTestCase):
+        reset_sequences = True
+
+        def test_your_import(self):
+            your_import()
+
+            Fixture('yourapp/tests/yourtest.json',
+                    models=[YourModel]).assertNoDiff()
+
+The first time, it will raise a ``FixtureCreated`` exception, and the test will
+fail. This is to inform the user that the test didn't really run. On the next
+run though, it will pass.
+
+If any difference is found between the database and the test fixture, then
+``diff()`` will return the diff as outputed by GNU diff.
+
+If you need to ignore fields globally, set the class-level variable exclude as such:
+
+.. code-block:: python
+
+   Fixture.exclude = {'mrsrequest.mrsrequest': ['token']}
+
+Instead of deleting the fixtures manually before running the tests to
+regenerate them, just run your tests with FIXTURE_REWRITE=1 environment
+variable. This will overwrite the fixtures and make the tests look like it
+passed.
+
+See tests and docstrings for crunchy details.
+
+Requirements
+============
+
+MySQL, SQLite and PostgreSQL, Python 3.8 to 3.12 are supported along with
+Django 3.2 to 5.0 - it's always better to support django's master so that we
+can **upgrade easily when it is released**, which is one of the selling points
+for having 100% coverage.
+
+Install
+=======
+
+Install ``django-dbdiff`` with pip and add ``dbdiff`` to ``INSTALLED_APPS``.
+
+Django model observer
+=====================
+
+It is interresting to note that a related, perhaps sort-of similar app exists:
+https://github.com/Griffosx/djmo

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/README.rst

@@ -53,7 +53,9 @@ models=[YourModelToTest]).assertNoDiff()`` in a
 Usage
 =====
 
-Example::
+Example:
+
+.. code-block:: python
 
     from django import TransactionTestCase
     from dbdiff.fixture import Fixture
@@ -75,6 +77,12 @@ run though, it will pass.
 If any difference is found between the database and the test fixture, then
 ``diff()`` will return the diff as outputed by GNU diff.
 
+If you need to ignore fields globally, set the class-level variable exclude as such:
+
+.. code-block:: python
+
+   Fixture.exclude = {'mrsrequest.mrsrequest': ['token']}
+
 Instead of deleting the fixtures manually before running the tests to
 regenerate them, just run your tests with FIXTURE_REWRITE=1 environment
 variable. This will overwrite the fixtures and make the tests look like it
@@ -85,8 +93,8 @@ See tests and docstrings for crunchy details.
 Requirements
 ============
 
-MySQL, SQLite and PostgreSQL, Python 2.7 and 3.4 are supported along with
-Django 1.7 to 1.10 - it's always better to support django's master so that we
+MySQL, SQLite and PostgreSQL, Python 3.8 to 3.12 are supported along with
+Django 3.2 to 5.0 - it's always better to support django's master so that we
 can **upgrade easily when it is released**, which is one of the selling points
 for having 100% coverage.
 

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/dbdiff/fixture.py

@@ -1,5 +1,6 @@
 """Public fixture API."""
 
+import copy
 import json
 import os
 import tempfile
@@ -36,8 +37,15 @@ class Fixture(object):
     .. py:attribute:: database
 
         Database name to use, 'default' by default.
+
+    .. py:attribute:: exclude
+
+        Class attribute, dict of model fields to ignore in the form of:
+        {'app.model': ['fieldN']}
     """
 
+    exclude = dict()
+
     def __init__(self, relative_path, models=None, database=None):
         """
         Instanciate a FixtureDiff on a database.
@@ -92,6 +100,9 @@ class Fixture(object):
         """
         fh, dump_path = tempfile.mkstemp('_dbdiff')
 
+        exclude_final = copy.copy(self.exclude)
+        exclude_final.update(exclude or {})
+
         with os.fdopen(fh, 'w') as f:
             self.dump(f)
 
@@ -99,8 +110,8 @@ class Fixture(object):
             expected, result = json.load(e), json.load(r)
 
         unexpected, missing, different = diff(
-            get_tree(expected, exclude),
-            get_tree(result, exclude),
+            get_tree(expected, exclude_final),
+            get_tree(result, exclude_final),
         )
 
         if not unexpected and not missing and not diff:

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/dbdiff/tests/decimal_test/migrations/0001_initial.py

@@ -1,6 +1,3 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-
 from django.db import models, migrations
 
 

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/dbdiff/tests/decimal_test/migrations/0002_auto_20160102_0914.py

@@ -1,6 +1,3 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-
 from django.db import models, migrations
 
 

django-dbdiff-0.9.6/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',
+        }
+    }
+}

django-dbdiff-0.9.6/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': {},
+        
+    }
+}

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/dbdiff/tests/test_compare.py

@@ -1,15 +1,11 @@
 """Public API tests."""
 
-from __future__ import unicode_literals
-
 import os
 import tempfile
 
 from django import test
 from django.contrib.auth.models import Group
 
-import six
-
 from ..exceptions import DiffFound, FixtureCreated
 from ..fixture import Fixture
 
@@ -57,8 +53,8 @@ class SmokeTest(test.TransactionTestCase):
 1 instance(s) of auth.group have not expected fields
 #1:
   name:
-- u'testgroup'
-+ u'BOOM'
+- 'testgroup'
++ 'BOOM'
 '''
 
         with self.assertRaises(DiffFound) as result:
@@ -73,12 +69,12 @@ class SmokeTest(test.TransactionTestCase):
         expected = '''
 1 unexpected instance(s) of auth.group found in the dump:
 #2:
-{u'name': u'unexpected', u'permissions': []}
+{'name': 'unexpected', 'permissions': []}
 1 instance(s) of auth.group have not expected fields
 #1:
   name:
-- u'testgroup'
-+ u'BOOM'
+- 'testgroup'
++ 'BOOM'
 '''
 
         with self.assertRaises(DiffFound) as result:
@@ -90,10 +86,10 @@ class SmokeTest(test.TransactionTestCase):
         expected = '''
 1 unexpected instance(s) of auth.group found in the dump:
 #2:
-{u'name': u'unexpected', u'permissions': []}
+{'name': 'unexpected', 'permissions': []}
 1 expected instance(s) of auth.group missing from dump:
 #1:
-{u'name': u'testgroup', u'permissions': []}
+{'name': 'testgroup', 'permissions': []}
 '''
 
         with self.assertRaises(DiffFound) as result:
@@ -101,13 +97,6 @@ class SmokeTest(test.TransactionTestCase):
         self.assert_message_is(expected, result)
 
     def assert_message_is(self, expected, result):
-        if six.PY3:
-            expected = expected.replace("u'", "'")
-
-        msg = (
-            result.exception.message
-            if six.PY2 else result.exception.args[0]
-        )
-
+        msg = result.exception.args[0]
         out = '\n'.join(msg.split('\n')[1:])
         assert out.strip() == expected.strip()

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/dbdiff/utils.py

@@ -1,13 +1,11 @@
 """Utils for dbdiff."""
 
-import imp
 import os
 
 from django.apps import apps
 from django.db import connections
 
-import six
-
+from importlib.util import find_spec
 
 def get_tree(dump, exclude=None):
     """Return a tree of model -> pk -> fields."""
@@ -86,7 +84,8 @@ def get_absolute_path(path):
     if path.startswith('.'):
         module_path = '.'
     else:
-        module_path = imp.find_module(path.split('/')[0])[1]
+        module_path = find_spec(path.split('/')[0]).submodule_search_locations[0]
+
     return os.path.abspath(os.path.join(
         module_path,
         *path.split('/')[1:]
@@ -96,7 +95,7 @@ def get_absolute_path(path):
 def get_model_names(model_classes):
     """Return model names for model classes."""
     return [
-        m if isinstance(m, six.string_types)
+        m if isinstance(m, str)
         else '%s.%s' % (m._meta.app_label, m._meta.model_name)
         for m in model_classes
     ]

django-dbdiff-0.9.6/django_dbdiff.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: django-dbdiff
+Version: 0.9.6
+Summary: Database data diffing against fixtures for testing
+Home-page: https://github.com/yourlabs/django-dbdiff
+Author: James Pic
+Author-email: jamespic@gmail.com
+License: MIT
+Keywords: django test database fixture diff
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: ijson
+Requires-Dist: json_delta
+
+.. image:: https://travis-ci.org/yourlabs/django-dbdiff.svg
+    :target: https://travis-ci.org/yourlabs/django-dbdiff
+.. image:: https://codecov.io/github/yourlabs/django-dbdiff/coverage.svg?branch=master
+    :target: https://codecov.io/github/yourlabs/django-dbdiff?branch=master
+.. image:: https://badge.fury.io/py/django-dbdiff.png
+   :target: http://badge.fury.io/py/django-dbdiff
+
+django-dbdiff
+~~~~~~~~~~~~~
+
+I'm pretty lazy when it comes to writing tests for existing code, however, I'm
+even lazier when it comes to repetitive manual testing action.
+
+This package aims at de-duplicating the data import tests from
+django-representatives and django-representatives-votes which is re-used in
+django-cities-light.
+
+Database state assertion
+========================
+
+A nice way to test a data import script is to create a source data fixture with
+a subset of data, ie. with only 10 cities instead of 28K or only 3 european
+parliament representatives instead of 3600, feed the import function with that
+and then compare the database state with a django fixture. This looks like what
+I was used to do:
+
+- use such a command to create a small data extract
+  `shuf -n3 cities15000.txt > cities_light/tests/cities_test_fixture.txt`,
+- use it against the import script on a clean database,
+- verify the database manually, and run
+  `django-admin dumpdata --indent=4 cities_light > cities_light/tests/cities_test_expected.txt`
+- then, make a test case that calls the import script against the fixture,
+- write and maintain some funny (fuzzy ?) repetitive test code to ensure that
+  the database is in the expected state.
+
+When a bug is fixed, just add the case to the fixture and repeat the process to
+create new expected data dumps, use coverage to ensure no case is missed.
+
+With django-dbdiff, I just need to maintain to initial data extract, and test
+it with ``Fixture('appname/path/to/fixture',
+models=[YourModelToTest]).assertNoDiff()`` in a
+``django.test.TransactionTestCase`` which has ``reset_sequences=True``:
+
+- if the fixture in question doesn't exist, it'll be automatically created on
+  with dumpdata for the concerned models on the first run, raising
+  "FixtureCreated" exception to fail the test and inform of the path of the
+  created fixture, so that it doesn't mislead the user in thinking the test
+  passed with an existing fixture,
+- if the fixture exists, it'll run dumpdata on the models concerned and GNU
+  diff it against the fixture, if there's any output it'll be raised in the
+  "DiffFound" exception, failing the test and printing the diff.
+
+Usage
+=====
+
+Example:
+
+.. code-block:: python
+
+    from django import TransactionTestCase
+    from dbdiff.fixture import Fixture
+
+
+    class YourImportTest(test.TransactionTestCase):
+        reset_sequences = True
+
+        def test_your_import(self):
+            your_import()
+
+            Fixture('yourapp/tests/yourtest.json',
+                    models=[YourModel]).assertNoDiff()
+
+The first time, it will raise a ``FixtureCreated`` exception, and the test will
+fail. This is to inform the user that the test didn't really run. On the next
+run though, it will pass.
+
+If any difference is found between the database and the test fixture, then
+``diff()`` will return the diff as outputed by GNU diff.
+
+If you need to ignore fields globally, set the class-level variable exclude as such:
+
+.. code-block:: python
+
+   Fixture.exclude = {'mrsrequest.mrsrequest': ['token']}
+
+Instead of deleting the fixtures manually before running the tests to
+regenerate them, just run your tests with FIXTURE_REWRITE=1 environment
+variable. This will overwrite the fixtures and make the tests look like it
+passed.
+
+See tests and docstrings for crunchy details.
+
+Requirements
+============
+
+MySQL, SQLite and PostgreSQL, Python 3.8 to 3.12 are supported along with
+Django 3.2 to 5.0 - it's always better to support django's master so that we
+can **upgrade easily when it is released**, which is one of the selling points
+for having 100% coverage.
+
+Install
+=======
+
+Install ``django-dbdiff`` with pip and add ``dbdiff`` to ``INSTALLED_APPS``.
+
+Django model observer
+=====================
+
+It is interresting to note that a related, perhaps sort-of similar app exists:
+https://github.com/Griffosx/djmo

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/django_dbdiff.egg-info/entry_points.txt

@@ -1,3 +1,2 @@
 [pytest11]
 dbdiff = dbdiff.plugin
-

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/django_dbdiff.egg-info/requires.txt

@@ -1,3 +1,2 @@
 ijson
 json_delta
-six

{django-dbdiff-0.9.4 → django-dbdiff-0.9.6}/setup.py

@@ -12,7 +12,7 @@ def read(fname):
 
 setup(
     name='django-dbdiff',
-    version='0.9.4',
+    version='0.9.6',
     description='Database data diffing against fixtures for testing',
     author='James Pic',
     author_email='jamespic@gmail.com',
@@ -22,18 +22,27 @@ setup(
     long_description=read('README.rst'),
     license='MIT',
     keywords='django test database fixture diff',
-    install_requires=['ijson', 'json_delta', 'six'],
+    install_requires=['ijson', 'json_delta'],
     entry_points={'pytest11': ['dbdiff = dbdiff.plugin']},
     classifiers=[
         'Development Status :: 4 - Beta',
         'Environment :: Web Environment',
-        'Framework :: Django',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
+        'Framework :: Django',
+        'Framework :: Django :: 3.2',
+        'Framework :: Django :: 4.0',
+        'Framework :: Django :: 4.1',
+        'Framework :: Django :: 4.2',
+        'Framework :: Django :: 5.0',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
         'Topic :: Internet :: WWW/HTTP',
         'Topic :: Software Development :: Libraries :: Python Modules',
     ],

django-dbdiff-0.9.4/PKG-INFO

@@ -1,125 +0,0 @@
-Metadata-Version: 2.1
-Name: django-dbdiff
-Version: 0.9.4
-Summary: Database data diffing against fixtures for testing
-Home-page: https://github.com/yourlabs/django-dbdiff
-Author: James Pic
-Author-email: jamespic@gmail.com
-License: MIT
-Description: .. image:: https://travis-ci.org/yourlabs/django-dbdiff.svg
-            :target: https://travis-ci.org/yourlabs/django-dbdiff
-        .. image:: https://codecov.io/github/yourlabs/django-dbdiff/coverage.svg?branch=master
-            :target: https://codecov.io/github/yourlabs/django-dbdiff?branch=master
-        .. image:: https://badge.fury.io/py/django-dbdiff.png
-           :target: http://badge.fury.io/py/django-dbdiff
-        
-        django-dbdiff
-        ~~~~~~~~~~~~~
-        
-        I'm pretty lazy when it comes to writing tests for existing code, however, I'm
-        even lazier when it comes to repetitive manual testing action.
-        
-        This package aims at de-duplicating the data import tests from
-        django-representatives and django-representatives-votes which is re-used in
-        django-cities-light.
-        
-        Database state assertion
-        ========================
-        
-        A nice way to test a data import script is to create a source data fixture with
-        a subset of data, ie. with only 10 cities instead of 28K or only 3 european
-        parliament representatives instead of 3600, feed the import function with that
-        and then compare the database state with a django fixture. This looks like what
-        I was used to do:
-        
-        - use such a command to create a small data extract
-          `shuf -n3 cities15000.txt > cities_light/tests/cities_test_fixture.txt`,
-        - use it against the import script on a clean database,
-        - verify the database manually, and run
-          `django-admin dumpdata --indent=4 cities_light > cities_light/tests/cities_test_expected.txt`
-        - then, make a test case that calls the import script against the fixture,
-        - write and maintain some funny (fuzzy ?) repetitive test code to ensure that
-          the database is in the expected state.
-        
-        When a bug is fixed, just add the case to the fixture and repeat the process to
-        create new expected data dumps, use coverage to ensure no case is missed.
-        
-        With django-dbdiff, I just need to maintain to initial data extract, and test
-        it with ``Fixture('appname/path/to/fixture',
-        models=[YourModelToTest]).assertNoDiff()`` in a
-        ``django.test.TransactionTestCase`` which has ``reset_sequences=True``:
-        
-        - if the fixture in question doesn't exist, it'll be automatically created on
-          with dumpdata for the concerned models on the first run, raising
-          "FixtureCreated" exception to fail the test and inform of the path of the
-          created fixture, so that it doesn't mislead the user in thinking the test
-          passed with an existing fixture,
-        - if the fixture exists, it'll run dumpdata on the models concerned and GNU
-          diff it against the fixture, if there's any output it'll be raised in the
-          "DiffFound" exception, failing the test and printing the diff.
-        
-        Usage
-        =====
-        
-        Example::
-        
-            from django import TransactionTestCase
-            from dbdiff.fixture import Fixture
-        
-        
-            class YourImportTest(test.TransactionTestCase):
-                reset_sequences = True
-        
-                def test_your_import(self):
-                    your_import()
-        
-                    Fixture('yourapp/tests/yourtest.json',
-                            models=[YourModel]).assertNoDiff()
-        
-        The first time, it will raise a ``FixtureCreated`` exception, and the test will
-        fail. This is to inform the user that the test didn't really run. On the next
-        run though, it will pass.
-        
-        If any difference is found between the database and the test fixture, then
-        ``diff()`` will return the diff as outputed by GNU diff.
-        
-        Instead of deleting the fixtures manually before running the tests to
-        regenerate them, just run your tests with FIXTURE_REWRITE=1 environment
-        variable. This will overwrite the fixtures and make the tests look like it
-        passed.
-        
-        See tests and docstrings for crunchy details.
-        
-        Requirements
-        ============
-        
-        MySQL, SQLite and PostgreSQL, Python 2.7 and 3.4 are supported along with
-        Django 1.7 to 1.10 - it's always better to support django's master so that we
-        can **upgrade easily when it is released**, which is one of the selling points
-        for having 100% coverage.
-        
-        Install
-        =======
-        
-        Install ``django-dbdiff`` with pip and add ``dbdiff`` to ``INSTALLED_APPS``.
-        
-        Django model observer
-        =====================
-        
-        It is interresting to note that a related, perhaps sort-of similar app exists:
-        https://github.com/Griffosx/djmo
-        
-Keywords: django test database fixture diff
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Web Environment
-Classifier: Framework :: Django
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Description-Content-Type: text/x-rst

django-dbdiff-0.9.4/dbdiff/tests/project/settings_mysql.py

@@ -1,9 +0,0 @@
-from .settings import *  # noqa
-
-DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.mysql',
-        'NAME': 'dbdiff_test',
-        'USER': 'root',
-    }
-}

django-dbdiff-0.9.4/dbdiff/tests/project/settings_postgresql.py

@@ -1,9 +0,0 @@
-from .settings import *  # noqa
-
-DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.postgresql_psycopg2',
-        'NAME': 'dbdiff_test',
-        'USER': 'postgres',
-    }
-}

django-dbdiff-0.9.4/django_dbdiff.egg-info/PKG-INFO

@@ -1,125 +0,0 @@
-Metadata-Version: 2.1
-Name: django-dbdiff
-Version: 0.9.4
-Summary: Database data diffing against fixtures for testing
-Home-page: https://github.com/yourlabs/django-dbdiff
-Author: James Pic
-Author-email: jamespic@gmail.com
-License: MIT
-Description: .. image:: https://travis-ci.org/yourlabs/django-dbdiff.svg
-            :target: https://travis-ci.org/yourlabs/django-dbdiff
-        .. image:: https://codecov.io/github/yourlabs/django-dbdiff/coverage.svg?branch=master
-            :target: https://codecov.io/github/yourlabs/django-dbdiff?branch=master
-        .. image:: https://badge.fury.io/py/django-dbdiff.png
-           :target: http://badge.fury.io/py/django-dbdiff
-        
-        django-dbdiff
-        ~~~~~~~~~~~~~
-        
-        I'm pretty lazy when it comes to writing tests for existing code, however, I'm
-        even lazier when it comes to repetitive manual testing action.
-        
-        This package aims at de-duplicating the data import tests from
-        django-representatives and django-representatives-votes which is re-used in
-        django-cities-light.
-        
-        Database state assertion
-        ========================
-        
-        A nice way to test a data import script is to create a source data fixture with
-        a subset of data, ie. with only 10 cities instead of 28K or only 3 european
-        parliament representatives instead of 3600, feed the import function with that
-        and then compare the database state with a django fixture. This looks like what
-        I was used to do:
-        
-        - use such a command to create a small data extract
-          `shuf -n3 cities15000.txt > cities_light/tests/cities_test_fixture.txt`,
-        - use it against the import script on a clean database,
-        - verify the database manually, and run
-          `django-admin dumpdata --indent=4 cities_light > cities_light/tests/cities_test_expected.txt`
-        - then, make a test case that calls the import script against the fixture,
-        - write and maintain some funny (fuzzy ?) repetitive test code to ensure that
-          the database is in the expected state.
-        
-        When a bug is fixed, just add the case to the fixture and repeat the process to
-        create new expected data dumps, use coverage to ensure no case is missed.
-        
-        With django-dbdiff, I just need to maintain to initial data extract, and test
-        it with ``Fixture('appname/path/to/fixture',
-        models=[YourModelToTest]).assertNoDiff()`` in a
-        ``django.test.TransactionTestCase`` which has ``reset_sequences=True``:
-        
-        - if the fixture in question doesn't exist, it'll be automatically created on
-          with dumpdata for the concerned models on the first run, raising
-          "FixtureCreated" exception to fail the test and inform of the path of the
-          created fixture, so that it doesn't mislead the user in thinking the test
-          passed with an existing fixture,
-        - if the fixture exists, it'll run dumpdata on the models concerned and GNU
-          diff it against the fixture, if there's any output it'll be raised in the
-          "DiffFound" exception, failing the test and printing the diff.
-        
-        Usage
-        =====
-        
-        Example::
-        
-            from django import TransactionTestCase
-            from dbdiff.fixture import Fixture
-        
-        
-            class YourImportTest(test.TransactionTestCase):
-                reset_sequences = True
-        
-                def test_your_import(self):
-                    your_import()
-        
-                    Fixture('yourapp/tests/yourtest.json',
-                            models=[YourModel]).assertNoDiff()
-        
-        The first time, it will raise a ``FixtureCreated`` exception, and the test will
-        fail. This is to inform the user that the test didn't really run. On the next
-        run though, it will pass.
-        
-        If any difference is found between the database and the test fixture, then
-        ``diff()`` will return the diff as outputed by GNU diff.
-        
-        Instead of deleting the fixtures manually before running the tests to
-        regenerate them, just run your tests with FIXTURE_REWRITE=1 environment
-        variable. This will overwrite the fixtures and make the tests look like it
-        passed.
-        
-        See tests and docstrings for crunchy details.
-        
-        Requirements
-        ============
-        
-        MySQL, SQLite and PostgreSQL, Python 2.7 and 3.4 are supported along with
-        Django 1.7 to 1.10 - it's always better to support django's master so that we
-        can **upgrade easily when it is released**, which is one of the selling points
-        for having 100% coverage.
-        
-        Install
-        =======
-        
-        Install ``django-dbdiff`` with pip and add ``dbdiff`` to ``INSTALLED_APPS``.
-        
-        Django model observer
-        =====================
-        
-        It is interresting to note that a related, perhaps sort-of similar app exists:
-        https://github.com/Griffosx/djmo
-        
-Keywords: django test database fixture diff
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Web Environment
-Classifier: Framework :: Django
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Description-Content-Type: text/x-rst