Make AUTOLOAD_TRANSLATIONS False by default

hvad/settings.py

@@ -17,7 +17,7 @@
     'LANGUAGES': djsettings.LANGUAGES,
     'FALLBACK_LANGUAGES': None,     # dynamic default
     'TABLE_NAME_FORMAT': '%s_translation',
-    'AUTOLOAD_TRANSLATIONS': True,
+    'AUTOLOAD_TRANSLATIONS': False,
     'USE_DEFAULT_QUERYSET': False,
 }
 

hvad/tests/query.py

@@ -422,6 +422,19 @@ def test_in_bulk(self):
     def test_untranslated_in_bulk(self):
         pk1 = self.normal_id[1]
         with translation.override('ja'):
+            with self.assertNumQueries(1):
+                result = Normal.objects.untranslated().in_bulk([pk1])
+                self.assertCountEqual((pk1,), result)
+            with self.assertNumQueries(0):
+                self.assertEqual(result[pk1].shared_field, NORMAL[1].shared_field)
+            with self.assertNumQueries(0):
+                self.assertRaises(AttributeError, getattr, result[pk1], 'translated_field')
+            with self.assertNumQueries(0):
+                self.assertIs(result[pk1].language_code, None)
+
+    def test_untranslated_in_bulk_autoload(self):
+        pk1 = self.normal_id[1]
+        with self.settings(HVAD={'AUTOLOAD_TRANSLATIONS': True}), translation.override('ja'):
             with self.assertNumQueries(1):
                 result = Normal.objects.untranslated().in_bulk([pk1])
                 self.assertCountEqual((pk1,), result)
@@ -532,29 +545,29 @@ def test_simple(self):
         self.assertEqual(ja.shared_field, NORMAL[1].shared_field)
         self.assertEqual(ja.translated_field, NORMAL[1].translated_field['ja'])
 
-    def test_cached_autoload(self):
-        # get the english instance
+    def test_cached_no_autoload(self):
         en = Normal.objects.untranslated().prefetch_related('translations').get()
-        with self.assertNumQueries(0):
-            ja_trans = en.translations.get_language('ja')
-
-        # get the japanese *combined*
         ja = Normal.objects.language('ja').get(pk=en.pk)
 
         self.assertEqual(en.shared_field, NORMAL[1].shared_field)
-        self.assertEqual(en.translated_field, NORMAL[1].translated_field['en'])
-        self.assertRaises(AttributeError, getattr, ja_trans, 'shared_field')
-        self.assertEqual(ja_trans.translated_field, NORMAL[1].translated_field['ja'])
+        self.assertRaises(AttributeError, getattr, en, 'translated_field') # no autoload => error
         self.assertEqual(ja.shared_field, NORMAL[1].shared_field)
         self.assertEqual(ja.translated_field, NORMAL[1].translated_field['ja'])
 
-    def test_cached_no_autoload(self):
-        with self.settings(HVAD={'AUTOLOAD_TRANSLATIONS': False}):
+    def test_cached_autoload(self):
+        with self.settings(HVAD={'AUTOLOAD_TRANSLATIONS': True}):
+            # get the english instance
             en = Normal.objects.untranslated().prefetch_related('translations').get()
+            with self.assertNumQueries(0):
+                ja_trans = en.translations.get_language('ja')
+
+            # get the japanese *combined*
             ja = Normal.objects.language('ja').get(pk=en.pk)
 
             self.assertEqual(en.shared_field, NORMAL[1].shared_field)
-            self.assertRaises(AttributeError, getattr, en, 'translated_field') # no autoload => error
+            self.assertEqual(en.translated_field, NORMAL[1].translated_field['en'])
+            self.assertRaises(AttributeError, getattr, ja_trans, 'shared_field')
+            self.assertEqual(ja_trans.translated_field, NORMAL[1].translated_field['ja'])
             self.assertEqual(ja.shared_field, NORMAL[1].shared_field)
             self.assertEqual(ja.translated_field, NORMAL[1].translated_field['ja'])
 

hvad/tests/related.py

@@ -67,13 +67,19 @@ def test_relation(self):
         en = Normal.objects.language('en').get(pk=self.normal_id[1])
         ja = Normal.objects.language('ja').get(pk=self.normal_id[1])
 
-        with translation.override('en'):
+        related = Standard.objects.get(pk=self.standard_id[1])
+        self.assertEqual(related.normal.pk, en.pk)
+        self.assertEqual(related.normal.shared_field, en.shared_field)
+        self.assertRaises(AttributeError, getattr, related.normal, 'translated_field')
+        self.assertTrue(related in en.standards.all())
+
+        with self.settings(HVAD={'AUTOLOAD_TRANSLATIONS': True}), translation.override('en'):
             related = Standard.objects.get(pk=self.standard_id[1])
             self.assertEqual(related.normal.pk, en.pk)
             self.assertEqual(related.normal.shared_field, en.shared_field)
             self.assertEqual(related.normal.translated_field, en.translated_field)
             self.assertTrue(related in en.standards.all())
