Merged trunk changes r13316:13342 into test-refactor SOC branch.

git-svn-id: http://code.djangoproject.com/svn/django/branches/soc2010/test-refactor@13343 bcc190cf-cafb-0310-a4f2-bffc1f526a37

7 files changed, 246 insertions, 183 deletions

diff --git a/tests/regressiontests/backends/models.py b/tests/regressiontests/backends/models.py
index 423bead1ad..e3137f2710 100644
--- a/tests/regressiontests/backends/models.py
+++ b/tests/regressiontests/backends/models.py
@@ -1,5 +1,7 @@
+from django.conf import settings
 from django.db import models
-from django.db import connection
+from django.db import connection, DEFAULT_DB_ALIAS
+
 
 class Square(models.Model):
     root = models.IntegerField()
@@ -8,6 +10,7 @@ class Square(models.Model):
     def __unicode__(self):
         return "%s ** 2 == %s" % (self.root, self.square)
 
+
 class Person(models.Model):
     first_name = models.CharField(max_length=20)
     last_name = models.CharField(max_length=20)
@@ -15,11 +18,25 @@ class Person(models.Model):
     def __unicode__(self):
         return u'%s %s' % (self.first_name, self.last_name)
 
+
 class SchoolClass(models.Model):
     year = models.PositiveIntegerField()
     day = models.CharField(max_length=9, blank=True)
     last_updated = models.DateTimeField()
 
