Merged regressiontests and modeltests into the test root.

4 files changed, 227 insertions, 0 deletions

diff --git a/tests/known_related_objects/__init__.py b/tests/known_related_objects/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/tests/known_related_objects/__init__.py
diff --git a/tests/known_related_objects/fixtures/tournament.json b/tests/known_related_objects/fixtures/tournament.json
new file mode 100644
index 0000000000..bd4cbc17a7
--- /dev/null
+++ b/tests/known_related_objects/fixtures/tournament.json
@@ -0,0 +1,76 @@
+[
+    {
+        "pk": 1,
+        "model": "known_related_objects.tournament",
+        "fields": {
+            "name": "Tourney 1"
+        }
+    },
+    {
+        "pk": 2,
+        "model": "known_related_objects.tournament",
+        "fields": {
+            "name": "Tourney 2"
+        }
+    },
+    {
+        "pk": 1,
+        "model": "known_related_objects.organiser",
+        "fields": {
+            "name": "Organiser 1"
+        }
+    },
+    {
+        "pk": 1,
+        "model": "known_related_objects.pool",
+        "fields": {
+            "tournament": 1,
+            "organiser": 1,
+            "name": "T1 Pool 1"
+        }
+    },
+    {
+        "pk": 2,
+        "model": "known_related_objects.pool",
+        "fields": {
+            "tournament": 1,
+            "organiser": 1,
+            "name": "T1 Pool 2"
+        }
+    },
+    {
+        "pk": 3,
+        "model": "known_related_objects.pool",
+        "fields": {
+            "tournament": 2,
+            "organiser": 1,
+            "name": "T2 Pool 1"
+        }
+    },
+    {
+        "pk": 4,
+        "model": "known_related_objects.pool",
+        "fields": {
+            "tournament": 2,
+            "organiser": 1,
+            "name": "T2 Pool 2"
+        }
+    },
+    {
+        "pk": 1,
+        "model": "known_related_objects.poolstyle",
+        "fields": {
+            "name": "T1 Pool 2 Style",
+            "pool": 2
+        }
+    },
+    {
+        "pk": 2,
+        "model": "known_related_objects.poolstyle",
+        "fields": {
+            "name": "T2 Pool 1 Style",
+            "pool": 3
+        }
+    }
+]
+
diff --git a/tests/known_related_objects/models.py b/tests/known_related_objects/models.py
new file mode 100644
index 0000000000..e256cc38f2
--- /dev/null
+++ b/tests/known_related_objects/models.py
@@ -0,0 +1,23 @@
+"""
+Existing related object instance caching.
+
+Test that queries are not redone when going back through known relations.
+"""
+
+from django.db import models
+
+class Tournament(models.Model):
+    name = models.CharField(max_length=30)
+
+class Organiser(models.Model):
+    name = models.CharField(max_length=30)
+
+class Pool(models.Model):
+    name = models.CharField(max_length=30)
+    tournament = models.ForeignKey(Tournament)
+    organiser = models.ForeignKey(Organiser)
+
+class PoolStyle(models.Model):
+    name = models.CharField(max_length=30)
+    pool = models.OneToOneField(Pool)
+
diff --git a/tests/known_related_objects/tests.py b/tests/known_related_objects/tests.py
new file mode 100644
index 0000000000..d28d266557
--- /dev/null
+++ b/tests/known_related_objects/tests.py
@@ -0,0 +1,128 @@
+from __future__ import absolute_import
+
+from django.test import TestCase
+
+from .models import Tournament, Organiser, Pool, PoolStyle
+
+class ExistingRelatedInstancesTests(TestCase):
+    fixtures = ['tournament.json']
+
+    def test_foreign_key(self):
+        with self.assertNumQueries(2):
+            tournament = Tournament.objects.get(pk=1)
+            pool = tournament.pool_set.all()[0]
+            self.assertIs(tournament, pool.tournament)
+
+    def test_foreign_key_prefetch_related(self):
+        with self.assertNumQueries(2):
+            tournament = (Tournament.objects.prefetch_related('pool_set').get(pk=1))
+            pool = tournament.pool_set.all()[0]
+            self.assertIs(tournament, pool.tournament)
+
+    def test_foreign_key_multiple_prefetch(self):
+        with self.assertNumQueries(2):
+            tournaments = list(Tournament.objects.prefetch_related('pool_set').order_by('pk'))
+            pool1 = tournaments[0].pool_set.all()[0]
+            self.assertIs(tournaments[0], pool1.tournament)
+            pool2 = tournaments[1].pool_set.all()[0]
+            self.assertIs(tournaments[1], pool2.tournament)
+
+    def test_queryset_or(self):
+        tournament_1 = Tournament.objects.get(pk=1)
+        tournament_2 = Tournament.objects.get(pk=2)
+        with self.assertNumQueries(1):
+            pools = tournament_1.pool_set.all() | tournament_2.pool_set.all()
+            related_objects = set(pool.tournament for pool in pools)
+            self.assertEqual(related_objects, set((tournament_1, tournament_2)))
+
+    def test_queryset_or_different_cached_items(self):
+        tournament = Tournament.objects.get(pk=1)
+        organiser = Organiser.objects.get(pk=1)
+        with self.assertNumQueries(1):
+            pools = tournament.pool_set.all() | organiser.pool_set.all()
+            first = pools.filter(pk=1)[0]
+            self.assertIs(first.tournament, tournament)
+            self.assertIs(first.organiser, organiser)
+
+    def test_queryset_or_only_one_with_precache(self):
+        tournament_1 = Tournament.objects.get(pk=1)
+        tournament_2 = Tournament.objects.get(pk=2)
+        # 2 queries here as pool id 3 has tournament 2, which is not cached
+        with self.assertNumQueries(2):
+            pools = tournament_1.pool_set.all() | Pool.objects.filter(pk=3)
+            related_objects = set(pool.tournament for pool in pools)
+            self.assertEqual(related_objects, set((tournament_1, tournament_2)))
+        # and the other direction
+        with self.assertNumQueries(2):
+            pools = Pool.objects.filter(pk=3) | tournament_1.pool_set.all()
+            related_objects = set(pool.tournament for pool in pools)
+            self.assertEqual(related_objects, set((tournament_1, tournament_2)))
+
+    def test_queryset_and(self):
+        tournament = Tournament.objects.get(pk=1)
+        organiser = Organiser.objects.get(pk=1)
+        with self.assertNumQueries(1):
+            pools = tournament.pool_set.all() & organiser.pool_set.all()
+            first = pools.filter(pk=1)[0]
+            self.assertIs(first.tournament, tournament)
+            self.assertIs(first.organiser, organiser)
+
+    def test_one_to_one(self):
+        with self.assertNumQueries(2):
+            style = PoolStyle.objects.get(pk=1)
+            pool = style.pool
+            self.assertIs(style, pool.poolstyle)
+
+    def test_one_to_one_select_related(self):
+        with self.assertNumQueries(1):
+            style = PoolStyle.objects.select_related('pool').get(pk=1)
+            pool = style.pool
+            self.assertIs(style, pool.poolstyle)
+
+    def test_one_to_one_multi_select_related(self):
+        with self.assertNumQueries(1):
+            poolstyles = list(PoolStyle.objects.select_related('pool').order_by('pk'))
+            self.assertIs(poolstyles[0], poolstyles[0].pool.poolstyle)
+            self.assertIs(poolstyles[1], poolstyles[1].pool.poolstyle)
+
+    def test_one_to_one_prefetch_related(self):
+        with self.assertNumQueries(2):
+            style = PoolStyle.objects.prefetch_related('pool').get(pk=1)
+            pool = style.pool
+            self.assertIs(style, pool.poolstyle)
+
+    def test_one_to_one_multi_prefetch_related(self):
+        with self.assertNumQueries(2):
+            poolstyles = list(PoolStyle.objects.prefetch_related('pool').order_by('pk'))
+            self.assertIs(poolstyles[0], poolstyles[0].pool.poolstyle)
+            self.assertIs(poolstyles[1], poolstyles[1].pool.poolstyle)
+
+    def test_reverse_one_to_one(self):
+        with self.assertNumQueries(2):
+            pool = Pool.objects.get(pk=2)
+            style = pool.poolstyle
+            self.assertIs(pool, style.pool)
+
+    def test_reverse_one_to_one_select_related(self):
+        with self.assertNumQueries(1):
+            pool = Pool.objects.select_related('poolstyle').get(pk=2)
+            style = pool.poolstyle
+            self.assertIs(pool, style.pool)
+
+    def test_reverse_one_to_one_prefetch_related(self):
+        with self.assertNumQueries(2):
+            pool = Pool.objects.prefetch_related('poolstyle').get(pk=2)
+            style = pool.poolstyle
+            self.assertIs(pool, style.pool)
+
+    def test_reverse_one_to_one_multi_select_related(self):
+        with self.assertNumQueries(1):
+            pools = list(Pool.objects.select_related('poolstyle').order_by('pk'))
+            self.assertIs(pools[1], pools[1].poolstyle.pool)
+            self.assertIs(pools[2], pools[2].poolstyle.pool)
+
+    def test_reverse_one_to_one_multi_prefetch_related(self):
+        with self.assertNumQueries(2):
+            pools = list(Pool.objects.prefetch_related('poolstyle').order_by('pk'))
+            self.assertIs(pools[1], pools[1].poolstyle.pool)
+            self.assertIs(pools[2], pools[2].poolstyle.pool)