-        with translation.override('ja'):
+        with self.settings(HVAD={'AUTOLOAD_TRANSLATIONS': True}), translation.override('ja'):
             related = Standard.objects.get(pk=self.standard_id[1])
             self.assertEqual(related.normal.pk, ja.pk)
             self.assertEqual(related.normal.shared_field, ja.shared_field)
@@ -88,16 +94,16 @@ def test_num_queries(self):
                 self.assertEqual(related.normal.pk, en.pk)
             with self.assertNumQueries(0):
                 self.assertEqual(related.normal.shared_field, en.shared_field)
-            with self.assertNumQueries(1):
-                self.assertEqual(related.normal.translated_field, en.translated_field)
+            with self.assertNumQueries(0):
+                self.assertRaises(AttributeError, getattr, related.normal, 'translated_field')
 
     def test_lookup_by_pk(self):
         en = Normal.objects.language('en').get(pk=self.normal_id[1])
         by_pk = Standard.objects.get(normal__pk=en.pk)
         with translation.override('en'):
             self.assertEqual(by_pk.normal.pk, en.pk)
             self.assertEqual(by_pk.normal.shared_field, en.shared_field)
-            self.assertEqual(by_pk.normal.translated_field, en.translated_field)
+            self.assertRaises(AttributeError, getattr, by_pk.normal, 'translated_field')
             self.assertTrue(by_pk in en.standards.all())
 
     def test_lookup_by_shared_field(self):
@@ -106,7 +112,7 @@ def test_lookup_by_shared_field(self):
         with translation.override('en'):
             self.assertEqual(by_shared_field.normal.pk, en.pk)
             self.assertEqual(by_shared_field.normal.shared_field, en.shared_field)
-            self.assertEqual(by_shared_field.normal.translated_field, en.translated_field)
+            self.assertRaises(AttributeError, getattr, by_shared_field.normal, 'translated_field')
             self.assertTrue(by_shared_field in en.standards.all())
 
     def test_lookup_by_translated_field(self):
@@ -118,7 +124,7 @@ def test_lookup_by_translated_field(self):
             )
             self.assertEqual(by_translated_field.normal.pk, en.pk)
             self.assertEqual(by_translated_field.normal.shared_field, en.shared_field)
-            self.assertEqual(by_translated_field.normal.translated_field, en.translated_field)
+            self.assertRaises(AttributeError, getattr, by_translated_field.normal, 'translated_field')
             self.assertTrue(by_translated_field in en.standards.all())
 
     def test_lookup_by_translated_field_requires_translation_aware_manager(self):
@@ -140,7 +146,7 @@ def test_lookup_by_translated_field_using_q_objects(self):
             by_translated_field = translation_aware_manager.get(q)
             self.assertEqual(by_translated_field.normal.pk, en.pk)
             self.assertEqual(by_translated_field.normal.shared_field, en.shared_field)
-            self.assertEqual(by_translated_field.normal.translated_field, en.translated_field)
+            self.assertRaises(AttributeError, getattr, by_translated_field.normal, 'translated_field')
             self.assertTrue(by_translated_field in en.standards.all())
 
     def test_filter_by_shared_field(self):
@@ -153,9 +159,6 @@ def test_filter_by_shared_field(self):
             shared_fields = [obj.normal.shared_field for obj in by_shared_field]
             expected_fields = [en.shared_field]
             self.assertEqual(shared_fields, expected_fields)
-            translated_fields = [obj.normal.translated_field for obj in by_shared_field]
-            expected_fields = [en.translated_field]
-            self.assertEqual(translated_fields, expected_fields)
             for obj in by_shared_field:
                 self.assertTrue(obj in en.standards.all())
 
@@ -190,9 +193,6 @@ def test_filter_by_translated_field(self):
             shared_fields = [obj.normal.shared_field for obj in by_translated_field]
             expected_fields = [en.shared_field]
             self.assertEqual(shared_fields, expected_fields)
-            translated_fields = [obj.normal.translated_field for obj in by_translated_field]
-            expected_fields = [en.translated_field]
-            self.assertEqual(translated_fields, expected_fields)
             for obj in by_translated_field:
                 self.assertTrue(obj in en.standards.all())
 
@@ -214,9 +214,6 @@ def test_filter_by_translated_field_using_q_objects(self):
             shared_fields = [obj.normal.shared_field for obj in by_translated_field]
             expected_fields = [en.shared_field]
             self.assertEqual(shared_fields, expected_fields)
-            translated_fields = [obj.normal.translated_field for obj in by_translated_field]
-            expected_fields = [en.translated_field]
-            self.assertEqual(translated_fields, expected_fields)
             for obj in by_translated_field:
                 self.assertTrue(obj in en.standards.all())