[soc2009-testing] Adding some missed files

git-svn-id: http://code.djangoproject.com/svn/django/branches/soc2009/test-improvements@10969 bcc190cf-cafb-0310-a4f2-bffc1f526a37

tests/modeltests/custom_pk/fields.py

@@ -0,0 +1,54 @@
+import random
+import string
+
+from django.db import models
+
+class MyWrapper(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __repr__(self):
+        return "<%s: %s>" % (self.__class__.__name__, self.value)
+
+    def __unicode__(self):
+        return self.value
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.value == other.value
+        return self.value == other
+
+class MyAutoField(models.CharField):
+    __metaclass__ = models.SubfieldBase
+
+    def __init__(self, *args, **kwargs):
+        kwargs['max_length'] = 10
+        super(MyAutoField, self).__init__(*args, **kwargs)
+
+    def pre_save(self, instance, add):
+        value = getattr(instance, self.attname, None)
+        if not value:
+            value = MyWrapper(''.join(random.sample(string.lowercase, 10)))
+            setattr(instance, self.attname, value)
+        return value
+
+    def to_python(self, value):
+        if not value:
+            return
+        if not isinstance(value, MyWrapper):
+            value = MyWrapper(value)
+        return value
+
+    def get_db_prep_save(self, value):
+        if not value:
+            return
+        if isinstance(value, MyWrapper):
+            return unicode(value)
+        return value
+
+    def get_db_prep_value(self, value):
+        if not value:
+            return
+        if isinstance(value, MyWrapper):
+            return unicode(value)
+        return value

tests/modeltests/proxy_models/fixtures/mypeople.json

@@ -0,0 +1,9 @@
+[
+    {
+        "pk": 100,
+        "model": "proxy_models.myperson",
+        "fields": {
+            "name": "Elvis Presley"
+        }
+    }
+]

tests/regressiontests/delete_regress/__init__.py

@@ -0,0 +1 @@
+

tests/regressiontests/delete_regress/models.py

@@ -0,0 +1,61 @@
+from django.conf import settings
+from django.db import models, backend, connection, transaction
+from django.db.models import sql, query
+from django.test import TransactionTestCase
+
+class Book(models.Model):
+    pagecount = models.IntegerField()
+
+# Can't run this test under SQLite, because you can't
+# get two connections to an in-memory database.
+if settings.DATABASE_ENGINE != 'sqlite3':
+    class DeleteLockingTest(TransactionTestCase):
+        def setUp(self):
+            # Create a second connection to the database
+            self.conn2 = backend.DatabaseWrapper({
+                'DATABASE_HOST': settings.DATABASE_HOST,
+                'DATABASE_NAME': settings.DATABASE_NAME,
+                'DATABASE_OPTIONS': settings.DATABASE_OPTIONS,
+                'DATABASE_PASSWORD': settings.DATABASE_PASSWORD,
+                'DATABASE_PORT': settings.DATABASE_PORT,
+                'DATABASE_USER': settings.DATABASE_USER,
+                'TIME_ZONE': settings.TIME_ZONE,
+            })
+
+            # Put both DB connections into managed transaction mode
+            transaction.enter_transaction_management()
+            transaction.managed(True)
+            self.conn2._enter_transaction_management(True)
+
+        def tearDown(self):
+            # Close down the second connection.
+            transaction.leave_transaction_management()
+            self.conn2.close()
+
+        def test_concurrent_delete(self):
+            "Deletes on concurrent transactions don't collide and lock the database. Regression for #9479"
+
+            # Create some dummy data
+            b1 = Book(id=1, pagecount=100)
+            b2 = Book(id=2, pagecount=200)
+            b3 = Book(id=3, pagecount=300)
+            b1.save()
+            b2.save()
+            b3.save()
+
+            transaction.commit()
+
+            self.assertEquals(3, Book.objects.count())
+
+            # Delete something using connection 2.
+            cursor2 = self.conn2.cursor()
+            cursor2.execute('DELETE from delete_regress_book WHERE id=1')
+            self.conn2._commit();
+
+            # Now perform a queryset delete that covers the object
+            # deleted in connection 2. This causes an infinite loop
+            # under MySQL InnoDB unless we keep track of already
+            # deleted objects.
+            Book.objects.filter(pagecount__lt=250).delete()
+            transaction.commit()
+            self.assertEquals(1, Book.objects.count())