diff options
Diffstat (limited to 'tests/basic/tests.py')
| -rw-r--r-- | tests/basic/tests.py | 693 |
1 files changed, 693 insertions, 0 deletions
diff --git a/tests/basic/tests.py b/tests/basic/tests.py new file mode 100644 index 0000000000..2de87a225f --- /dev/null +++ b/tests/basic/tests.py @@ -0,0 +1,693 @@ +from __future__ import absolute_import, unicode_literals + +from datetime import datetime + +from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned, FieldError +from django.db.models.fields import Field, FieldDoesNotExist +from django.db.models.query import QuerySet, EmptyQuerySet, ValuesListQuerySet +from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature +from django.utils import six +from django.utils.translation import ugettext_lazy + +from .models import Article + + +class ModelTest(TestCase): + + def test_lookup(self): + # No articles are in the system yet. + self.assertQuerysetEqual(Article.objects.all(), []) + + # Create an Article. + a = Article( + id=None, + headline='Area man programs in Python', + pub_date=datetime(2005, 7, 28), + ) + + # Save it into the database. You have to call save() explicitly. + a.save() + + # Now it has an ID. + self.assertTrue(a.id != None) + + # Models have a pk property that is an alias for the primary key + # attribute (by default, the 'id' attribute). + self.assertEqual(a.pk, a.id) + + # Access database columns via Python attributes. + self.assertEqual(a.headline, 'Area man programs in Python') + self.assertEqual(a.pub_date, datetime(2005, 7, 28, 0, 0)) + + # Change values by changing the attributes, then calling save(). + a.headline = 'Area woman programs in Python' + a.save() + + # Article.objects.all() returns all the articles in the database. + self.assertQuerysetEqual(Article.objects.all(), + ['<Article: Area woman programs in Python>']) + + # Django provides a rich database lookup API. + self.assertEqual(Article.objects.get(id__exact=a.id), a) + self.assertEqual(Article.objects.get(headline__startswith='Area woman'), a) + self.assertEqual(Article.objects.get(pub_date__year=2005), a) + self.assertEqual(Article.objects.get(pub_date__year=2005, pub_date__month=7), a) + self.assertEqual(Article.objects.get(pub_date__year=2005, pub_date__month=7, pub_date__day=28), a) + self.assertEqual(Article.objects.get(pub_date__week_day=5), a) + + # The "__exact" lookup type can be omitted, as a shortcut. + self.assertEqual(Article.objects.get(id=a.id), a) + self.assertEqual(Article.objects.get(headline='Area woman programs in Python'), a) + + self.assertQuerysetEqual( + Article.objects.filter(pub_date__year=2005), + ['<Article: Area woman programs in Python>'], + ) + self.assertQuerysetEqual( + Article.objects.filter(pub_date__year=2004), + [], + ) + self.assertQuerysetEqual( + Article.objects.filter(pub_date__year=2005, pub_date__month=7), + ['<Article: Area woman programs in Python>'], + ) + + self.assertQuerysetEqual( + Article.objects.filter(pub_date__week_day=5), + ['<Article: Area woman programs in Python>'], + ) + self.assertQuerysetEqual( + Article.objects.filter(pub_date__week_day=6), + [], + ) + + # Django raises an Article.DoesNotExist exception for get() if the + # parameters don't match any object. + six.assertRaisesRegex(self, + ObjectDoesNotExist, + "Article matching query does not exist. Lookup parameters were " + "{'id__exact': 2000}", + Article.objects.get, + id__exact=2000, + ) + # To avoid dict-ordering related errors check only one lookup + # in single assert. + six.assertRaisesRegex(self, + ObjectDoesNotExist, + ".*'pub_date__year': 2005.*", + Article.objects.get, + pub_date__year=2005, + pub_date__month=8, + ) + six.assertRaisesRegex(self, + ObjectDoesNotExist, + ".*'pub_date__month': 8.*", + Article.objects.get, + pub_date__year=2005, + pub_date__month=8, + ) + + six.assertRaisesRegex(self, + ObjectDoesNotExist, + "Article matching query does not exist. Lookup parameters were " + "{'pub_date__week_day': 6}", + Article.objects.get, + pub_date__week_day=6, + ) + + # Lookup by a primary key is the most common case, so Django + # provides a shortcut for primary-key exact lookups. + # The following is identical to articles.get(id=a.id). + self.assertEqual(Article.objects.get(pk=a.id), a) + + # pk can be used as a shortcut for the primary key name in any query. + self.assertQuerysetEqual(Article.objects.filter(pk__in=[a.id]), + ["<Article: Area woman programs in Python>"]) + + # Model instances of the same type and same ID are considered equal. + a = Article.objects.get(pk=a.id) + b = Article.objects.get(pk=a.id) + self.assertEqual(a, b) + + # Create a very similar object + a = Article( + id=None, + headline='Area man programs in Python', + pub_date=datetime(2005, 7, 28), + ) + a.save() + + self.assertEqual(Article.objects.count(), 2) + + # Django raises an Article.MultipleObjectsReturned exception if the + # lookup matches more than one object + six.assertRaisesRegex(self, + MultipleObjectsReturned, + "get\(\) returned more than one Article -- it returned 2!", + Article.objects.get, + headline__startswith='Area', + ) + + six.assertRaisesRegex(self, + MultipleObjectsReturned, + "get\(\) returned more than one Article -- it returned 2!", + Article.objects.get, + pub_date__year=2005, + ) + + six.assertRaisesRegex(self, + MultipleObjectsReturned, + "get\(\) returned more than one Article -- it returned 2!", + Article.objects.get, + pub_date__year=2005, + pub_date__month=7, + ) + + def test_object_creation(self): + # Create an Article. + a = Article( + id=None, + headline='Area man programs in Python', + pub_date=datetime(2005, 7, 28), + ) + + # Save it into the database. You have to call save() explicitly. + a.save() + + # You can initialize a model instance using positional arguments, + # which should match the field order as defined in the model. + a2 = Article(None, 'Second article', datetime(2005, 7, 29)) + a2.save() + + self.assertNotEqual(a2.id, a.id) + self.assertEqual(a2.headline, 'Second article') + self.assertEqual(a2.pub_date, datetime(2005, 7, 29, 0, 0)) + + # ...or, you can use keyword arguments. + a3 = Article( + id=None, + headline='Third article', + pub_date=datetime(2005, 7, 30), + ) + a3.save() + + self.assertNotEqual(a3.id, a.id) + self.assertNotEqual(a3.id, a2.id) + self.assertEqual(a3.headline, 'Third article') + self.assertEqual(a3.pub_date, datetime(2005, 7, 30, 0, 0)) + + # You can also mix and match position and keyword arguments, but + # be sure not to duplicate field information. + a4 = Article(None, 'Fourth article', pub_date=datetime(2005, 7, 31)) + a4.save() + self.assertEqual(a4.headline, 'Fourth article') + + # Don't use invalid keyword arguments. + six.assertRaisesRegex(self, + TypeError, + "'foo' is an invalid keyword argument for this function", + Article, + id=None, + headline='Invalid', + pub_date=datetime(2005, 7, 31), + foo='bar', + ) + + # You can leave off the value for an AutoField when creating an + # object, because it'll get filled in automatically when you save(). + a5 = Article(headline='Article 6', pub_date=datetime(2005, 7, 31)) + a5.save() + self.assertEqual(a5.headline, 'Article 6') + + # If you leave off a field with "default" set, Django will use + # the default. + a6 = Article(pub_date=datetime(2005, 7, 31)) + a6.save() + self.assertEqual(a6.headline, 'Default headline') + + # For DateTimeFields, Django saves as much precision (in seconds) + # as you give it. + a7 = Article( + headline='Article 7', + pub_date=datetime(2005, 7, 31, 12, 30), + ) + a7.save() + self.assertEqual(Article.objects.get(id__exact=a7.id).pub_date, + datetime(2005, 7, 31, 12, 30)) + + a8 = Article( + headline='Article 8', + pub_date=datetime(2005, 7, 31, 12, 30, 45), + ) + a8.save() + self.assertEqual(Article.objects.get(id__exact=a8.id).pub_date, + datetime(2005, 7, 31, 12, 30, 45)) + + # Saving an object again doesn't create a new object -- it just saves + # the old one. + current_id = a8.id + a8.save() + self.assertEqual(a8.id, current_id) + a8.headline = 'Updated article 8' + a8.save() + self.assertEqual(a8.id, current_id) + + # Check that != and == operators behave as expecte on instances + self.assertTrue(a7 != a8) + self.assertFalse(a7 == a8) + self.assertEqual(a8, Article.objects.get(id__exact=a8.id)) + + self.assertTrue(Article.objects.get(id__exact=a8.id) != Article.objects.get(id__exact=a7.id)) + self.assertFalse(Article.objects.get(id__exact=a8.id) == Article.objects.get(id__exact=a7.id)) + + # You can use 'in' to test for membership... + self.assertTrue(a8 in Article.objects.all()) + + # ... but there will often be more efficient ways if that is all you need: + self.assertTrue(Article.objects.filter(id=a8.id).exists()) + + # datetimes() returns a list of available dates of the given scope for + # the given field. + self.assertQuerysetEqual( + Article.objects.datetimes('pub_date', 'year'), + ["datetime.datetime(2005, 1, 1, 0, 0)"]) + self.assertQuerysetEqual( + Article.objects.datetimes('pub_date', 'month'), + ["datetime.datetime(2005, 7, 1, 0, 0)"]) + self.assertQuerysetEqual( + Article.objects.datetimes('pub_date', 'day'), + ["datetime.datetime(2005, 7, 28, 0, 0)", + "datetime.datetime(2005, 7, 29, 0, 0)", + "datetime.datetime(2005, 7, 30, 0, 0)", + "datetime.datetime(2005, 7, 31, 0, 0)"]) + self.assertQuerysetEqual( + Article.objects.datetimes('pub_date', 'day', order='ASC'), + ["datetime.datetime(2005, 7, 28, 0, 0)", + "datetime.datetime(2005, 7, 29, 0, 0)", + "datetime.datetime(2005, 7, 30, 0, 0)", + "datetime.datetime(2005, 7, 31, 0, 0)"]) + self.assertQuerysetEqual( + Article.objects.datetimes('pub_date', 'day', order='DESC'), + ["datetime.datetime(2005, 7, 31, 0, 0)", + "datetime.datetime(2005, 7, 30, 0, 0)", + "datetime.datetime(2005, 7, 29, 0, 0)", + "datetime.datetime(2005, 7, 28, 0, 0)"]) + + # datetimes() requires valid arguments. + self.assertRaises( + TypeError, + Article.objects.dates, + ) + + six.assertRaisesRegex(self, + FieldDoesNotExist, + "Article has no field named 'invalid_field'", + Article.objects.dates, + "invalid_field", + "year", + ) + + six.assertRaisesRegex(self, + AssertionError, + "'kind' must be one of 'year', 'month' or 'day'.", + Article.objects.dates, + "pub_date", + "bad_kind", + ) + + six.assertRaisesRegex(self, + AssertionError, + "'order' must be either 'ASC' or 'DESC'.", + Article.objects.dates, + "pub_date", + "year", + order="bad order", + ) + + # Use iterator() with datetimes() to return a generator that lazily + # requests each result one at a time, to save memory. + dates = [] + for article in Article.objects.datetimes('pub_date', 'day', order='DESC').iterator(): + dates.append(article) + self.assertEqual(dates, [ + datetime(2005, 7, 31, 0, 0), + datetime(2005, 7, 30, 0, 0), + datetime(2005, 7, 29, 0, 0), + datetime(2005, 7, 28, 0, 0)]) + + # You can combine queries with & and |. + s1 = Article.objects.filter(id__exact=a.id) + s2 = Article.objects.filter(id__exact=a2.id) + self.assertQuerysetEqual(s1 | s2, + ["<Article: Area man programs in Python>", + "<Article: Second article>"]) + self.assertQuerysetEqual(s1 & s2, []) + + # You can get the number of objects like this: + self.assertEqual(len(Article.objects.filter(id__exact=a.id)), 1) + + # You can get items using index and slice notation. + self.assertEqual(Article.objects.all()[0], a) + self.assertQuerysetEqual(Article.objects.all()[1:3], + ["<Article: Second article>", "<Article: Third article>"]) + + s3 = Article.objects.filter(id__exact=a3.id) + self.assertQuerysetEqual((s1 | s2 | s3)[::2], + ["<Article: Area man programs in Python>", + "<Article: Third article>"]) + + # Slicing works with longs (Python 2 only -- Python 3 doesn't have longs). + if not six.PY3: + self.assertEqual(Article.objects.all()[long(0)], a) + self.assertQuerysetEqual(Article.objects.all()[long(1):long(3)], + ["<Article: Second article>", "<Article: Third article>"]) + self.assertQuerysetEqual((s1 | s2 | s3)[::long(2)], + ["<Article: Area man programs in Python>", + "<Article: Third article>"]) + + # And can be mixed with ints. + self.assertQuerysetEqual(Article.objects.all()[1:long(3)], + ["<Article: Second article>", "<Article: Third article>"]) + + # Slices (without step) are lazy: + self.assertQuerysetEqual(Article.objects.all()[0:5].filter(), + ["<Article: Area man programs in Python>", + "<Article: Second article>", + "<Article: Third article>", + "<Article: Article 6>", + "<Article: Default headline>"]) + + # Slicing again works: + self.assertQuerysetEqual(Article.objects.all()[0:5][0:2], + ["<Article: Area man programs in Python>", + "<Article: Second article>"]) + self.assertQuerysetEqual(Article.objects.all()[0:5][:2], + ["<Article: Area man programs in Python>", + "<Article: Second article>"]) + self.assertQuerysetEqual(Article.objects.all()[0:5][4:], + ["<Article: Default headline>"]) + self.assertQuerysetEqual(Article.objects.all()[0:5][5:], []) + + # Some more tests! + self.assertQuerysetEqual(Article.objects.all()[2:][0:2], + ["<Article: Third article>", "<Article: Article 6>"]) + self.assertQuerysetEqual(Article.objects.all()[2:][:2], + ["<Article: Third article>", "<Article: Article 6>"]) + self.assertQuerysetEqual(Article.objects.all()[2:][2:3], + ["<Article: Default headline>"]) + + # Using an offset without a limit is also possible. + self.assertQuerysetEqual(Article.objects.all()[5:], + ["<Article: Fourth article>", + "<Article: Article 7>", + "<Article: Updated article 8>"]) + + # Also, once you have sliced you can't filter, re-order or combine + six.assertRaisesRegex(self, + AssertionError, + "Cannot filter a query once a slice has been taken.", + Article.objects.all()[0:5].filter, + id=a.id, + ) + + six.assertRaisesRegex(self, + AssertionError, + "Cannot reorder a query once a slice has been taken.", + Article.objects.all()[0:5].order_by, + 'id', + ) + + try: + Article.objects.all()[0:1] & Article.objects.all()[4:5] + self.fail('Should raise an AssertionError') + except AssertionError as e: + self.assertEqual(str(e), "Cannot combine queries once a slice has been taken.") + except Exception as e: + self.fail('Should raise an AssertionError, not %s' % e) + + # Negative slices are not supported, due to database constraints. + # (hint: inverting your ordering might do what you need). + try: + Article.objects.all()[-1] + self.fail('Should raise an AssertionError') + except AssertionError as e: + self.assertEqual(str(e), "Negative indexing is not supported.") + except Exception as e: + self.fail('Should raise an AssertionError, not %s' % e) + + error = None + try: + Article.objects.all()[0:-5] + except Exception as e: + error = e + self.assertTrue(isinstance(error, AssertionError)) + self.assertEqual(str(error), "Negative indexing is not supported.") + + # An Article instance doesn't have access to the "objects" attribute. + # That's only available on the class. + six.assertRaisesRegex(self, + AttributeError, + "Manager isn't accessible via Article instances", + getattr, + a7, + "objects", + ) + + # Bulk delete test: How many objects before and after the delete? + self.assertQuerysetEqual(Article.objects.all(), + ["<Article: Area man programs in Python>", + "<Article: Second article>", + "<Article: Third article>", + "<Article: Article 6>", + "<Article: Default headline>", + "<Article: Fourth article>", + "<Article: Article 7>", + "<Article: Updated article 8>"]) + Article.objects.filter(id__lte=a4.id).delete() + self.assertQuerysetEqual(Article.objects.all(), + ["<Article: Article 6>", + "<Article: Default headline>", + "<Article: Article 7>", + "<Article: Updated article 8>"]) + + @skipUnlessDBFeature('supports_microsecond_precision') + def test_microsecond_precision(self): + # In PostgreSQL, microsecond-level precision is available. + a9 = Article( + headline='Article 9', + pub_date=datetime(2005, 7, 31, 12, 30, 45, 180), + ) + a9.save() + self.assertEqual(Article.objects.get(pk=a9.pk).pub_date, + datetime(2005, 7, 31, 12, 30, 45, 180)) + + @skipIfDBFeature('supports_microsecond_precision') + def test_microsecond_precision_not_supported(self): + # In MySQL, microsecond-level precision isn't available. You'll lose + # microsecond-level precision once the data is saved. + a9 = Article( + headline='Article 9', + pub_date=datetime(2005, 7, 31, 12, 30, 45, 180), + ) + a9.save() + self.assertEqual(Article.objects.get(id__exact=a9.id).pub_date, + datetime(2005, 7, 31, 12, 30, 45)) + + def test_manually_specify_primary_key(self): + # You can manually specify the primary key when creating a new object. + a101 = Article( + id=101, + headline='Article 101', + pub_date=datetime(2005, 7, 31, 12, 30, 45), + ) + a101.save() + a101 = Article.objects.get(pk=101) + self.assertEqual(a101.headline, 'Article 101') + + def test_create_method(self): + # You can create saved objects in a single step + a10 = Article.objects.create( + headline="Article 10", + pub_date=datetime(2005, 7, 31, 12, 30, 45), + ) + self.assertEqual(Article.objects.get(headline="Article 10"), a10) + + def test_year_lookup_edge_case(self): + # Edge-case test: A year lookup should retrieve all objects in + # the given year, including Jan. 1 and Dec. 31. + a11 = Article.objects.create( + headline='Article 11', + pub_date=datetime(2008, 1, 1), + ) + a12 = Article.objects.create( + headline='Article 12', + pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), + ) + self.assertQuerysetEqual(Article.objects.filter(pub_date__year=2008), + ["<Article: Article 11>", "<Article: Article 12>"]) + + def test_unicode_data(self): + # Unicode data works, too. + a = Article( + headline='\u6797\u539f \u3081\u3050\u307f', + pub_date=datetime(2005, 7, 28), + ) + a.save() + self.assertEqual(Article.objects.get(pk=a.id).headline, + '\u6797\u539f \u3081\u3050\u307f') + + def test_hash_function(self): + # Model instances have a hash function, so they can be used in sets + # or as dictionary keys. Two models compare as equal if their primary + # keys are equal. + a10 = Article.objects.create( + headline="Article 10", + pub_date=datetime(2005, 7, 31, 12, 30, 45), + ) + a11 = Article.objects.create( + headline='Article 11', + pub_date=datetime(2008, 1, 1), + ) + a12 = Article.objects.create( + headline='Article 12', + pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), + ) + + s = set([a10, a11, a12]) + self.assertTrue(Article.objects.get(headline='Article 11') in s) + + def test_field_ordering(self): + """ + Field instances have a `__lt__` comparison function to define an + ordering based on their creation. Prior to #17851 this ordering + comparison relied on the now unsupported `__cmp__` and was assuming + compared objects were both Field instances raising `AttributeError` + when it should have returned `NotImplemented`. + """ + f1 = Field() + f2 = Field(auto_created=True) + f3 = Field() + self.assertTrue(f2 < f1) + self.assertTrue(f3 > f1) + self.assertFalse(f1 == None) + self.assertFalse(f2 in (None, 1, '')) + + def test_extra_method_select_argument_with_dashes_and_values(self): + # The 'select' argument to extra() supports names with dashes in + # them, as long as you use values(). + a10 = Article.objects.create( + headline="Article 10", + pub_date=datetime(2005, 7, 31, 12, 30, 45), + ) + a11 = Article.objects.create( + headline='Article 11', + pub_date=datetime(2008, 1, 1), + ) + a12 = Article.objects.create( + headline='Article 12', + pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), + ) + + dicts = Article.objects.filter( + pub_date__year=2008).extra( + select={'dashed-value': '1'} + ).values('headline', 'dashed-value') + self.assertEqual([sorted(d.items()) for d in dicts], + [[('dashed-value', 1), ('headline', 'Article 11')], [('dashed-value', 1), ('headline', 'Article 12')]]) + + def test_extra_method_select_argument_with_dashes(self): + # If you use 'select' with extra() and names containing dashes on a + # query that's *not* a values() query, those extra 'select' values + # will silently be ignored. + a10 = Article.objects.create( + headline="Article 10", + pub_date=datetime(2005, 7, 31, 12, 30, 45), + ) + a11 = Article.objects.create( + headline='Article 11', + pub_date=datetime(2008, 1, 1), + ) + a12 = Article.objects.create( + headline='Article 12', + pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), + ) + + articles = Article.objects.filter( + pub_date__year=2008).extra( + select={'dashed-value': '1', 'undashedvalue': '2'}) + self.assertEqual(articles[0].undashedvalue, 2) + + def test_create_relation_with_ugettext_lazy(self): + """ + Test that ugettext_lazy objects work when saving model instances + through various methods. Refs #10498. + """ + notlazy = 'test' + lazy = ugettext_lazy(notlazy) + reporter = Article.objects.create(headline=lazy, pub_date=datetime.now()) + article = Article.objects.get() + self.assertEqual(article.headline, notlazy) + # test that assign + save works with Promise objecs + article.headline = lazy + article.save() + self.assertEqual(article.headline, notlazy) + # test .update() + Article.objects.update(headline=lazy) + article = Article.objects.get() + self.assertEqual(article.headline, notlazy) + # still test bulk_create() + Article.objects.all().delete() + Article.objects.bulk_create([Article(headline=lazy, pub_date=datetime.now())]) + article = Article.objects.get() + self.assertEqual(article.headline, notlazy) + + def test_emptyqs(self): + # Can't be instantiated + with self.assertRaises(TypeError): + EmptyQuerySet() + self.assertTrue(isinstance(Article.objects.none(), EmptyQuerySet)) + + def test_emptyqs_values(self): + # test for #15959 + Article.objects.create(headline='foo', pub_date=datetime.now()) + with self.assertNumQueries(0): + qs = Article.objects.none().values_list('pk') + self.assertTrue(isinstance(qs, EmptyQuerySet)) + self.assertTrue(isinstance(qs, ValuesListQuerySet)) + self.assertEqual(len(qs), 0) + + def test_emptyqs_customqs(self): + # A hacky test for custom QuerySet subclass - refs #17271 + Article.objects.create(headline='foo', pub_date=datetime.now()) + class CustomQuerySet(QuerySet): + def do_something(self): + return 'did something' + + qs = Article.objects.all() + qs.__class__ = CustomQuerySet + qs = qs.none() + with self.assertNumQueries(0): + self.assertEqual(len(qs), 0) + self.assertTrue(isinstance(qs, EmptyQuerySet)) + self.assertEqual(qs.do_something(), 'did something') + + def test_emptyqs_values_order(self): + # Tests for ticket #17712 + Article.objects.create(headline='foo', pub_date=datetime.now()) + with self.assertNumQueries(0): + self.assertEqual(len(Article.objects.none().values_list('id').order_by('id')), 0) + with self.assertNumQueries(0): + self.assertEqual(len(Article.objects.none().filter( + id__in=Article.objects.values_list('id', flat=True))), 0) + + @skipUnlessDBFeature('can_distinct_on_fields') + def test_emptyqs_distinct(self): + # Tests for #19426 + Article.objects.create(headline='foo', pub_date=datetime.now()) + with self.assertNumQueries(0): + self.assertEqual(len(Article.objects.none().distinct('headline', 'pub_date')), 0) + + def test_invalid_qs_list(self): + qs = Article.objects.order_by('invalid_column') + self.assertRaises(FieldError, list, qs) + self.assertRaises(FieldError, list, qs)
\ No newline at end of file |