Hello community,
here is the log from the commit of package python-django-nose for
openSUSE:Factory checked in at 2012-05-31 17:09:25
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-django-nose (Old)
and /work/SRC/openSUSE:Factory/.python-django-nose.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-django-nose", Maintainer is ""
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-django-nose/python-django-nose.changes
2012-03-24 20:09:52.000000000 +0100
+++
/work/SRC/openSUSE:Factory/.python-django-nose.new/python-django-nose.changes
2012-05-31 17:09:27.000000000 +0200
@@ -1,0 +2,22 @@
+Mon May 21 01:55:09 UTC 2012 - alexan...@exatati.com.br
+
+- Update to 1.1:
+ * Django TransactionTestCases don't clean up after themselves;
+ they leave junk in the DB and clean it up only on _pre_setup.
+ Thus, Django makes sure these tests run last. Now django-nose
+ does, too. This means one fewer source of failures on existing
+ projects. (Erik Rose)
+ * Add support for hygienic TransactionTestCases. (Erik Rose)
+ * Support models that are used only for tests. Just put them in
+ any file imported in the course of loading tests. No more crazy
+ hacks necessary. (Erik Rose)
+ * Make the fixture bundler more conservative, fixing some conceivable
+ situations in which fixtures would not appear as intended if a
+ TransactionTestCase found its way into the middle of a bundle.
+ (Erik Rose)
+ * Fix an error that would surface when using SQLAlchemy with
+ connection pooling. (Roger Hu)
+ * Gracefully ignore the new --liveserver option introduced in
+ Django 1.4; don't let it through to nose. (Adam DePue)
+
+-------------------------------------------------------------------
Old:
----
django-nose-1.0.tar.gz
New:
----
django-nose-1.1.tar.bz2
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-django-nose.spec ++++++
--- /var/tmp/diff_new_pack.za4FIl/_old 2012-05-31 17:09:29.000000000 +0200
+++ /var/tmp/diff_new_pack.za4FIl/_new 2012-05-31 17:09:29.000000000 +0200
@@ -17,13 +17,13 @@
Name: python-django-nose
-Version: 1.0
+Version: 1.1
Release: 0
Url: http://github.com/jbalogh/django-nose
Summary: Django test runner that uses nose
License: BSD-3-Clause
Group: Development/Languages/Python
-Source:
http://pypi.python.org/packages/source/d/django-nose/django-nose-%{version}.tar.gz
+Source: django-nose-%{version}.tar.bz2
BuildRoot: %{_tmppath}/%{name}-%{version}-build
BuildRequires: python-devel
BuildRequires: python-distribute
++++++ django-nose-1.0.tar.gz -> django-nose-1.1.tar.bz2 ++++++
Files old/django-nose-1.0/._MANIFEST.in and new/django-nose-1.1/._MANIFEST.in
differ
Files old/django-nose-1.0/._changelog.txt and
new/django-nose-1.1/._changelog.txt differ
Files old/django-nose-1.0/._runtests.sh and new/django-nose-1.1/._runtests.sh
differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/PKG-INFO new/django-nose-1.1/PKG-INFO
--- old/django-nose-1.0/PKG-INFO 2012-03-13 20:04:49.000000000 +0100
+++ new/django-nose-1.1/PKG-INFO 2012-05-20 03:18:48.000000000 +0200
@@ -1,7 +1,7 @@
Metadata-Version: 1.0
Name: django-nose
-Version: 1.0
-Summary: Django test runner that uses nose
+Version: 1.1
+Summary: Makes your Django tests simple and snappy
Home-page: http://github.com/jbalogh/django-nose
Author: Erik Rose
Author-email: erikr...@grinchcentral.com
@@ -13,14 +13,25 @@
Features
--------
- * All the goodness of `nose`_ in your Django tests
+ * All the goodness of `nose`_ in your Django tests, like...
+
+ * Testing just your apps by default, not all the standard ones that
happen to
+ be in ``INSTALLED_APPS``
+ * Running the tests in one or more specific modules (or apps, or
classes, or
+ running a specific test)
+ * Obviating the need to import all your tests into
``tests/__init__.py``.
+ This not only saves busy-work but also eliminates the possibility
of
+ accidentally shadowing test classes.
+ * Taking advantage of all the useful `nose plugins`_
* Fixture bundling, an optional feature which speeds up your
fixture-based
tests by a factor of 4
* Reuse of previously created test DBs, cutting 10 seconds off startup
time
+ * Hygienic TransactionTestCases, which can save you a DB flush per test
* Support for various databases. Tested with MySQL, PostgreSQL, and
SQLite.
Others should work as well.
.. _nose: http://somethingaboutorange.com/mrl/projects/nose/
+ .. _nose plugins: http://nose-plugins.jottit.com/
Installation
@@ -73,18 +84,25 @@
the flag off the next time you run tests. This will cue the test
runner to
reinitialize the test database.
+ Also, REUSE_DB is not compatible with TransactionTestCases that leave
junk in
+ the DB, so be sure to make your TransactionTestCases hygienic (see
below) if
+ you want to use it.
+
Enabling Fast Fixtures
----------------------
- django-nose includes a nose plugin which drastically speeds up your
tests by
- eliminating redundant setup of Django test fixtures. To use it...
+ django-nose includes a fixture bundler which drastically speeds up
your tests
+ by eliminating redundant setup of Django test fixtures. To use it...
1. Subclass ``django_nose.FastFixtureTestCase`` instead of
``django.test.TestCase``. (I like to import it ``as TestCase`` in my
project's ``tests/__init__.py`` and then import it from there into
my actual
- tests. Then it's easy to sub the base class in and out.)
- 2. Activate the plugin by passing the ``--with-fixture-bundling``
option to ``./manage.py test``.
+ tests. Then it's easy to sub the base class in and out.) This alone
will
+ cause fixtures to load once per class rather than once per test.
+ 2. Activate fixture bundling by passing the
``--with-fixture-bundling`` option
+ to ``./manage.py test``. This loads each unique set of fixtures
only once,
+ even across class, module, and app boundaries.
How Fixture Bundling Works
~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -132,6 +150,59 @@
``exempt_from_fixture_bundling`` attribute of the test class to
``True``.
+ Speedy Hygienic TransactionTestCases
+ ------------------------------------
+
+ Unlike the stock Django test runner, django-nose lets you write custom
+ TransactionTestCase subclasses which expect to start with an unmarred
DB,
+ saving an entire DB flush per test.
+
+ Background
+ ~~~~~~~~~~
+
+ The default Django TransactionTestCase class `can leave the DB in an
unclean
+ state`_ when it's done. To compensate, TransactionTestCase does a
+ time-consuming flush of the DB *before* each test to ensure it begins
with a
+ clean slate. Django's stock test runner then runs TransactionTestCases
last so
+ they don't wreck the environment for better-behaved tests. django-nose
+ replicates this behavior.
+
+ Escaping the Grime
+ ~~~~~~~~~~~~~~~~~~
+
+ Some people, however, have made subclasses of TransactionTestCase that
clean up
+ after themselves (and can do so efficiently, since they know what
they've
+ changed). Like TestCase, these may assume they start with a clean DB.
However,
+ any TransactionTestCases that run before them and leave a mess could
cause them
+ to fail spuriously.
+
+ django-nose offers to fix this. If you include a special attribute on
your
+ well-behaved TransactionTestCase... ::
+
+ class MyNiceTestCase(TransactionTestCase):
+ cleans_up_after_itself = True
+
+ ...django-nose will run it before any of those nasty, trash-spewing
test cases.
+ You can thus enjoy a big speed boost any time you make a
TransactionTestCase
+ clean up after itself: skipping a whole DB flush before every test.
With a
+ large schema, this can save minutes of IO.
+
+ django-nose's own FastFixtureTestCase uses this feature, even though it
+ ultimately acts more like a TestCase than a TransactionTestCase.
+
+ .. _can leave the DB in an unclean state:
https://docs.djangoproject.com/en/dev/topics/testing/?from=olddocs#django.test.TransactionTestCase
+
+
+ Test-Only Models
+ ----------------
+
+ If you have a model that is used only by tests (for example, to test an
+ abstract model base class), you can put it in any file that's imported
in the
+ course of loading tests. For example, if the tests that need it are in
+ ``test_models.py``, you can put the model in there, too. django-nose
will make
+ sure its DB table gets created.
+
+
Using With South
----------------
@@ -198,10 +269,32 @@
https://github.com/jbalogh/django-nose/tree/django-1.1 or
http://pypi.python.org/pypi/django-nose/0.0.3.
+ Django 1.0
+ ~~~~~~~~~~
+
+ django-nose does not support Django 1.0.
+
Recent Version History
----------------------
+ 1.1
+ * Django TransactionTestCases don't clean up after themselves; they
leave
+ junk in the DB and clean it up only on _pre_setup. Thus, Django
makes sure
+ these tests run last. Now django-nose does, too. This means one
fewer
+ source of failures on existing projects. (Erik Rose)
+ * Add support for hygienic TransactionTestCases. (Erik Rose)
+ * Support models that are used only for tests. Just put them in any
file
+ imported in the course of loading tests. No more crazy hacks
necessary.
+ (Erik Rose)
+ * Make the fixture bundler more conservative, fixing some conceivable
+ situations in which fixtures would not appear as intended if a
+ TransactionTestCase found its way into the middle of a bundle.
(Erik Rose)
+ * Fix an error that would surface when using SQLAlchemy with
connection
+ pooling. (Roger Hu)
+ * Gracefully ignore the new ``--liveserver`` option introduced in
Django 1.4;
+ don't let it through to nose. (Adam DePue)
+
1.0 (2012-03-12)
* New fixture-bundling plugin for avoiding needless fixture setup
(Erik Rose)
* Moved FastFixtureTestCase in from test-utils, so now all the
@@ -213,7 +306,6 @@
* Nail down versions of the package requirements. (Daniel Mizyrycki)
0.1.3 (2010-04-15)
-
* Even better coverage support (rozza)
* README fixes (carljm and ionelmc)
* optparse OptionGroups are handled better (outofculture)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/README.rst
new/django-nose-1.1/README.rst
--- old/django-nose-1.0/README.rst 2012-03-13 19:56:03.000000000 +0100
+++ new/django-nose-1.1/README.rst 2012-05-19 21:26:12.000000000 +0200
@@ -5,14 +5,25 @@
Features
--------
-* All the goodness of `nose`_ in your Django tests
+* All the goodness of `nose`_ in your Django tests, like...
+
+ * Testing just your apps by default, not all the standard ones that happen to
+ be in ``INSTALLED_APPS``
+ * Running the tests in one or more specific modules (or apps, or classes, or
+ running a specific test)
+ * Obviating the need to import all your tests into ``tests/__init__.py``.
+ This not only saves busy-work but also eliminates the possibility of
+ accidentally shadowing test classes.
+ * Taking advantage of all the useful `nose plugins`_
* Fixture bundling, an optional feature which speeds up your fixture-based
tests by a factor of 4
* Reuse of previously created test DBs, cutting 10 seconds off startup time
+* Hygienic TransactionTestCases, which can save you a DB flush per test
* Support for various databases. Tested with MySQL, PostgreSQL, and SQLite.
Others should work as well.
.. _nose: http://somethingaboutorange.com/mrl/projects/nose/
+.. _nose plugins: http://nose-plugins.jottit.com/
Installation
@@ -65,18 +76,25 @@
the flag off the next time you run tests. This will cue the test runner to
reinitialize the test database.
+Also, REUSE_DB is not compatible with TransactionTestCases that leave junk in
+the DB, so be sure to make your TransactionTestCases hygienic (see below) if
+you want to use it.
+
Enabling Fast Fixtures
----------------------
-django-nose includes a nose plugin which drastically speeds up your tests by
-eliminating redundant setup of Django test fixtures. To use it...
+django-nose includes a fixture bundler which drastically speeds up your tests
+by eliminating redundant setup of Django test fixtures. To use it...
1. Subclass ``django_nose.FastFixtureTestCase`` instead of
``django.test.TestCase``. (I like to import it ``as TestCase`` in my
project's ``tests/__init__.py`` and then import it from there into my actual
- tests. Then it's easy to sub the base class in and out.)
-2. Activate the plugin by passing the ``--with-fixture-bundling`` option to
``./manage.py test``.
+ tests. Then it's easy to sub the base class in and out.) This alone will
+ cause fixtures to load once per class rather than once per test.
+2. Activate fixture bundling by passing the ``--with-fixture-bundling`` option
+ to ``./manage.py test``. This loads each unique set of fixtures only once,
+ even across class, module, and app boundaries.
How Fixture Bundling Works
~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -124,6 +142,59 @@
``exempt_from_fixture_bundling`` attribute of the test class to ``True``.
+Speedy Hygienic TransactionTestCases
+------------------------------------
+
+Unlike the stock Django test runner, django-nose lets you write custom
+TransactionTestCase subclasses which expect to start with an unmarred DB,
+saving an entire DB flush per test.
+
+Background
+~~~~~~~~~~
+
+The default Django TransactionTestCase class `can leave the DB in an unclean
+state`_ when it's done. To compensate, TransactionTestCase does a
+time-consuming flush of the DB *before* each test to ensure it begins with a
+clean slate. Django's stock test runner then runs TransactionTestCases last so
+they don't wreck the environment for better-behaved tests. django-nose
+replicates this behavior.
+
+Escaping the Grime
+~~~~~~~~~~~~~~~~~~
+
+Some people, however, have made subclasses of TransactionTestCase that clean up
+after themselves (and can do so efficiently, since they know what they've
+changed). Like TestCase, these may assume they start with a clean DB. However,
+any TransactionTestCases that run before them and leave a mess could cause them
+to fail spuriously.
+
+django-nose offers to fix this. If you include a special attribute on your
+well-behaved TransactionTestCase... ::
+
+ class MyNiceTestCase(TransactionTestCase):
+ cleans_up_after_itself = True
+
+...django-nose will run it before any of those nasty, trash-spewing test cases.
+You can thus enjoy a big speed boost any time you make a TransactionTestCase
+clean up after itself: skipping a whole DB flush before every test. With a
+large schema, this can save minutes of IO.
+
+django-nose's own FastFixtureTestCase uses this feature, even though it
+ultimately acts more like a TestCase than a TransactionTestCase.
+
+.. _can leave the DB in an unclean state:
https://docs.djangoproject.com/en/dev/topics/testing/?from=olddocs#django.test.TransactionTestCase
+
+
+Test-Only Models
+----------------
+
+If you have a model that is used only by tests (for example, to test an
+abstract model base class), you can put it in any file that's imported in the
+course of loading tests. For example, if the tests that need it are in
+``test_models.py``, you can put the model in there, too. django-nose will make
+sure its DB table gets created.
+
+
Using With South
----------------
@@ -190,10 +261,32 @@
https://github.com/jbalogh/django-nose/tree/django-1.1 or
http://pypi.python.org/pypi/django-nose/0.0.3.
+Django 1.0
+~~~~~~~~~~
+
+django-nose does not support Django 1.0.
+
Recent Version History
----------------------
+1.1
+ * Django TransactionTestCases don't clean up after themselves; they leave
+ junk in the DB and clean it up only on _pre_setup. Thus, Django makes sure
+ these tests run last. Now django-nose does, too. This means one fewer
+ source of failures on existing projects. (Erik Rose)
+ * Add support for hygienic TransactionTestCases. (Erik Rose)
+ * Support models that are used only for tests. Just put them in any file
+ imported in the course of loading tests. No more crazy hacks necessary.
+ (Erik Rose)
+ * Make the fixture bundler more conservative, fixing some conceivable
+ situations in which fixtures would not appear as intended if a
+ TransactionTestCase found its way into the middle of a bundle. (Erik Rose)
+ * Fix an error that would surface when using SQLAlchemy with connection
+ pooling. (Roger Hu)
+ * Gracefully ignore the new ``--liveserver`` option introduced in Django 1.4;
+ don't let it through to nose. (Adam DePue)
+
1.0 (2012-03-12)
* New fixture-bundling plugin for avoiding needless fixture setup (Erik Rose)
* Moved FastFixtureTestCase in from test-utils, so now all the
@@ -205,7 +298,6 @@
* Nail down versions of the package requirements. (Daniel Mizyrycki)
0.1.3 (2010-04-15)
-
* Even better coverage support (rozza)
* README fixes (carljm and ionelmc)
* optparse OptionGroups are handled better (outofculture)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/changelog.txt
new/django-nose-1.1/changelog.txt
--- old/django-nose-1.0/changelog.txt 2012-03-13 19:57:24.000000000 +0100
+++ new/django-nose-1.1/changelog.txt 2012-05-19 20:56:19.000000000 +0200
@@ -1,18 +1,4 @@
-- 1.0
- * New fixture-bundling plugin for avoiding needless fixture setup (Erik Rose)
- * Moved FastFixtureTestCase in from test-utils, so now all the
- fixture-bundling stuff is in one library. (Erik Rose)
- * Added the REUSE_DB setting for faster startup and shutdown. (Erik Rose)
- * Fixed a crash when printing options with certain verbosities. (Daniel Abel)
- * Broke hard dependency on MySQL. Support PostgreSQL. (Roger Hu)
- * Support SQLite, both memory- and disk-based. (Roger Hu and Erik Rose)
- * Nail down versions of the package requirements. (Daniel Mizyrycki)
-
-- 0.1.3 (04-15-10)
- * Even better coverage support (rozza)
- * README fixes (carljm and ionelmc)
- * optparse OptionGroups are handled better (outofculture)
- * nose plugins are loaded before listing options
+(Later entries are in the readme.)
- 0.1.2 (08-14-10)
* run_tests API support (carjm)
Files old/django-nose-1.0/django_nose/.___init__.py and
new/django-nose-1.1/django_nose/.___init__.py differ
Files old/django-nose-1.0/django_nose/._fixture_bundling.py and
new/django-nose-1.1/django_nose/._fixture_bundling.py differ
Files old/django-nose-1.0/django_nose/._plugin.py and
new/django-nose-1.1/django_nose/._plugin.py differ
Files old/django-nose-1.0/django_nose/._runner.py and
new/django-nose-1.1/django_nose/._runner.py differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose/__init__.py
new/django-nose-1.1/django_nose/__init__.py
--- old/django-nose-1.0/django_nose/__init__.py 2012-03-13 04:46:32.000000000
+0100
+++ new/django-nose-1.1/django_nose/__init__.py 2012-05-19 20:56:25.000000000
+0200
@@ -1,4 +1,4 @@
-VERSION = (1, 0, 0)
+VERSION = (1, 1, 0)
__version__ = '.'.join(map(str, VERSION))
from django_nose.runner import *
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose/fixture_bundling.py
new/django-nose-1.1/django_nose/fixture_bundling.py
--- old/django-nose-1.0/django_nose/fixture_bundling.py 2011-09-07
23:41:02.000000000 +0200
+++ new/django-nose-1.1/django_nose/fixture_bundling.py 1970-01-01
01:00:00.000000000 +0100
@@ -1,106 +0,0 @@
-from nose.plugins import Plugin
-from nose.suite import ContextSuite
-
-
-class Bucketer(object):
- def __init__(self):
- # { frozenset(['users.json']):
- # [ContextSuite(...), ContextSuite(...)] }
- self.buckets = {}
-
- def add(self, test):
- """Put a test into a bucket according to its set of fixtures and the
- value of its exempt_from_fixture_bundling attr."""
- key = (frozenset(getattr(test.context, 'fixtures', [])),
- getattr(test.context, 'exempt_from_fixture_bundling', False))
- self.buckets.setdefault(key, []).append(test)
-
-
-class FixtureBundlingPlugin(Plugin):
- """Nose plugin which reorders tests to avoid redundant fixture setup
-
- I reorder test classes so ones using identical sets of fixtures run
- adjacently. I then put attributes on the classes which advise a savvy
- test superclass (like test-utils' FastFixtureTestCase) to not reload the
- fixtures for each class.
-
- This takes support.mozilla.com's suite from 123s down to 94s.
-
- """
- name = 'fixture-bundling'
-
- def prepareTest(self, test):
- """Reorder the tests in the suite so classes using identical sets of
- fixtures are contiguous."""
-
- def process_tests(suite, base_callable):
- """Given a nested disaster of [Lazy]Suites, traverse to the first
- level that has setup or teardown routines, and do something to
- them.
-
- If we were to traverse all the way to the leaves (the Tests)
- indiscriminately and return them, when the runner later calls them,
- they'd run without reference to the suite that contained them, so
- they'd miss their class-, module-, and package-wide setup and
- teardown routines.
-
- The nested suites form basically a double-linked tree, and suites
- will call up to their containing suites to run their setups and
- teardowns, but it would be hubris to assume that something you saw
- fit to setup or teardown at the module level is less costly to
- repeat than DB fixtures. Also, those sorts of setups and teardowns
- are extremely rare in our code. Thus, we limit the granularity of
- bucketing to the first level that has setups or teardowns.
-
- """
- if (not hasattr(suite, '_tests') or
- (hasattr(suite, 'hasFixtures') and suite.hasFixtures())):
- # We hit a Test or something with setup, so do the thing.
- base_callable(suite)
- else:
- for t in suite._tests:
- process_tests(t, base_callable)
-
- def suite_sorted_by_fixtures(suite):
- """Flatten and sort a tree of Suites by the ``fixtures`` members of
- their contexts.
-
- Add ``_fb_should_setup_fixtures`` and
- ``_fb_should_teardown_fixtures`` attrs to each test class to advise
- it whether to set up or tear down (respectively) the fixtures.
-
- Return a Suite.
-
- """
- bucketer = Bucketer()
- process_tests(suite, bucketer.add)
-
- # Lay the bundles of common-fixture-having test classes end to end
- # in a single list so we can make a test suite out of them:
- flattened = []
- for ((fixtures, is_exempt), fixture_bundle) in
bucketer.buckets.iteritems():
- # Advise first and last test classes in each bundle to set up
- # and tear down fixtures and the rest not to:
- if fixtures and not is_exempt:
- # Ones with fixtures are sure to be classes, which means
- # they're sure to be ContextSuites with contexts.
-
- # First class with this set of fixtures sets up:
- fixture_bundle[0].context._fb_should_setup_fixtures = True
-
- # Set all classes' 1..n should_setup to False:
- for cls in fixture_bundle[1:]:
- cls.context._fb_should_setup_fixtures = False
-
- # Last class tears down:
- fixture_bundle[-1].context._fb_should_teardown_fixtures =
True
-
- # Set all classes' 0..(n-1) should_teardown to False:
- for cls in fixture_bundle[:-1]:
- cls.context._fb_should_teardown_fixtures = False
-
- flattened.extend(fixture_bundle)
-
- return ContextSuite(flattened)
-
- return suite_sorted_by_fixtures(test)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose/plugin.py
new/django-nose-1.1/django_nose/plugin.py
--- old/django-nose-1.0/django_nose/plugin.py 2012-03-13 05:40:49.000000000
+0100
+++ new/django-nose-1.1/django_nose/plugin.py 2012-05-19 20:56:19.000000000
+0200
@@ -2,10 +2,14 @@
import sys
from nose.plugins.base import Plugin
+from nose.suite import ContextSuite
from django.conf import settings
from django.db.models.loading import get_apps, load_app
-from django.test.testcases import TransactionTestCase
+from django.test.testcases import TransactionTestCase, TestCase
+
+from django_nose.testcases import FastFixtureTestCase
+from django_nose.utils import process_tests, is_subclass_at_all
class AlwaysOnPlugin(Plugin):
@@ -26,35 +30,47 @@
class ResultPlugin(AlwaysOnPlugin):
- """
- Captures the TestResult object for later inspection.
+ """Captures the TestResult object for later inspection
nose doesn't return the full test result object from any of its runner
methods. Pass an instance of this plugin to the TestProgram and use
``result`` after running the tests to get the TestResult object.
- """
- name = "result"
+ """
+ name = 'result'
def finalize(self, result):
self.result = result
class DjangoSetUpPlugin(AlwaysOnPlugin):
- """
- Configures Django to setup and tear down the environment.
+ """Configures Django to set up and tear down the environment
+
This allows coverage to report on all code imported and used during the
- initialisation of the test runner.
+ initialization of the test runner.
"""
- name = "django setup"
+ name = 'django setup'
def __init__(self, runner):
super(DjangoSetUpPlugin, self).__init__()
self.runner = runner
self.sys_stdout = sys.stdout
- def begin(self):
+ def prepareTest(self, test):
+ """Create the Django DB and model tables, and do other setup.
+
+ This isn't done in begin() because that's too early--the DB has to be
+ set up *after* the tests are imported so the model registry contains
+ models defined in tests.py modules. Models are registered at
+ declaration time by their metaclass.
+
+ prepareTestRunner() might also have been a sane choice, except that, if
+ some plugin returns something from it, none of the other ones get
+ called. I'd rather not dink with scores if I don't have to.
+
+ """
+ # What is this stdout switcheroo for?
sys_stdout = sys.stdout
sys.stdout = self.sys_stdout
@@ -66,3 +82,170 @@
def finalize(self, result):
self.runner.teardown_databases(self.old_names)
self.runner.teardown_test_environment()
+
+
+class Bucketer(object):
+ def __init__(self):
+ # { (frozenset(['users.json']), True):
+ # [ContextSuite(...), ContextSuite(...)] }
+ self.buckets = {}
+
+ # All the non-FastFixtureTestCase tests we saw, in the order they came
+ # in:
+ self.remainder = []
+
+ def add(self, test):
+ """Put a test into a bucket according to its set of fixtures and the
+ value of its exempt_from_fixture_bundling attr."""
+ if is_subclass_at_all(test.context, FastFixtureTestCase):
+ # We bucket even FFTCs that don't have any fixtures, but it
+ # shouldn't matter.
+ key = (frozenset(getattr(test.context, 'fixtures', [])),
+ getattr(test.context, 'exempt_from_fixture_bundling',
False))
+ self.buckets.setdefault(key, []).append(test)
+ else:
+ self.remainder.append(test)
+
+
+class TestReorderer(AlwaysOnPlugin):
+ """Reorder tests for various reasons."""
+ name = 'django-nose-test-reorderer'
+
+ def options(self, parser, env):
+ super(TestReorderer, self).options(parser, env) # pointless
+ parser.add_option('--with-fixture-bundling',
+ action='store_true',
+ dest='with_fixture_bundling',
+ default=env.get('NOSE_WITH_FIXTURE_BUNDLING', False),
+ help='Load a unique set of fixtures only once, even '
+ 'across test classes. '
+ '[NOSE_WITH_FIXTURE_BUNDLING]')
+
+ def configure(self, options, conf):
+ super(TestReorderer, self).configure(options, conf)
+ self.should_bundle = options.with_fixture_bundling
+
+ def _put_transaction_test_cases_last(self, test):
+ """Reorder tests in the suite so TransactionTestCase-based tests come
+ last.
+
+ Django has a weird design decision wherein TransactionTestCase doesn't
+ clean up after itself. Instead, it resets the DB to a clean state only
+ at the *beginning* of each test:
+ https://docs.djangoproject.com/en/dev/topics/testing/?from=olddocs#
+ django. test.TransactionTestCase. Thus, Django reorders tests so
+ TransactionTestCases all come last. Here we do the same.
+
+ "I think it's historical. We used to have doctests also, adding cleanup
+ after each unit test wouldn't necessarily clean up after doctests, so
+ you'd have to clean on entry to a test anyway." was once uttered on
+ #django-dev.
+
+ """
+
+ def filthiness(test):
+ """Return a comparand based on whether a test is guessed to clean
+ up after itself.
+
+ Django's TransactionTestCase doesn't clean up the DB on teardown,
+ but it's hard to guess whether subclasses (other than TestCase) do.
+ We will assume they don't, unless they have a
+ ``cleans_up_after_itself`` attr set to True. This is reasonable
+ because the odd behavior of TransactionTestCase is documented, so
+ subclasses should by default be assumed to preserve it.
+
+ Thus, things will get these comparands (and run in this order):
+
+ * 1: TestCase subclasses. These clean up after themselves.
+ * 1: TransactionTestCase subclasses with
+ cleans_up_after_itself=True. These include
+ FastFixtureTestCases. If you're using the
+ FixtureBundlingPlugin, it will pull the FFTCs out, reorder
+ them, and run them first of all.
+ * 2: TransactionTestCase subclasses. These leave a mess.
+ * 2: Anything else (including doctests, I hope). These don't care
+ about the mess you left, because they don't hit the DB or, if
+ they do, are responsible for ensuring that it's clean (as per
+ https://docs.djangoproject.com/en/dev/topics/testing/?from=
+ olddocs#writing-doctests)
+
+ """
+ test_class = test.context
+ if (is_subclass_at_all(test_class, TestCase) or
+ (is_subclass_at_all(test_class, TransactionTestCase) and
+ getattr(test_class, 'cleans_up_after_itself', False))):
+ return 1
+ return 2
+
+ flattened = []
+ process_tests(test, flattened.append)
+ flattened.sort(key=filthiness)
+ return ContextSuite(flattened)
+
+ def _bundle_fixtures(self, test):
+ """Reorder the tests in the suite so classes using identical sets of
+ fixtures are contiguous.
+
+ I reorder FastFixtureTestCases so ones using identical sets of
fixtures run
+ adjacently. I then put attributes on them to advise them to not reload
the
+ fixtures for each class.
+
+ This takes support.mozilla.com's suite from 123s down to 94s.
+
+ FastFixtureTestCases are the only ones we care about, because nobody
+ else, in practice, pays attention to the ``_fb`` advisory bits. We
+ return those first, then any remaining tests in the order they were
+ received.
+
+ """
+ def suite_sorted_by_fixtures(suite):
+ """Flatten and sort a tree of Suites by the ``fixtures`` members of
+ their contexts.
+
+ Add ``_fb_should_setup_fixtures`` and
+ ``_fb_should_teardown_fixtures`` attrs to each test class to advise
+ it whether to set up or tear down (respectively) the fixtures.
+
+ Return a Suite.
+
+ """
+ bucketer = Bucketer()
+ process_tests(suite, bucketer.add)
+
+ # Lay the bundles of common-fixture-having test classes end to end
+ # in a single list so we can make a test suite out of them:
+ flattened = []
+ for ((fixtures, is_exempt), fixture_bundle) in
bucketer.buckets.iteritems():
+ # Advise first and last test classes in each bundle to set up
+ # and tear down fixtures and the rest not to:
+ if fixtures and not is_exempt:
+ # Ones with fixtures are sure to be classes, which means
+ # they're sure to be ContextSuites with contexts.
+
+ # First class with this set of fixtures sets up:
+ fixture_bundle[0].context._fb_should_setup_fixtures = True
+
+ # Set all classes' 1..n should_setup to False:
+ for cls in fixture_bundle[1:]:
+ cls.context._fb_should_setup_fixtures = False
+
+ # Last class tears down:
+ fixture_bundle[-1].context._fb_should_teardown_fixtures =
True
+
+ # Set all classes' 0..(n-1) should_teardown to False:
+ for cls in fixture_bundle[:-1]:
+ cls.context._fb_should_teardown_fixtures = False
+
+ flattened.extend(fixture_bundle)
+ flattened.extend(bucketer.remainder)
+
+ return ContextSuite(flattened)
+
+ return suite_sorted_by_fixtures(test)
+
+ def prepareTest(self, test):
+ """Reorder the tests."""
+ test = self._put_transaction_test_cases_last(test)
+ if self.should_bundle:
+ test = self._bundle_fixtures(test)
+ return test
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose/runner.py
new/django-nose-1.1/django_nose/runner.py
--- old/django-nose-1.0/django_nose/runner.py 2012-03-13 18:52:48.000000000
+0100
+++ new/django-nose-1.1/django_nose/runner.py 2012-05-19 20:56:19.000000000
+0200
@@ -24,7 +24,8 @@
import nose.core
-from django_nose.plugin import DjangoSetUpPlugin, ResultPlugin
+from django_nose.plugin import DjangoSetUpPlugin, ResultPlugin, TestReorderer
+from django_nose.utils import uses_mysql
try:
any
@@ -36,7 +37,7 @@
return False
-__all__ = ['BasicNoseRunner', 'NoseTestSuiteRunner', 'uses_mysql']
+__all__ = ['BasicNoseRunner', 'NoseTestSuiteRunner']
# This is a table of Django's "manage.py test" options which
@@ -44,10 +45,6 @@
OPTION_TRANSLATION = {'--failfast': '-x'}
-def uses_mysql(connection):
- return 'mysql' in connection.settings_dict['ENGINE']
-
-
# Django v1.2 does not have a _get_test_db_name() function.
if not hasattr(BaseDatabaseCreation, '_get_test_db_name'):
def _get_test_db_name(self):
@@ -61,7 +58,7 @@
def _get_plugins_from_settings():
- for plg_path in list(getattr(settings, 'NOSE_PLUGINS', [])) +
['django_nose.fixture_bundling.FixtureBundlingPlugin']:
+ for plg_path in list(getattr(settings, 'NOSE_PLUGINS', [])) +
['django_nose.plugin.TestReorderer']:
try:
dot = plg_path.rindex('.')
except ValueError:
@@ -109,7 +106,9 @@
def run_suite(self, nose_argv):
result_plugin = ResultPlugin()
- plugins_to_add = [DjangoSetUpPlugin(self), result_plugin]
+ plugins_to_add = [DjangoSetUpPlugin(self),
+ result_plugin,
+ TestReorderer()]
for plugin in _get_plugins_from_settings():
plugins_to_add.append(plugin)
@@ -119,13 +118,12 @@
return result_plugin.result
def run_tests(self, test_labels, extra_tests=None):
- """
- Run the unit tests for all the test names in the provided list.
+ """Run the unit tests for all the test names in the provided list.
Test names specified may be file or module names, and may optionally
indicate the test case to run by separating the module or file name
from the test case name with a colon. Filenames may be relative or
- absolute. Examples:
+ absolute. Examples:
runner.run_tests('test.module')
runner.run_tests('another.test:TestCase.test_method')
@@ -133,6 +131,7 @@
runner.run_tests('/path/to/test/file.py:test_function')
Returns the number of tests that failed.
+
"""
nose_argv = (['nosetests', '--verbosity', str(self.verbosity)]
+ list(test_labels))
@@ -140,7 +139,7 @@
nose_argv.extend(settings.NOSE_ARGS)
# Skip over 'manage.py test' and any arguments handled by django.
- django_opts = ['--noinput']
+ django_opts = ['--noinput', '--liveserver']
for opt in BaseCommand.option_list:
django_opts.extend(opt._long_opts)
django_opts.extend(opt._short_opts)
@@ -207,7 +206,7 @@
def _reusing_db():
"""Return whether the ``REUSE_DB`` flag was passed"""
- return (os.getenv('REUSE_DB', 'false').lower() in ('true', '1', ''))
+ return os.getenv('REUSE_DB', 'false').lower() in ('true', '1', '')
def _can_support_reuse_db(connection):
@@ -285,6 +284,14 @@
if _should_create_database(connection):
# We're not using _skip_create_test_db, so put the DB name
back:
connection.settings_dict['NAME'] = orig_db_name
+
+ # Since we replaced the connection with the test DB, closing
+ # the connection will avoid pooling issues with SQLAlchemy. The
+ # issue is trying to CREATE/DROP the test database using a
+ # connection to a DB that was established with that test DB.
+ # MySQLdb doesn't allow it, and SQLAlchemy attempts to reuse
+ # the existing connection from its pool.
+ connection.close()
else:
# Reset auto-increment sequences. Apparently, SUMO's tests are
# horrid and coupled to certain numbers.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose/testcases.py
new/django-nose-1.1/django_nose/testcases.py
--- old/django-nose-1.0/django_nose/testcases.py 2012-03-13
04:46:32.000000000 +0100
+++ new/django-nose-1.1/django_nose/testcases.py 2012-05-19
20:56:19.000000000 +0200
@@ -5,7 +5,7 @@
from django.db import connections, DEFAULT_DB_ALIAS, transaction
from django_nose.fixture_tables import tables_used_by_fixtures
-from django_nose.runner import uses_mysql
+from django_nose.utils import uses_mysql
__all__ = ['FastFixtureTestCase']
@@ -32,6 +32,8 @@
plugin from django-nose, which does it dynamically at test time.
"""
+ cleans_up_after_itself = True # This is the good kind of puppy.
+
@classmethod
def setUpClass(cls):
"""Turn on manual commits. Load and commit the fixtures."""
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose/utils.py
new/django-nose-1.1/django_nose/utils.py
--- old/django-nose-1.0/django_nose/utils.py 1970-01-01 01:00:00.000000000
+0100
+++ new/django-nose-1.1/django_nose/utils.py 2012-05-19 20:56:19.000000000
+0200
@@ -0,0 +1,48 @@
+def process_tests(suite, process):
+ """Given a nested disaster of [Lazy]Suites, traverse to the first
+ level that has setup or teardown, and do something to them.
+
+ If we were to traverse all the way to the leaves (the Tests)
+ indiscriminately and return them, when the runner later calls them,
+ they'd run without reference to the suite that contained them, so
+ they'd miss their class-, module-, and package-wide setup and
+ teardown routines.
+
+ The nested suites form basically a double-linked tree, and suites
+ will call up to their containing suites to run their setups and
+ teardowns, but it would be hubris to assume that something you saw
+ fit to setup or teardown at the module level is less costly to
+ repeat than DB fixtures. Also, those sorts of setups and teardowns
+ are extremely rare in our code. Thus, we limit the granularity of
+ bucketing to the first level that has setups or teardowns.
+
+ :arg process: The thing to call once we get to a leaf or a test with setup
+ or teardown
+
+ """
+ if (not hasattr(suite, '_tests') or
+ (hasattr(suite, 'hasFixtures') and suite.hasFixtures())):
+ # We hit a Test or something with setup, so do the thing. (Note that
+ # "fixtures" here means setup or teardown routines, not Django
+ # fixtures.)
+ process(suite)
+ else:
+ for t in suite._tests:
+ process_tests(t, process)
+
+
+def is_subclass_at_all(cls, class_info):
+ """Return whether ``cls`` is a subclass of ``class_info``.
+
+ Even if ``cls`` is not a class, don't crash. Return False instead.
+
+ """
+ try:
+ return issubclass(cls, class_info)
+ except TypeError:
+ return False
+
+
+def uses_mysql(connection):
+ """Return whether the connection represents a MySQL DB."""
+ return 'mysql' in connection.settings_dict['ENGINE']
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose.egg-info/PKG-INFO
new/django-nose-1.1/django_nose.egg-info/PKG-INFO
--- old/django-nose-1.0/django_nose.egg-info/PKG-INFO 2012-03-13
20:04:49.000000000 +0100
+++ new/django-nose-1.1/django_nose.egg-info/PKG-INFO 2012-05-20
03:18:48.000000000 +0200
@@ -1,7 +1,7 @@
Metadata-Version: 1.0
Name: django-nose
-Version: 1.0
-Summary: Django test runner that uses nose
+Version: 1.1
+Summary: Makes your Django tests simple and snappy
Home-page: http://github.com/jbalogh/django-nose
Author: Erik Rose
Author-email: erikr...@grinchcentral.com
@@ -13,14 +13,25 @@
Features
--------
- * All the goodness of `nose`_ in your Django tests
+ * All the goodness of `nose`_ in your Django tests, like...
+
+ * Testing just your apps by default, not all the standard ones that
happen to
+ be in ``INSTALLED_APPS``
+ * Running the tests in one or more specific modules (or apps, or
classes, or
+ running a specific test)
+ * Obviating the need to import all your tests into
``tests/__init__.py``.
+ This not only saves busy-work but also eliminates the possibility
of
+ accidentally shadowing test classes.
+ * Taking advantage of all the useful `nose plugins`_
* Fixture bundling, an optional feature which speeds up your
fixture-based
tests by a factor of 4
* Reuse of previously created test DBs, cutting 10 seconds off startup
time
+ * Hygienic TransactionTestCases, which can save you a DB flush per test
* Support for various databases. Tested with MySQL, PostgreSQL, and
SQLite.
Others should work as well.
.. _nose: http://somethingaboutorange.com/mrl/projects/nose/
+ .. _nose plugins: http://nose-plugins.jottit.com/
Installation
@@ -73,18 +84,25 @@
the flag off the next time you run tests. This will cue the test
runner to
reinitialize the test database.
+ Also, REUSE_DB is not compatible with TransactionTestCases that leave
junk in
+ the DB, so be sure to make your TransactionTestCases hygienic (see
below) if
+ you want to use it.
+
Enabling Fast Fixtures
----------------------
- django-nose includes a nose plugin which drastically speeds up your
tests by
- eliminating redundant setup of Django test fixtures. To use it...
+ django-nose includes a fixture bundler which drastically speeds up
your tests
+ by eliminating redundant setup of Django test fixtures. To use it...
1. Subclass ``django_nose.FastFixtureTestCase`` instead of
``django.test.TestCase``. (I like to import it ``as TestCase`` in my
project's ``tests/__init__.py`` and then import it from there into
my actual
- tests. Then it's easy to sub the base class in and out.)
- 2. Activate the plugin by passing the ``--with-fixture-bundling``
option to ``./manage.py test``.
+ tests. Then it's easy to sub the base class in and out.) This alone
will
+ cause fixtures to load once per class rather than once per test.
+ 2. Activate fixture bundling by passing the
``--with-fixture-bundling`` option
+ to ``./manage.py test``. This loads each unique set of fixtures
only once,
+ even across class, module, and app boundaries.
How Fixture Bundling Works
~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -132,6 +150,59 @@
``exempt_from_fixture_bundling`` attribute of the test class to
``True``.
+ Speedy Hygienic TransactionTestCases
+ ------------------------------------
+
+ Unlike the stock Django test runner, django-nose lets you write custom
+ TransactionTestCase subclasses which expect to start with an unmarred
DB,
+ saving an entire DB flush per test.
+
+ Background
+ ~~~~~~~~~~
+
+ The default Django TransactionTestCase class `can leave the DB in an
unclean
+ state`_ when it's done. To compensate, TransactionTestCase does a
+ time-consuming flush of the DB *before* each test to ensure it begins
with a
+ clean slate. Django's stock test runner then runs TransactionTestCases
last so
+ they don't wreck the environment for better-behaved tests. django-nose
+ replicates this behavior.
+
+ Escaping the Grime
+ ~~~~~~~~~~~~~~~~~~
+
+ Some people, however, have made subclasses of TransactionTestCase that
clean up
+ after themselves (and can do so efficiently, since they know what
they've
+ changed). Like TestCase, these may assume they start with a clean DB.
However,
+ any TransactionTestCases that run before them and leave a mess could
cause them
+ to fail spuriously.
+
+ django-nose offers to fix this. If you include a special attribute on
your
+ well-behaved TransactionTestCase... ::
+
+ class MyNiceTestCase(TransactionTestCase):
+ cleans_up_after_itself = True
+
+ ...django-nose will run it before any of those nasty, trash-spewing
test cases.
+ You can thus enjoy a big speed boost any time you make a
TransactionTestCase
+ clean up after itself: skipping a whole DB flush before every test.
With a
+ large schema, this can save minutes of IO.
+
+ django-nose's own FastFixtureTestCase uses this feature, even though it
+ ultimately acts more like a TestCase than a TransactionTestCase.
+
+ .. _can leave the DB in an unclean state:
https://docs.djangoproject.com/en/dev/topics/testing/?from=olddocs#django.test.TransactionTestCase
+
+
+ Test-Only Models
+ ----------------
+
+ If you have a model that is used only by tests (for example, to test an
+ abstract model base class), you can put it in any file that's imported
in the
+ course of loading tests. For example, if the tests that need it are in
+ ``test_models.py``, you can put the model in there, too. django-nose
will make
+ sure its DB table gets created.
+
+
Using With South
----------------
@@ -198,10 +269,32 @@
https://github.com/jbalogh/django-nose/tree/django-1.1 or
http://pypi.python.org/pypi/django-nose/0.0.3.
+ Django 1.0
+ ~~~~~~~~~~
+
+ django-nose does not support Django 1.0.
+
Recent Version History
----------------------
+ 1.1
+ * Django TransactionTestCases don't clean up after themselves; they
leave
+ junk in the DB and clean it up only on _pre_setup. Thus, Django
makes sure
+ these tests run last. Now django-nose does, too. This means one
fewer
+ source of failures on existing projects. (Erik Rose)
+ * Add support for hygienic TransactionTestCases. (Erik Rose)
+ * Support models that are used only for tests. Just put them in any
file
+ imported in the course of loading tests. No more crazy hacks
necessary.
+ (Erik Rose)
+ * Make the fixture bundler more conservative, fixing some conceivable
+ situations in which fixtures would not appear as intended if a
+ TransactionTestCase found its way into the middle of a bundle.
(Erik Rose)
+ * Fix an error that would surface when using SQLAlchemy with
connection
+ pooling. (Roger Hu)
+ * Gracefully ignore the new ``--liveserver`` option introduced in
Django 1.4;
+ don't let it through to nose. (Adam DePue)
+
1.0 (2012-03-12)
* New fixture-bundling plugin for avoiding needless fixture setup
(Erik Rose)
* Moved FastFixtureTestCase in from test-utils, so now all the
@@ -213,7 +306,6 @@
* Nail down versions of the package requirements. (Daniel Mizyrycki)
0.1.3 (2010-04-15)
-
* Even better coverage support (rozza)
* README fixes (carljm and ionelmc)
* optparse OptionGroups are handled better (outofculture)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/django_nose.egg-info/SOURCES.txt
new/django-nose-1.1/django_nose.egg-info/SOURCES.txt
--- old/django-nose-1.0/django_nose.egg-info/SOURCES.txt 2012-03-13
20:04:49.000000000 +0100
+++ new/django-nose-1.1/django_nose.egg-info/SOURCES.txt 2012-05-20
03:18:48.000000000 +0200
@@ -5,11 +5,11 @@
runtests.sh
setup.py
django_nose/__init__.py
-django_nose/fixture_bundling.py
django_nose/fixture_tables.py
django_nose/plugin.py
django_nose/runner.py
django_nose/testcases.py
+django_nose/utils.py
django_nose.egg-info/PKG-INFO
django_nose.egg-info/SOURCES.txt
django_nose.egg-info/dependency_links.txt
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/django-nose-1.0/setup.py new/django-nose-1.1/setup.py
--- old/django-nose-1.0/setup.py 2012-03-13 20:03:34.000000000 +0100
+++ new/django-nose-1.1/setup.py 2012-05-20 03:15:22.000000000 +0200
@@ -6,8 +6,8 @@
setup(
name='django-nose',
- version='1.0',
- description='Django test runner that uses nose',
+ version='1.1',
+ description='Makes your Django tests simple and snappy',
long_description=open(os.path.join(ROOT, 'README.rst')).read(),
author='Jeff Balogh',
author_email='m...@jeffbalogh.org',
@@ -15,7 +15,7 @@
maintainer_email='erikr...@grinchcentral.com',
url='http://github.com/jbalogh/django-nose',
license='BSD',
- packages=find_packages(exclude=['testapp','testapp/*']),
+ packages=find_packages(exclude=['testapp', 'testapp/*']),
include_package_data=True,
zip_safe=False,
install_requires=['nose>=1.0', 'Django>=1.2'],
Files old/django-nose-1.0/testapp/.DS_Store and
new/django-nose-1.1/testapp/.DS_Store differ
--
To unsubscribe, e-mail: opensuse-commit+unsubscr...@opensuse.org
For additional commands, e-mail: opensuse-commit+h...@opensuse.org
