diff options
Diffstat (limited to 'parts/django/tests/regressiontests/fixtures_regress')
18 files changed, 1096 insertions, 0 deletions
diff --git a/parts/django/tests/regressiontests/fixtures_regress/__init__.py b/parts/django/tests/regressiontests/fixtures_regress/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/__init__.py diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/absolute.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/absolute.json new file mode 100644 index 0000000..37ed3f6 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/absolute.json @@ -0,0 +1,9 @@ +[ + { + "pk": "1", + "model": "fixtures_regress.absolute", + "fields": { + "name": "Load Absolute Path Test" + } + } +]
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/animal.xml b/parts/django/tests/regressiontests/fixtures_regress/fixtures/animal.xml new file mode 100644 index 0000000..0383c60 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/animal.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="utf-8"?> +<django-objects version="1.0"> + <object pk="10" model="fixtures_regress.animal"> + <field type="CharField" name="name">Emu</field> + <field type="CharField" name="latin_name">Dromaius novaehollandiae</field> + <field type="IntegerField" name="count">42</field> + <field type="FloatField" name="weight">1.2</field> + </object> +</django-objects>
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/bad_fixture1.unkn b/parts/django/tests/regressiontests/fixtures_regress/fixtures/bad_fixture1.unkn new file mode 100644 index 0000000..a8b0a0c --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/bad_fixture1.unkn @@ -0,0 +1 @@ +This data shouldn't load, as it's of an unknown file format.
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/bad_fixture2.xml b/parts/django/tests/regressiontests/fixtures_regress/fixtures/bad_fixture2.xml new file mode 100644 index 0000000..87b809f --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/bad_fixture2.xml @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="utf-8"?> +<django-objcts version="1.0"> + <objct pk="2" model="fixtures.article"> + <field type="CharField" name="headline">Poker on TV is great!</field> + <field type="DateTimeField" name="pub_date">2006-06-16 11:00:00</field> + </objct> +</django-objcts>
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/big-fixture.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/big-fixture.json new file mode 100644 index 0000000..e655fbb --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/big-fixture.json @@ -0,0 +1,83 @@ +[ + { + "pk": 6, + "model": "fixtures_regress.channel", + "fields": { + "name": "Business" + } + }, + + { + "pk": 1, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 1", + "channels": [6] + } + }, + { + "pk": 2, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 2", + "channels": [6] + } + }, + { + "pk": 3, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 3", + "channels": [6] + } + }, + { + "pk": 4, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 4", + "channels": [6] + } + }, + + { + "pk": 5, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 5", + "channels": [6] + } + }, + { + "pk": 6, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 6", + "channels": [6] + } + }, + { + "pk": 7, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 7", + "channels": [6] + } + }, + { + "pk": 8, + "model": "fixtures_regress.article", + "fields": { + "title": "Article Title 8", + "channels": [6] + } + }, + { + "pk": 9, + "model": "fixtures_regress.article", + "fields": { + "title": "Yet Another Article", + "channels": [6] + } + } +]
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/empty.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/empty.json new file mode 100644 index 0000000..0637a08 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/empty.json @@ -0,0 +1 @@ +[]
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/forward_ref_lookup.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/forward_ref_lookup.json new file mode 100644 index 0000000..fe50c65 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/forward_ref_lookup.json @@ -0,0 +1,32 @@ +[ + { + "pk": "4", + "model": "fixtures_regress.person", + "fields": { + "name": "Neal Stephenson" + } + }, + { + "pk": "2", + "model": "fixtures_regress.store", + "fields": { + "name": "Amazon" + } + }, + { + "pk": "3", + "model": "fixtures_regress.store", + "fields": { + "name": "Borders" + } + }, + { + "pk": 1, + "model": "fixtures_regress.book", + "fields": { + "name": "Cryptonomicon", + "author": ["Neal Stephenson"], + "stores": [["Amazon"], ["Borders"]] + } + } +]
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/model-inheritance.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/model-inheritance.json new file mode 100644 index 0000000..00c482b --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/model-inheritance.json @@ -0,0 +1,4 @@ +[ + {"pk": 1, "model": "fixtures_regress.parent", "fields": {"name": "fred"}}, + {"pk": 1, "model": "fixtures_regress.child", "fields": {"data": "apple"}} +] diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/nk-inheritance.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/nk-inheritance.json new file mode 100644 index 0000000..08e5d4f --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/nk-inheritance.json @@ -0,0 +1,18 @@ +[ + { + "pk": 1, + "model": "fixtures_regress.nkchild", + "fields": { + "data": "apple" + } + }, + { + "pk": 1, + "model": "fixtures_regress.reftonkchild", + "fields": { + "text": "my text", + "nk_fk" : ["apple"], + "nk_m2m": [["apple"]] + } + } +] diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/nk-inheritance2.xml b/parts/django/tests/regressiontests/fixtures_regress/fixtures/nk-inheritance2.xml new file mode 100644 index 0000000..7eb17a6 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/nk-inheritance2.xml @@ -0,0 +1,23 @@ +<?xml version="1.0" encoding="utf-8"?> +<django-objects version="1.0"> + <object pk="2" model="fixtures_regress.parent"> + <field type="CharField" name="name">james</field> + </object> + <object pk="2" model="fixtures_regress.nkchild"> + <field type="CharField" name="data">banana</field> + </object> + <object pk="2" model="fixtures_regress.reftonkchild"> + <field type="CharField" name="text">other text</field> + <field to="fixtures_regress.nkchild" name="nk_fk" rel="ManyToOneRel"> + <natural>apple</natural> + </field> + <field to="fixtures_regress.nkchild" name="nk_m2m" rel="ManyToManyRel"> + <object> + <natural>banana</natural> + </object> + <object> + <natural>apple</natural> + </object> + </field> + </object> +</django-objects>
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/non_natural_1.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/non_natural_1.json new file mode 100644 index 0000000..4bce792 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/non_natural_1.json @@ -0,0 +1,25 @@ +[ + { + "pk": 12, + "model": "fixtures_regress.person", + "fields": { + "name": "Greg Egan" + } + }, + { + "pk": 11, + "model": "fixtures_regress.store", + "fields": { + "name": "Angus and Robertson" + } + }, + { + "pk": 10, + "model": "fixtures_regress.book", + "fields": { + "name": "Permutation City", + "author": 12, + "stores": [11] + } + } +]
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/non_natural_2.xml b/parts/django/tests/regressiontests/fixtures_regress/fixtures/non_natural_2.xml new file mode 100644 index 0000000..280ad37 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/non_natural_2.xml @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="utf-8"?> +<django-objects version="1.0"> + <object pk="22" model="fixtures_regress.person"> + <field type="CharField" name="name">Orson Scott Card</field> + </object> + <object pk="21" model="fixtures_regress.store"> + <field type="CharField" name="name">Collins Bookstore</field> + </object> + <object pk="20" model="fixtures_regress.book"> + <field type="CharField" name="name">Ender's Game</field> + <field to="fixtures_regress.person" name="author" rel="ManyToOneRel">22</field> + <field to="fixtures_regress.store" name="stores" rel="ManyToManyRel"> + <object pk="21"/> + </field> + </object> +</django-objects>
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/pretty.xml b/parts/django/tests/regressiontests/fixtures_regress/fixtures/pretty.xml new file mode 100644 index 0000000..68e5710 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/pretty.xml @@ -0,0 +1,11 @@ +<?xml version="1.0" encoding="utf-8"?> +<django-objects version="1.0"> + <object pk="1" model="fixtures_regress.stuff"> + <field type="CharField" name="name"> + <None/> + </field> + <field to="auth.user" name="owner" rel="ManyToOneRel"> + <None/> + </field> + </object> +</django-objects>
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/sequence.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/sequence.json new file mode 100644 index 0000000..60bfcdd --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/sequence.json @@ -0,0 +1,12 @@ +[ + { + "pk": "1", + "model": "fixtures_regress.animal", + "fields": { + "name": "Lion", + "latin_name": "Panthera leo", + "count": 3, + "weight": 1.2 + } + } +]
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/fixtures_regress/fixtures/thingy.json b/parts/django/tests/regressiontests/fixtures_regress/fixtures/thingy.json new file mode 100644 index 0000000..1693177 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/fixtures/thingy.json @@ -0,0 +1,9 @@ +[ + { + "pk": "1", + "model": "fixtures_regress.thingy", + "fields": { + "name": "Whatchamacallit" + } + } +] diff --git a/parts/django/tests/regressiontests/fixtures_regress/models.py b/parts/django/tests/regressiontests/fixtures_regress/models.py new file mode 100644 index 0000000..7465fd2 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/models.py @@ -0,0 +1,225 @@ +from django.db import models, DEFAULT_DB_ALIAS +from django.contrib.auth.models import User +from django.conf import settings + + +class Animal(models.Model): + name = models.CharField(max_length=150) + latin_name = models.CharField(max_length=150) + count = models.IntegerField() + weight = models.FloatField() + + # use a non-default name for the default manager + specimens = models.Manager() + + def __unicode__(self): + return self.name + + +class Plant(models.Model): + name = models.CharField(max_length=150) + + class Meta: + # For testing when upper case letter in app name; regression for #4057 + db_table = "Fixtures_regress_plant" + +class Stuff(models.Model): + name = models.CharField(max_length=20, null=True) + owner = models.ForeignKey(User, null=True) + + def __unicode__(self): + return unicode(self.name) + u' is owned by ' + unicode(self.owner) + + +class Absolute(models.Model): + name = models.CharField(max_length=40) + + load_count = 0 + + def __init__(self, *args, **kwargs): + super(Absolute, self).__init__(*args, **kwargs) + Absolute.load_count += 1 + + +class Parent(models.Model): + name = models.CharField(max_length=10) + + class Meta: + ordering = ('id',) + + +class Child(Parent): + data = models.CharField(max_length=10) + + +# Models to regression test #7572 +class Channel(models.Model): + name = models.CharField(max_length=255) + + +class Article(models.Model): + title = models.CharField(max_length=255) + channels = models.ManyToManyField(Channel) + + class Meta: + ordering = ('id',) + + +# Models to regression test #11428 +class Widget(models.Model): + name = models.CharField(max_length=255) + + class Meta: + ordering = ('name',) + + def __unicode__(self): + return self.name + + +class WidgetProxy(Widget): + class Meta: + proxy = True + + +# Check for forward references in FKs and M2Ms with natural keys +class TestManager(models.Manager): + def get_by_natural_key(self, key): + return self.get(name=key) + + +class Store(models.Model): + objects = TestManager() + name = models.CharField(max_length=255) + + class Meta: + ordering = ('name',) + + def __unicode__(self): + return self.name + + def natural_key(self): + return (self.name,) + + +class Person(models.Model): + objects = TestManager() + name = models.CharField(max_length=255) + + class Meta: + ordering = ('name',) + + def __unicode__(self): + return self.name + + # Person doesn't actually have a dependency on store, but we need to define + # one to test the behaviour of the dependency resolution algorithm. + def natural_key(self): + return (self.name,) + natural_key.dependencies = ['fixtures_regress.store'] + + +class Book(models.Model): + name = models.CharField(max_length=255) + author = models.ForeignKey(Person) + stores = models.ManyToManyField(Store) + + class Meta: + ordering = ('name',) + + def __unicode__(self): + return u'%s by %s (available at %s)' % ( + self.name, + self.author.name, + ', '.join(s.name for s in self.stores.all()) + ) + + +class NKManager(models.Manager): + def get_by_natural_key(self, data): + return self.get(data=data) + + +class NKChild(Parent): + data = models.CharField(max_length=10, unique=True) + objects = NKManager() + + def natural_key(self): + return self.data + + def __unicode__(self): + return u'NKChild %s:%s' % (self.name, self.data) + + +class RefToNKChild(models.Model): + text = models.CharField(max_length=10) + nk_fk = models.ForeignKey(NKChild, related_name='ref_fks') + nk_m2m = models.ManyToManyField(NKChild, related_name='ref_m2ms') + + def __unicode__(self): + return u'%s: Reference to %s [%s]' % ( + self.text, + self.nk_fk, + ', '.join(str(o) for o in self.nk_m2m.all()) + ) + + +# ome models with pathological circular dependencies +class Circle1(models.Model): + name = models.CharField(max_length=255) + + def natural_key(self): + return self.name + natural_key.dependencies = ['fixtures_regress.circle2'] + + +class Circle2(models.Model): + name = models.CharField(max_length=255) + + def natural_key(self): + return self.name + natural_key.dependencies = ['fixtures_regress.circle1'] + + +class Circle3(models.Model): + name = models.CharField(max_length=255) + + def natural_key(self): + return self.name + natural_key.dependencies = ['fixtures_regress.circle3'] + + +class Circle4(models.Model): + name = models.CharField(max_length=255) + + def natural_key(self): + return self.name + natural_key.dependencies = ['fixtures_regress.circle5'] + + +class Circle5(models.Model): + name = models.CharField(max_length=255) + + def natural_key(self): + return self.name + natural_key.dependencies = ['fixtures_regress.circle6'] + + +class Circle6(models.Model): + name = models.CharField(max_length=255) + + def natural_key(self): + return self.name + natural_key.dependencies = ['fixtures_regress.circle4'] + + +class ExternalDependency(models.Model): + name = models.CharField(max_length=255) + + def natural_key(self): + return self.name + natural_key.dependencies = ['fixtures_regress.book'] + + +# Model for regression test of #11101 +class Thingy(models.Model): + name = models.CharField(max_length=255) diff --git a/parts/django/tests/regressiontests/fixtures_regress/tests.py b/parts/django/tests/regressiontests/fixtures_regress/tests.py new file mode 100644 index 0000000..57ee7c0 --- /dev/null +++ b/parts/django/tests/regressiontests/fixtures_regress/tests.py @@ -0,0 +1,611 @@ +# -*- coding: utf-8 -*- +# Unittests for fixtures. +import os +import sys +try: + from cStringIO import StringIO +except ImportError: + from StringIO import StringIO + +from django.conf import settings +from django.core import management +from django.core.management.commands.dumpdata import sort_dependencies +from django.core.management.base import CommandError +from django.db.models import signals +from django.db import DEFAULT_DB_ALIAS, transaction +from django.test import TestCase, TransactionTestCase + +from models import Animal, Stuff +from models import Absolute, Parent, Child +from models import Article, Widget +from models import Store, Person, Book +from models import NKChild, RefToNKChild +from models import Circle1, Circle2, Circle3 +from models import ExternalDependency +from models import Thingy + + +pre_save_checks = [] +def animal_pre_save_check(signal, sender, instance, **kwargs): + "A signal that is used to check the type of data loaded from fixtures" + pre_save_checks.append( + ( + 'Count = %s (%s)' % (instance.count, type(instance.count)), + 'Weight = %s (%s)' % (instance.weight, type(instance.weight)), + ) + ) + + +class TestFixtures(TestCase): + def test_duplicate_pk(self): + """ + This is a regression test for ticket #3790. + """ + # Load a fixture that uses PK=1 + management.call_command( + 'loaddata', + 'sequence', + verbosity=0, + commit=False + ) + + # Create a new animal. Without a sequence reset, this new object + # will take a PK of 1 (on Postgres), and the save will fail. + + animal = Animal( + name='Platypus', + latin_name='Ornithorhynchus anatinus', + count=2, + weight=2.2 + ) + animal.save() + self.assertTrue(animal.id > 1) + + if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.oracle': + def test_pretty_print_xml(self): + """ + Regression test for ticket #4558 -- pretty printing of XML fixtures + doesn't affect parsing of None values. + """ + # Load a pretty-printed XML fixture with Nulls. + management.call_command( + 'loaddata', + 'pretty.xml', + verbosity=0, + commit=False + ) + self.assertEqual(Stuff.objects.all()[0].name, None) + self.assertEqual(Stuff.objects.all()[0].owner, None) + + if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] == 'django.db.backends.oracle': + def test_pretty_print_xml_empty_strings(self): + """ + Regression test for ticket #4558 -- pretty printing of XML fixtures + doesn't affect parsing of None values. + """ + # Load a pretty-printed XML fixture with Nulls. + management.call_command( + 'loaddata', + 'pretty.xml', + verbosity=0, + commit=False + ) + self.assertEqual(Stuff.objects.all()[0].name, u'') + self.assertEqual(Stuff.objects.all()[0].owner, None) + + def test_absolute_path(self): + """ + Regression test for ticket #6436 -- + os.path.join will throw away the initial parts of a path if it + encounters an absolute path. + This means that if a fixture is specified as an absolute path, + we need to make sure we don't discover the absolute path in every + fixture directory. + """ + load_absolute_path = os.path.join( + os.path.dirname(__file__), + 'fixtures', + 'absolute.json' + ) + management.call_command( + 'loaddata', + load_absolute_path, + verbosity=0, + commit=False + ) + self.assertEqual(Absolute.load_count, 1) + + + def test_unknown_format(self): + """ + Test for ticket #4371 -- Loading data of an unknown format should fail + Validate that error conditions are caught correctly + """ + stderr = StringIO() + management.call_command( + 'loaddata', + 'bad_fixture1.unkn', + verbosity=0, + commit=False, + stderr=stderr, + ) + self.assertEqual( + stderr.getvalue(), + "Problem installing fixture 'bad_fixture1': unkn is not a known serialization format.\n" + ) + + def test_invalid_data(self): + """ + Test for ticket #4371 -- Loading a fixture file with invalid data + using explicit filename. + Validate that error conditions are caught correctly + """ + stderr = StringIO() + management.call_command( + 'loaddata', + 'bad_fixture2.xml', + verbosity=0, + commit=False, + stderr=stderr, + ) + self.assertEqual( + stderr.getvalue(), + "No fixture data found for 'bad_fixture2'. (File format may be invalid.)\n" + ) + + def test_invalid_data_no_ext(self): + """ + Test for ticket #4371 -- Loading a fixture file with invalid data + without file extension. + Validate that error conditions are caught correctly + """ + stderr = StringIO() + management.call_command( + 'loaddata', + 'bad_fixture2', + verbosity=0, + commit=False, + stderr=stderr, + ) + self.assertEqual( + stderr.getvalue(), + "No fixture data found for 'bad_fixture2'. (File format may be invalid.)\n" + ) + + def test_empty(self): + """ + Test for ticket #4371 -- Loading a fixture file with no data returns an error. + Validate that error conditions are caught correctly + """ + stderr = StringIO() + management.call_command( + 'loaddata', + 'empty', + verbosity=0, + commit=False, + stderr=stderr, + ) + self.assertEqual( + stderr.getvalue(), + "No fixture data found for 'empty'. (File format may be invalid.)\n" + ) + + def test_abort_loaddata_on_error(self): + """ + Test for ticket #4371 -- If any of the fixtures contain an error, + loading is aborted. + Validate that error conditions are caught correctly + """ + stderr = StringIO() + management.call_command( + 'loaddata', + 'empty', + verbosity=0, + commit=False, + stderr=stderr, + ) + self.assertEqual( + stderr.getvalue(), + "No fixture data found for 'empty'. (File format may be invalid.)\n" + ) + + def test_error_message(self): + """ + (Regression for #9011 - error message is correct) + """ + stderr = StringIO() + management.call_command( + 'loaddata', + 'bad_fixture2', + 'animal', + verbosity=0, + commit=False, + stderr=stderr, + ) + self.assertEqual( + stderr.getvalue(), + "No fixture data found for 'bad_fixture2'. (File format may be invalid.)\n" + ) + + def test_pg_sequence_resetting_checks(self): + """ + Test for ticket #7565 -- PostgreSQL sequence resetting checks shouldn't + ascend to parent models when inheritance is used + (since they are treated individually). + """ + management.call_command( + 'loaddata', + 'model-inheritance.json', + verbosity=0, + commit=False + ) + self.assertEqual(Parent.objects.all()[0].id, 1) + self.assertEqual(Child.objects.all()[0].id, 1) + + def test_close_connection_after_loaddata(self): + """ + Test for ticket #7572 -- MySQL has a problem if the same connection is + used to create tables, load data, and then query over that data. + To compensate, we close the connection after running loaddata. + This ensures that a new connection is opened when test queries are + issued. + """ + management.call_command( + 'loaddata', + 'big-fixture.json', + verbosity=0, + commit=False + ) + articles = Article.objects.exclude(id=9) + self.assertEqual( + list(articles.values_list('id', flat=True)), + [1, 2, 3, 4, 5, 6, 7, 8] + ) + # Just for good measure, run the same query again. + # Under the influence of ticket #7572, this will + # give a different result to the previous call. + self.assertEqual( + list(articles.values_list('id', flat=True)), + [1, 2, 3, 4, 5, 6, 7, 8] + ) + + def test_field_value_coerce(self): + """ + Test for tickets #8298, #9942 - Field values should be coerced into the + correct type by the deserializer, not as part of the database write. + """ + global pre_save_checks + pre_save_checks = [] + signals.pre_save.connect(animal_pre_save_check) + management.call_command( + 'loaddata', + 'animal.xml', + verbosity=0, + commit=False, + ) + self.assertEqual( + pre_save_checks, + [ + ("Count = 42 (<type 'int'>)", "Weight = 1.2 (<type 'float'>)") + ] + ) + signals.pre_save.disconnect(animal_pre_save_check) + + def test_dumpdata_uses_default_manager(self): + """ + Regression for #11286 + Ensure that dumpdata honors the default manager + Dump the current contents of the database as a JSON fixture + """ + management.call_command( + 'loaddata', + 'animal.xml', + verbosity=0, + commit=False, + ) + management.call_command( + 'loaddata', + 'sequence.json', + verbosity=0, + commit=False, + ) + animal = Animal( + name='Platypus', + latin_name='Ornithorhynchus anatinus', + count=2, + weight=2.2 + ) + animal.save() + + stdout = StringIO() + management.call_command( + 'dumpdata', + 'fixtures_regress.animal', + format='json', + stdout=stdout + ) + + # Output order isn't guaranteed, so check for parts + data = stdout.getvalue() + lion_json = '{"pk": 1, "model": "fixtures_regress.animal", "fields": {"count": 3, "weight": 1.2, "name": "Lion", "latin_name": "Panthera leo"}}' + emu_json = '{"pk": 10, "model": "fixtures_regress.animal", "fields": {"count": 42, "weight": 1.2, "name": "Emu", "latin_name": "Dromaius novaehollandiae"}}' + platypus_json = '{"pk": %d, "model": "fixtures_regress.animal", "fields": {"count": 2, "weight": 2.2000000000000002, "name": "Platypus", "latin_name": "Ornithorhynchus anatinus"}}' + platypus_json = platypus_json % animal.pk + + self.assertEqual(len(data), len('[%s]' % ', '.join([lion_json, emu_json, platypus_json]))) + self.assertTrue(lion_json in data) + self.assertTrue(emu_json in data) + self.assertTrue(platypus_json in data) + + def test_proxy_model_included(self): + """ + Regression for #11428 - Proxy models aren't included when you dumpdata + """ + stdout = StringIO() + # Create an instance of the concrete class + Widget(name='grommet').save() + management.call_command( + 'dumpdata', + 'fixtures_regress.widget', + 'fixtures_regress.widgetproxy', + format='json', + stdout=stdout + ) + self.assertEqual( + stdout.getvalue(), + """[{"pk": 1, "model": "fixtures_regress.widget", "fields": {"name": "grommet"}}]""" + ) + + +class NaturalKeyFixtureTests(TestCase): + def assertRaisesMessage(self, exc, msg, func, *args, **kwargs): + try: + func(*args, **kwargs) + except Exception, e: + self.assertEqual(msg, str(e)) + self.assertTrue(isinstance(e, exc), "Expected %s, got %s" % (exc, type(e))) + + def test_nk_deserialize(self): + """ + Test for ticket #13030 - Python based parser version + natural keys deserialize with fk to inheriting model + """ + management.call_command( + 'loaddata', + 'model-inheritance.json', + verbosity=0, + commit=False + ) + management.call_command( + 'loaddata', + 'nk-inheritance.json', + verbosity=0, + commit=False + ) + self.assertEqual( + NKChild.objects.get(pk=1).data, + 'apple' + ) + + self.assertEqual( + RefToNKChild.objects.get(pk=1).nk_fk.data, + 'apple' + ) + + def test_nk_deserialize_xml(self): + """ + Test for ticket #13030 - XML version + natural keys deserialize with fk to inheriting model + """ + management.call_command( + 'loaddata', + 'model-inheritance.json', + verbosity=0, + commit=False + ) + management.call_command( + 'loaddata', + 'nk-inheritance.json', + verbosity=0, + commit=False + ) + management.call_command( + 'loaddata', + 'nk-inheritance2.xml', + verbosity=0, + commit=False + ) + self.assertEqual( + NKChild.objects.get(pk=2).data, + 'banana' + ) + self.assertEqual( + RefToNKChild.objects.get(pk=2).nk_fk.data, + 'apple' + ) + + def test_nk_on_serialize(self): + """ + Check that natural key requirements are taken into account + when serializing models + """ + management.call_command( + 'loaddata', + 'forward_ref_lookup.json', + verbosity=0, + commit=False + ) + + stdout = StringIO() + management.call_command( + 'dumpdata', + 'fixtures_regress.book', + 'fixtures_regress.person', + 'fixtures_regress.store', + verbosity=0, + format='json', + use_natural_keys=True, + stdout=stdout, + ) + self.assertEqual( + stdout.getvalue(), + """[{"pk": 2, "model": "fixtures_regress.store", "fields": {"name": "Amazon"}}, {"pk": 3, "model": "fixtures_regress.store", "fields": {"name": "Borders"}}, {"pk": 4, "model": "fixtures_regress.person", "fields": {"name": "Neal Stephenson"}}, {"pk": 1, "model": "fixtures_regress.book", "fields": {"stores": [["Amazon"], ["Borders"]], "name": "Cryptonomicon", "author": ["Neal Stephenson"]}}]""" + ) + + def test_dependency_sorting(self): + """ + Now lets check the dependency sorting explicitly + It doesn't matter what order you mention the models + Store *must* be serialized before then Person, and both + must be serialized before Book. + """ + sorted_deps = sort_dependencies( + [('fixtures_regress', [Book, Person, Store])] + ) + self.assertEqual( + sorted_deps, + [Store, Person, Book] + ) + + def test_dependency_sorting_2(self): + sorted_deps = sort_dependencies( + [('fixtures_regress', [Book, Store, Person])] + ) + self.assertEqual( + sorted_deps, + [Store, Person, Book] + ) + + def test_dependency_sorting_3(self): + sorted_deps = sort_dependencies( + [('fixtures_regress', [Store, Book, Person])] + ) + self.assertEqual( + sorted_deps, + [Store, Person, Book] + ) + + def test_dependency_sorting_4(self): + sorted_deps = sort_dependencies( + [('fixtures_regress', [Store, Person, Book])] + ) + self.assertEqual( + sorted_deps, + [Store, Person, Book] + ) + + def test_dependency_sorting_5(self): + sorted_deps = sort_dependencies( + [('fixtures_regress', [Person, Book, Store])] + ) + self.assertEqual( + sorted_deps, + [Store, Person, Book] + ) + + def test_dependency_sorting_6(self): + sorted_deps = sort_dependencies( + [('fixtures_regress', [Person, Store, Book])] + ) + self.assertEqual( + sorted_deps, + [Store, Person, Book] + ) + + def test_dependency_sorting_dangling(self): + sorted_deps = sort_dependencies( + [('fixtures_regress', [Person, Circle1, Store, Book])] + ) + self.assertEqual( + sorted_deps, + [Circle1, Store, Person, Book] + ) + + def test_dependency_sorting_tight_circular(self): + self.assertRaisesMessage( + CommandError, + """Can't resolve dependencies for fixtures_regress.Circle1, fixtures_regress.Circle2 in serialized app list.""", + sort_dependencies, + [('fixtures_regress', [Person, Circle2, Circle1, Store, Book])], + ) + + def test_dependency_sorting_tight_circular_2(self): + self.assertRaisesMessage( + CommandError, + """Can't resolve dependencies for fixtures_regress.Circle1, fixtures_regress.Circle2 in serialized app list.""", + sort_dependencies, + [('fixtures_regress', [Circle1, Book, Circle2])], + ) + + def test_dependency_self_referential(self): + self.assertRaisesMessage( + CommandError, + """Can't resolve dependencies for fixtures_regress.Circle3 in serialized app list.""", + sort_dependencies, + [('fixtures_regress', [Book, Circle3])], + ) + + def test_dependency_sorting_long(self): + self.assertRaisesMessage( + CommandError, + """Can't resolve dependencies for fixtures_regress.Circle1, fixtures_regress.Circle2, fixtures_regress.Circle3 in serialized app list.""", + sort_dependencies, + [('fixtures_regress', [Person, Circle2, Circle1, Circle3, Store, Book])], + ) + + def test_dependency_sorting_normal(self): + sorted_deps = sort_dependencies( + [('fixtures_regress', [Person, ExternalDependency, Book])] + ) + self.assertEqual( + sorted_deps, + [Person, Book, ExternalDependency] + ) + + def test_normal_pk(self): + """ + Check that normal primary keys still work + on a model with natural key capabilities + """ + management.call_command( + 'loaddata', + 'non_natural_1.json', + verbosity=0, + commit=False + ) + management.call_command( + 'loaddata', + 'forward_ref_lookup.json', + verbosity=0, + commit=False + ) + management.call_command( + 'loaddata', + 'non_natural_2.xml', + verbosity=0, + commit=False + ) + books = Book.objects.all() + self.assertEqual( + books.__repr__(), + """[<Book: Cryptonomicon by Neal Stephenson (available at Amazon, Borders)>, <Book: Ender's Game by Orson Scott Card (available at Collins Bookstore)>, <Book: Permutation City by Greg Egan (available at Angus and Robertson)>]""" + ) + + +class TestTicket11101(TransactionTestCase): + + def ticket_11101(self): + management.call_command( + 'loaddata', + 'thingy.json', + verbosity=0, + commit=False + ) + self.assertEqual(Thingy.objects.count(), 1) + transaction.rollback() + self.assertEqual(Thingy.objects.count(), 0) + + def test_ticket_11101(self): + """Test that fixtures can be rolled back (ticket #11101).""" + ticket_11101 = transaction.commit_manually(self.ticket_11101) + ticket_11101() |