+# Unfortunately, the following model breaks MySQL hard.
+# Until #13711 is fixed, this test can't be run under MySQL.
+if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.mysql':
+    class VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ(models.Model):
+        class Meta:
+            # We need to use a short actual table name or
+            # we hit issue #8548 which we're not testing!
+            verbose_name = 'model_with_long_table_name'
+        primary_key_is_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = models.AutoField(primary_key=True)
+        charfield_is_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = models.CharField(max_length=100)
+        m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz = models.ManyToManyField(Person,blank=True)
+
+
 qn = connection.ops.quote_name
 
 __test__ = {'API_TESTS': """
diff --git a/tests/regressiontests/backends/tests.py b/tests/regressiontests/backends/tests.py
index 6a26a608eb..ee3ccdc72f 100644
--- a/tests/regressiontests/backends/tests.py
+++ b/tests/regressiontests/backends/tests.py
@@ -1,13 +1,17 @@
 # -*- coding: utf-8 -*-
 # Unit and doctests for specific database backends.
 import datetime
-import models
 import unittest
+
+from django.conf import settings
+from django.core import management
+from django.core.management.color import no_style
 from django.db import backend, connection, DEFAULT_DB_ALIAS
 from django.db.backends.signals import connection_created
-from django.conf import settings
 from django.test import TestCase
 
+from regressiontests.backends import models
+
 class Callproc(unittest.TestCase):
 
     def test_dbms_session(self):
@@ -76,6 +80,7 @@ class DateQuotingTest(TestCase):
         classes = models.SchoolClass.objects.filter(last_updated__day=20)
         self.assertEqual(len(classes), 1)
 
+
 class ParameterHandlingTest(TestCase):
     def test_bad_parameter_count(self):
         "An executemany call with too many/not enough parameters will raise an exception (Refs #12612)"
@@ -88,6 +93,50 @@ class ParameterHandlingTest(TestCase):
         self.assertRaises(Exception, cursor.executemany, query, [(1,2,3),])
         self.assertRaises(Exception, cursor.executemany, query, [(1,),])
 
+# Unfortunately, the following tests would be a good test to run on all
+# backends, but it breaks MySQL hard. Until #13711 is fixed, it can't be run
+# everywhere (although it would be an effective test of #13711).
+if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.mysql':
+    class LongNameTest(TestCase):
+        """Long primary keys and model names can result in a sequence name
+        that exceeds the database limits, which will result in truncation
+        on certain databases (e.g., Postgres). The backend needs to use
+        the correct sequence name in last_insert_id and other places, so
+        check it is. Refs #8901.
+        """
+
+        def test_sequence_name_length_limits_create(self):
+            """Test creation of model with long name and long pk name doesn't error. Ref #8901"""
+            models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
+
+        def test_sequence_name_length_limits_m2m(self):
+            """Test an m2m save of a model with a long name and a long m2m field name doesn't error as on Django >=1.2 this now uses object saves. Ref #8901"""
+            obj = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
+            rel_obj = models.Person.objects.create(first_name='Django', last_name='Reinhardt')
+            obj.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.add(rel_obj)
+
+        def test_sequence_name_length_limits_flush(self):
+            """Test that sequence resetting as part of a flush with model with long name and long pk name doesn't error. Ref #8901"""
+            # A full flush is expensive to the full test, so we dig into the
+            # internals to generate the likely offending SQL and run it manually
+
+            # Some convenience aliases
+            VLM = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+            VLM_m2m = VLM.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.through
+            tables = [
+                VLM._meta.db_table,
+                VLM_m2m._meta.db_table,
+            ]
+            sequences = [
+                {
+                    'column': VLM._meta.pk.column,
+                    'table': VLM._meta.db_table
+                },
+            ]
+            cursor = connection.cursor()
+            for statement in connection.ops.sql_flush(no_style(), tables, sequences):
+                cursor.execute(statement)
+
 
 def connection_created_test(sender, **kwargs):
     print 'connection_created signal'
diff --git a/tests/regressiontests/csrf_tests/tests.py b/tests/regressiontests/csrf_tests/tests.py
index 0a24522d9c..f383978266 100644
--- a/tests/regressiontests/csrf_tests/tests.py
+++ b/tests/regressiontests/csrf_tests/tests.py
@@ -3,7 +3,7 @@
 from django.test import TestCase
 from django.http import HttpRequest, HttpResponse
 from django.middleware.csrf import CsrfMiddleware, CsrfViewMiddleware
-from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.csrf import csrf_exempt, csrf_view_exempt
 from django.core.context_processors import csrf
 from django.contrib.sessions.middleware import SessionMiddleware
 from django.utils.importlib import import_module
@@ -123,6 +123,23 @@ class CsrfMiddlewareTest(TestCase):
         # Check the Vary header got patched correctly
         self.assert_('Cookie' in resp2.get('Vary',''))
 
+    def test_process_response_for_exempt_view(self):
+        """
+        Check that a view decorated with 'csrf_view_exempt' is still
+        post-processed to add the CSRF token.
+        """
+        req = self._get_GET_no_csrf_cookie_request()
+        CsrfMiddleware().process_view(req, csrf_view_exempt(post_form_view), (), {})
+
+        resp = post_form_response()
+        resp_content = resp.content # needed because process_response modifies resp
+        resp2 = CsrfMiddleware().process_response(req, resp)
+
+        csrf_cookie = resp2.cookies.get(settings.CSRF_COOKIE_NAME, False)
+        self.assertNotEqual(csrf_cookie, False)
+        self.assertNotEqual(resp_content, resp2.content)
+        self._check_token_present(resp2, csrf_cookie.value)
+
     def test_process_response_no_csrf_cookie_view_only_get_token_used(self):
         """
         When no prior CSRF cookie exists, check that the cookie is created, even
@@ -279,6 +296,15 @@ class CsrfMiddlewareTest(TestCase):
         resp = token_view(req)
         self._check_token_present(resp)
 
+    def test_get_token_for_exempt_view(self):
+        """
+        Check that get_token still works for a view decorated with 'csrf_view_exempt'.
+        """
+        req = self._get_GET_csrf_cookie_request()
+        CsrfViewMiddleware().process_view(req, csrf_view_exempt(token_view), (), {})
+        resp = token_view(req)
+        self._check_token_present(resp)
+
     def test_token_node_with_new_csrf_cookie(self):
         """
         Check that CsrfTokenNode works when a CSRF cookie is created by
diff --git a/tests/regressiontests/m2m_through_regress/models.py b/tests/regressiontests/m2m_through_regress/models.py
index 56aecd6975..ec87985765 100644
--- a/tests/regressiontests/m2m_through_regress/models.py
+++ b/tests/regressiontests/m2m_through_regress/models.py
@@ -1,8 +1,10 @@
 from datetime import datetime
+
 from django.contrib.auth.models import User
 from django.core import management
 from django.db import models
 
+
 # Forward declared intermediate model
 class Membership(models.Model):
     person = models.ForeignKey('Person')
@@ -51,159 +53,3 @@ class Through(ThroughBase):
 class B(models.Model):
     b_text = models.CharField(max_length=20)
     a_list = models.ManyToManyField(A, through=Through)
-
-
-__test__ = {'API_TESTS':"""
-# Create some dummy data
->>> bob = Person.objects.create(name='Bob')
->>> jim = Person.objects.create(name='Jim')
-
->>> rock = Group.objects.create(name='Rock')
->>> roll = Group.objects.create(name='Roll')
-
->>> frank = User.objects.create_user('frank','frank@example.com','password')
->>> jane = User.objects.create_user('jane','jane@example.com','password')
-
-# Now test that the forward declared Membership works
->>> Membership.objects.create(person=bob, group=rock)
-<Membership: Bob is a member of Rock>
-
->>> Membership.objects.create(person=bob, group=roll)
-<Membership: Bob is a member of Roll>
-
->>> Membership.objects.create(person=jim, group=rock)
-<Membership: Jim is a member of Rock>
-
->>> bob.group_set.all()
-[<Group: Rock>, <Group: Roll>]
-
->>> roll.members.all()
-[<Person: Bob>]
-
-# Error messages use the model name, not repr of the class name
->>> bob.group_set = []
-Traceback (most recent call last):
-...
-AttributeError: Cannot set values on a ManyToManyField which specifies an intermediary model.  Use m2m_through_regress.Membership's Manager instead.
-
->>> roll.members = []
-Traceback (most recent call last):
-...
-AttributeError: Cannot set values on a ManyToManyField which specifies an intermediary model.  Use m2m_through_regress.Membership's Manager instead.
-
->>> rock.members.create(name='Anne')
-Traceback (most recent call last):
-...
-AttributeError: Cannot use create() on a ManyToManyField which specifies an intermediary model.  Use m2m_through_regress.Membership's Manager instead.
-
->>> bob.group_set.create(name='Funk')
-Traceback (most recent call last):
-...
-AttributeError: Cannot use create() on a ManyToManyField which specifies an intermediary model.  Use m2m_through_regress.Membership's Manager instead.
-
-# Now test that the intermediate with a relationship outside
-# the current app (i.e., UserMembership) workds
->>> UserMembership.objects.create(user=frank, group=rock)
-<UserMembership: frank is a user and member of Rock>
-
->>> UserMembership.objects.create(user=frank, group=roll)
-<UserMembership: frank is a user and member of Roll>
-
->>> UserMembership.objects.create(user=jane, group=rock)
-<UserMembership: jane is a user and member of Rock>
-
->>> frank.group_set.all()
-[<Group: Rock>, <Group: Roll>]
-
->>> roll.user_members.all()
-[<User: frank>]
-
-# Regression test for #8134 --
-# m2m-through models shouldn't be serialized as m2m fields on the model.
-
-# First, clean up a lot of objects we don't need.
-# The serialization test only requires three objects to work -
-# one for each end of the m2m, plus the through model.
-
->>> User.objects.all().delete()
->>> UserMembership.objects.all().delete()
->>> frank.delete()
->>> rock.delete()
->>> jim.delete()
-
-# Dump the current contents of the database as a JSON fixture
->>> management.call_command('dumpdata', 'm2m_through_regress', format='json', indent=2)
-[
-  {
-    "pk": 2,
-    "model": "m2m_through_regress.membership",
-    "fields": {
-      "person": 1,
-      "price": 100,
-      "group": 2
-    }
-  },
-  {
-    "pk": 1,
-    "model": "m2m_through_regress.person",
-    "fields": {
-      "name": "Bob"
-    }
-  },
-  {
-    "pk": 2,
-    "model": "m2m_through_regress.group",
-    "fields": {
-      "name": "Roll"
-    }
-  }
-]
-
-# Check the XML serializer too, since it doesn't use the common implementation
->>> management.call_command('dumpdata', 'm2m_through_regress', format='xml', indent=2)
-<?xml version="1.0" encoding="utf-8"?>
-<django-objects version="1.0">
-  <object pk="2" model="m2m_through_regress.membership">
-    <field to="m2m_through_regress.person" name="person" rel="ManyToOneRel">1</field>
-    <field to="m2m_through_regress.group" name="group" rel="ManyToOneRel">2</field>
-    <field type="IntegerField" name="price">100</field>
-  </object>
-  <object pk="1" model="m2m_through_regress.person">
-    <field type="CharField" name="name">Bob</field>
-  </object>
-  <object pk="2" model="m2m_through_regress.group">
-    <field type="CharField" name="name">Roll</field>
-  </object>
-</django-objects>
-
-## Regression test for #8046:
-Check that we don't involve too many copies of the intermediate table when
-doing a join.
-
->>> bob = Person.objects.create(name='Bob')
->>> jim = Person.objects.create(name='Jim')
->>> rock = Group.objects.create(name='Rock')
->>> roll = Group.objects.create(name='Roll')
->>> _ = Membership.objects.create(person=bob, group=rock)
->>> _ = Membership.objects.create(person=jim, group=rock, price=50)
->>> _ = Membership.objects.create(person=bob, group=roll, price=50)
->>> rock.members.filter(membership__price=50)
-[<Person: Jim>]
-
-## Regression test for #8254
->>> bob.group_set.filter(membership__price=50)
-[<Group: Roll>]
-
-## Regression test for #9804
-# Flush the database, just to make sure we can.
->>> management.call_command('flush', verbosity=0, interactive=False)
-
-## Regression test for #11107
-Ensure that sequences on m2m_through tables are being created for the through
-model, not for a phantom auto-generated m2m table.
-
->>> management.call_command('loaddata', 'm2m_through', verbosity=0)
->>> management.call_command('dumpdata', 'm2m_through_regress', format='json')
-[{"pk": 1, "model": "m2m_through_regress.usermembership", "fields": {"price": 100, "group": 1, "user": 1}}, {"pk": 1, "model": "m2m_through_regress.person", "fields": {"name": "Guido"}}, {"pk": 1, "model": "m2m_through_regress.group", "fields": {"name": "Python Core Group"}}]
-
-"""}
diff --git a/tests/regressiontests/m2m_through_regress/tests.py b/tests/regressiontests/m2m_through_regress/tests.py
new file mode 100644
index 0000000000..ff1d95020e
--- /dev/null
+++ b/tests/regressiontests/m2m_through_regress/tests.py
@@ -0,0 +1,126 @@
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO
+
+from django.core import management
+from django.contrib.auth.models import User
+from django.test import TestCase
+
+from models import Person, Group, Membership, UserMembership
+
+
+class M2MThroughTestCase(TestCase):
+    def test_everything(self):
+        bob = Person.objects.create(name="Bob")
+        jim = Person.objects.create(name="Jim")
+
+        rock = Group.objects.create(name="Rock")
+        roll = Group.objects.create(name="Roll")
+
+        frank = User.objects.create_user("frank", "frank@example.com", "password")
+        jane = User.objects.create_user("jane", "jane@example.com", "password")
+
+        Membership.objects.create(person=bob, group=rock)
+        Membership.objects.create(person=bob, group=roll)
+        Membership.objects.create(person=jim, group=rock)
+
+        self.assertQuerysetEqual(
+            bob.group_set.all(), [
+                "<Group: Rock>",
+                "<Group: Roll>",
+            ]
+        )
+
+        self.assertQuerysetEqual(
+            roll.members.all(), [
+                "<Person: Bob>",
+            ]
+        )
+
+        self.assertRaises(AttributeError, setattr, bob, "group_set", [])
+        self.assertRaises(AttributeError, setattr, roll, "members", [])
+
+        self.assertRaises(AttributeError, rock.members.create, name="Anne")
+        self.assertRaises(AttributeError, bob.group_set.create, name="Funk")
+
+        UserMembership.objects.create(user=frank, group=rock)
+        UserMembership.objects.create(user=frank, group=roll)
+        UserMembership.objects.create(user=jane, group=rock)
+
+        self.assertQuerysetEqual(
+            frank.group_set.all(), [
+                "<Group: Rock>",
+                "<Group: Roll>",
+            ]
+        )
+
+        self.assertQuerysetEqual(
+            roll.user_members.all(), [
+                "<User: frank>",
+            ]
+        )
+
+    def test_serialization(self):
+        "m2m-through models aren't serialized as m2m fields. Refs #8134"
+
+        p = Person.objects.create(name="Bob")
+        g = Group.objects.create(name="Roll")
+        Membership.objects.create(person=p, group=g)
+
+        out = StringIO()
+        management.call_command("dumpdata", "m2m_through_regress", format="json", stdout=out)
+        self.assertEqual(out.getvalue().strip(), """[{"pk": 1, "model": "m2m_through_regress.membership", "fields": {"person": 1, "price": 100, "group": 1}}, {"pk": 1, "model": "m2m_through_regress.person", "fields": {"name": "Bob"}}, {"pk": 1, "model": "m2m_through_regress.group", "fields": {"name": "Roll"}}]""")
+
+        out = StringIO()
+        management.call_command("dumpdata", "m2m_through_regress", format="xml",
+            indent=2, stdout=out)
+        self.assertEqual(out.getvalue().strip(), """
+<?xml version="1.0" encoding="utf-8"?>
+<django-objects version="1.0">
+  <object pk="1" model="m2m_through_regress.membership">
+    <field to="m2m_through_regress.person" name="person" rel="ManyToOneRel">1</field>
+    <field to="m2m_through_regress.group" name="group" rel="ManyToOneRel">1</field>
+    <field type="IntegerField" name="price">100</field>
+  </object>
+  <object pk="1" model="m2m_through_regress.person">
+    <field type="CharField" name="name">Bob</field>
+  </object>
+  <object pk="1" model="m2m_through_regress.group">
+    <field type="CharField" name="name">Roll</field>
+  </object>
+</django-objects>
+        """.strip())
+
+    def test_join_trimming(self):
+        "Check that we don't involve too many copies of the intermediate table when doing a join. Refs #8046, #8254"
+        bob  = Person.objects.create(name="Bob")
+        jim = Person.objects.create(name="Jim")
+
+        rock = Group.objects.create(name="Rock")
+        roll = Group.objects.create(name="Roll")
+
+        Membership.objects.create(person=bob, group=rock)
+        Membership.objects.create(person=jim, group=rock, price=50)
+        Membership.objects.create(person=bob, group=roll, price=50)
+
+        self.assertQuerysetEqual(
+            rock.members.filter(membership__price=50), [
+                "<Person: Jim>",
+            ]
+        )
+
+        self.assertQuerysetEqual(
+            bob.group_set.filter(membership__price=50), [
+                "<Group: Roll>",
+            ]
+        )
+
+class ThroughLoadDataTestCase(TestCase):
+    fixtures = ["m2m_through"]
+
+    def test_sequence_creation(self):
+        "Check that sequences on an m2m_through are created for the through model, not a phantom auto-generated m2m table. Refs #11107"
+        out = StringIO()
+        management.call_command("dumpdata", "m2m_through_regress", format="json", stdout=out)
+        self.assertEqual(out.getvalue().strip(), """[{"pk": 1, "model": "m2m_through_regress.usermembership", "fields": {"price": 100, "group": 1, "user": 1}}, {"pk": 1, "model": "m2m_through_regress.person", "fields": {"name": "Guido"}}, {"pk": 1, "model": "m2m_through_regress.group", "fields": {"name": "Python Core Group"}}]""")
diff --git a/tests/regressiontests/multiple_database/tests.py b/tests/regressiontests/multiple_database/tests.py
index 7bde8bf037..6675fdcc6c 100644
--- a/tests/regressiontests/multiple_database/tests.py
+++ b/tests/regressiontests/multiple_database/tests.py
@@ -883,7 +883,13 @@ class QueryTestCase(TestCase):
         self.assertRaises(ValueError, str, qs.query)
 
         # Evaluating the query shouldn't work, either
-        self.assertRaises(ValueError, list, qs)
+        try:
+            for obj in qs:
+                pass
+            self.fail('Iterating over query should raise ValueError')
+        except ValueError:
+            pass
+
 
 class TestRouter(object):
     # A test router. The behaviour is vaguely master/slave, but the
@@ -1491,19 +1497,10 @@ class AuthTestCase(TestCase):
         self.old_routers = router.routers
         router.routers = [AuthRouter()]
 
-        # Redirect stdout to a buffer so we can test
-        # the output of a management command
-        self.old_stdout = sys.stdout
-        self.stdout = StringIO()
-        sys.stdout = self.stdout
-
     def tearDown(self):
         # Restore the 'other' database as an independent database
         router.routers = self.old_routers
 
-        # Restore stdout
-        sys.stdout = self.old_stdout
-
     def test_auth_manager(self):
         "The methods on the auth manager obey database hints"
         # Create one user using default allocation policy
@@ -1539,14 +1536,16 @@ class AuthTestCase(TestCase):
 
         # Check that dumping the default database doesn't try to include auth
         # because allow_syncdb prohibits auth on default
-        self.stdout.flush()
-        management.call_command('dumpdata', 'auth', format='json', database='default')
-        self.assertEquals(self.stdout.getvalue(), '[]\n')
+        new_io = StringIO()
+        management.call_command('dumpdata', 'auth', format='json', database='default', stdout=new_io)
+        command_output = new_io.getvalue().strip()
+        self.assertEqual(command_output, '[]')
 
         # Check that dumping the other database does include auth
-        self.stdout.flush()
-        management.call_command('dumpdata', 'auth', format='json', database='other')
-        self.assertTrue('alice@example.com' in self.stdout.getvalue())
+        new_io = StringIO()
+        management.call_command('dumpdata', 'auth', format='json', database='other', stdout=new_io)
+        command_output = new_io.getvalue().strip()
+        self.assertTrue('"email": "alice@example.com",' in command_output)
 
 class UserProfileTestCase(TestCase):
     def setUp(self):
diff --git a/tests/regressiontests/utils/timesince.py b/tests/regressiontests/utils/timesince.py
index 04878b272a..5a54bf4c8c 100644
--- a/tests/regressiontests/utils/timesince.py
+++ b/tests/regressiontests/utils/timesince.py
@@ -88,11 +88,11 @@ u'0 minutes'
 u'0 minutes'
 
 # Timesince should work with both date objects (#9672)
->>> today = datetime.date.today() 
->>> timeuntil(today+oneday, today) 
-u'1 day' 
->>> timeuntil(today-oneday, today) 
-u'0 minutes' 
->>> timeuntil(today+oneweek, today) 
-u'1 week' 
+>>> today = datetime.date.today()
+>>> timeuntil(today+oneday, today)
+u'1 day'
+>>> timeuntil(today-oneday, today)
+u'0 minutes'
+>>> timeuntil(today+oneweek, today)
+u'1 week'
 """