desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Check that if no CSRF cookies is present, the middleware rejects the
incoming request. This will stop login CSRF.'
| def test_process_request_no_csrf_cookie(self):
| req = self._get_POST_no_csrf_cookie_request()
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(403, req2.status_code)
|
'Check that if a CSRF cookie is present but no token, the middleware
rejects the incoming request.'
| def test_process_request_csrf_cookie_no_token(self):
| req = self._get_POST_csrf_cookie_request()
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(403, req2.status_code)
|
'Check that if both a cookie and a token is present, the middleware lets it through.'
| def test_process_request_csrf_cookie_and_token(self):
| req = self._get_POST_request_with_token()
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(None, req2)
|
'Check that if a CSRF cookie is present and no token, but the csrf_exempt
decorator has been applied to the view, the middleware lets it through'
| def test_process_request_csrf_cookie_no_token_exempt_view(self):
| req = self._get_POST_csrf_cookie_request()
req2 = CsrfViewMiddleware().process_view(req, csrf_exempt(post_form_view), (), {})
self.assertEqual(None, req2)
|
'Check that we can pass in the token in a header instead of in the form'
| def test_csrf_token_in_header(self):
| req = self._get_POST_csrf_cookie_request()
req.META[u'HTTP_X_CSRFTOKEN'] = self._csrf_id
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(None, req2)
|
'Tests that HTTP PUT and DELETE methods have protection'
| def test_put_and_delete_rejected(self):
| req = TestingHttpRequest()
req.method = u'PUT'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(403, req2.status_code)
req = TestingHttpRequest()
req.method = u'DELETE'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(403, req2.status_code)
|
'Tests that HTTP PUT and DELETE methods can get through with
X-CSRFToken and a cookie'
| def test_put_and_delete_allowed(self):
| req = self._get_GET_csrf_cookie_request()
req.method = u'PUT'
req.META[u'HTTP_X_CSRFTOKEN'] = self._csrf_id
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(None, req2)
req = self._get_GET_csrf_cookie_request()
req.method = u'DELETE'
req.META[u'HTTP_X_CSRFTOKEN'] = self._csrf_id
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(None, req2)
|
'Check that CsrfTokenNode works when no CSRF cookie is set'
| def test_token_node_no_csrf_cookie(self):
| req = self._get_GET_no_csrf_cookie_request()
resp = token_view(req)
self.assertEqual(resp.content, '')
|
'Check that we get a new token if the csrf_cookie is the empty string'
| def test_token_node_empty_csrf_cookie(self):
| req = self._get_GET_no_csrf_cookie_request()
req.COOKIES[settings.CSRF_COOKIE_NAME] = ''
CsrfViewMiddleware().process_view(req, token_view, (), {})
resp = token_view(req)
self.assertNotEqual(u'', resp.content)
|
'Check that CsrfTokenNode works when a CSRF cookie is set'
| def test_token_node_with_csrf_cookie(self):
| req = self._get_GET_csrf_cookie_request()
CsrfViewMiddleware().process_view(req, token_view, (), {})
resp = token_view(req)
self._check_token_present(resp)
|
'Check that get_token still works for a view decorated with \'csrf_exempt\'.'
| def test_get_token_for_exempt_view(self):
| req = self._get_GET_csrf_cookie_request()
CsrfViewMiddleware().process_view(req, csrf_exempt(token_view), (), {})
resp = token_view(req)
self._check_token_present(resp)
|
'Check that get_token works for a view decorated solely with requires_csrf_token'
| def test_get_token_for_requires_csrf_token_view(self):
| req = self._get_GET_csrf_cookie_request()
resp = requires_csrf_token(token_view)(req)
self._check_token_present(resp)
|
'Check that CsrfTokenNode works when a CSRF cookie is created by
the middleware (when one was not already present)'
| def test_token_node_with_new_csrf_cookie(self):
| req = self._get_GET_no_csrf_cookie_request()
CsrfViewMiddleware().process_view(req, token_view, (), {})
resp = token_view(req)
resp2 = CsrfViewMiddleware().process_response(req, resp)
csrf_cookie = resp2.cookies[settings.CSRF_COOKIE_NAME]
self._check_token_present(resp, csrf_id=csrf_cookie.value)
|
'Test that a POST HTTPS request with a bad referer is rejected'
| @override_settings(ALLOWED_HOSTS=[u'www.example.com'])
def test_https_bad_referer(self):
| req = self._get_POST_request_with_token()
req._is_secure_override = True
req.META[u'HTTP_HOST'] = u'www.example.com'
req.META[u'HTTP_REFERER'] = u'https://www.evil.org/somepage'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertNotEqual(None, req2)
self.assertEqual(403, req2.status_code)
|
'Test that a POST HTTPS request with a good referer is accepted'
| @override_settings(ALLOWED_HOSTS=[u'www.example.com'])
def test_https_good_referer(self):
| req = self._get_POST_request_with_token()
req._is_secure_override = True
req.META[u'HTTP_HOST'] = u'www.example.com'
req.META[u'HTTP_REFERER'] = u'https://www.example.com/somepage'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(None, req2)
|
'Test that a POST HTTPS request with a good referer is accepted
where the referer contains no trailing slash'
| @override_settings(ALLOWED_HOSTS=[u'www.example.com'])
def test_https_good_referer_2(self):
| req = self._get_POST_request_with_token()
req._is_secure_override = True
req.META[u'HTTP_HOST'] = u'www.example.com'
req.META[u'HTTP_REFERER'] = u'https://www.example.com'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(None, req2)
|
'Tests that ensures_csrf_cookie decorator fulfils its promise
with no middleware'
| def test_ensures_csrf_cookie_no_middleware(self):
| @ensure_csrf_cookie
def view(request):
return HttpResponse(content=u'')
req = self._get_GET_no_csrf_cookie_request()
resp = view(req)
self.assertTrue(resp.cookies.get(settings.CSRF_COOKIE_NAME, False))
self.assertTrue((u'Cookie' in resp.get(u'Vary', u'')))
|
'Tests that ensures_csrf_cookie decorator fulfils its promise
with the middleware enabled.'
| def test_ensures_csrf_cookie_with_middleware(self):
| @ensure_csrf_cookie
def view(request):
return HttpResponse(content=u'')
req = self._get_GET_no_csrf_cookie_request()
CsrfViewMiddleware().process_view(req, view, (), {})
resp = view(req)
resp2 = CsrfViewMiddleware().process_response(req, resp)
self.assertTrue(resp2.cookies.get(settings.CSRF_COOKIE_NAME, False))
self.assertTrue((u'Cookie' in resp2.get(u'Vary', u'')))
|
'Year boundary tests (ticket #3689)'
| def test_year_boundaries(self):
| d = Donut.objects.create(name=u'Date Test 2007', baked_date=datetime.datetime(year=2007, month=12, day=31), consumed_at=datetime.datetime(year=2007, month=12, day=31, hour=23, minute=59, second=59))
d1 = Donut.objects.create(name=u'Date Test 2006', baked_date=datetime.datetime(year=2006, month=1, day=1), consumed_at=datetime.datetime(year=2006, month=1, day=1))
self.assertEqual(u'Date Test 2007', Donut.objects.filter(baked_date__year=2007)[0].name)
self.assertEqual(u'Date Test 2006', Donut.objects.filter(baked_date__year=2006)[0].name)
d2 = Donut.objects.create(name=u'Apple Fritter', consumed_at=datetime.datetime(year=2007, month=4, day=20, hour=16, minute=19, second=59))
self.assertEqual([u'Apple Fritter', u'Date Test 2007'], list(Donut.objects.filter(consumed_at__year=2007).order_by(u'name').values_list(u'name', flat=True)))
self.assertEqual(0, Donut.objects.filter(consumed_at__year=2005).count())
self.assertEqual(0, Donut.objects.filter(consumed_at__year=2008).count())
|
'Regression test for #10238: TextField values returned from the
database should be unicode.'
| def test_textfields_unicode(self):
| d = Donut.objects.create(name=u'Jelly Donut', review=u'Outstanding')
newd = Donut.objects.get(id=d.id)
self.assertTrue(isinstance(newd.review, six.text_type))
|
'Regression test for #8354: the MySQL and Oracle backends should raise
an error if given a timezone-aware datetime object.'
| @skipIfDBFeature(u'supports_timezones')
def test_error_on_timezone(self):
| dt = datetime.datetime(2008, 8, 31, 16, 20, tzinfo=utc)
d = Donut(name=u'Bear claw', consumed_at=dt)
self.assertRaises(ValueError, d.save)
|
'Regression test for #10970, auto_now_add for DateField should store
a Python datetime.date, not a datetime.datetime'
| def test_datefield_auto_now_add(self):
| b = RumBaba.objects.create()
self.assertTrue(isinstance(b.baked_timestamp, datetime.datetime))
self.assertTrue((isinstance(b.baked_date, datetime.date) and (not isinstance(b.baked_date, datetime.datetime))))
|
'Regression test for #1661 and #1662
Check that string form referencing of
models works, both as pre and post reference, on all RelatedField types.'
| def test_string_form_referencing(self):
| f1 = Foo(name=u'Foo1')
f1.save()
f2 = Foo(name=u'Foo2')
f2.save()
w1 = Whiz(name=u'Whiz1')
w1.save()
b1 = Bar(name=u'Bar1', normal=f1, fwd=w1, back=f2)
b1.save()
self.assertEqual(b1.normal, f1)
self.assertEqual(b1.fwd, w1)
self.assertEqual(b1.back, f2)
base1 = Base(name=u'Base1')
base1.save()
child1 = Child(name=u'Child1', parent=base1)
child1.save()
self.assertEqual(child1.parent, base1)
|
'Regression tests for #3937
make sure we can use unicode characters in queries.
If these tests fail on MySQL, it\'s a problem with the test setup.
A properly configured UTF-8 database can handle this.'
| def test_unicode_chars_in_queries(self):
| fx = Foo(name=u'Bjorn', friend=u'Fran\xe7ois')
fx.save()
self.assertEqual(Foo.objects.get(friend__contains=u'\xe7'), fx)
self.assertEqual(Foo.objects.get(friend__contains='\xc3\xa7'), fx)
|
'Regression tests for #5087
make sure we can perform queries on TextFields.'
| def test_queries_on_textfields(self):
| a = Article(name=u'Test', text=u'The quick brown fox jumps over the lazy dog.')
a.save()
self.assertEqual(Article.objects.get(text__exact=u'The quick brown fox jumps over the lazy dog.'), a)
self.assertEqual(Article.objects.get(text__contains=u'quick brown fox'), a)
|
'Regression test for #708
"like" queries on IP address fields require casting to text (on PostgreSQL).'
| def test_ipaddress_on_postgresql(self):
| a = Article(name=u'IP test', text=u'The body', submitted_from=u'192.0.2.100')
a.save()
self.assertEqual(repr(Article.objects.filter(submitted_from__contains=u'192.0.2')), repr([a]))
|
'Zero as id for AutoField should raise exception in MySQL, because MySQL
does not allow zero for automatic primary key.'
| @skipIfDBFeature('allows_primary_key_0')
def test_zero_as_autoval(self):
| valid_country = Country(name='Germany', iso_two_letter='DE')
invalid_country = Country(id=0, name='Poland', iso_two_letter='PL')
with self.assertRaises(ValueError):
Country.objects.bulk_create([valid_country, invalid_country])
|
'Test inserting a large batch with objects having primary key set
mixed together with objects without PK set.'
| def test_large_batch_mixed(self):
| with override_settings(DEBUG=True):
connection.queries = []
TwoFields.objects.bulk_create([TwoFields(id=(i if ((i % 2) == 0) else None), f1=i, f2=(i + 1)) for i in range(100000, 101000)])
self.assertEqual(TwoFields.objects.count(), 1000)
id_range = range(100000, 101000, 2)
self.assertEqual(TwoFields.objects.filter(id__in=id_range).count(), 500)
self.assertEqual(TwoFields.objects.exclude(id__in=id_range).count(), 500)
|
'Test inserting a large batch with objects having primary key set
mixed together with objects without PK set.'
| @skipUnlessDBFeature('has_bulk_insert')
def test_large_batch_mixed_efficiency(self):
| with override_settings(DEBUG=True):
connection.queries = []
TwoFields.objects.bulk_create([TwoFields(id=(i if ((i % 2) == 0) else None), f1=i, f2=(i + 1)) for i in range(100000, 101000)])
self.assertTrue((len(connection.queries) < 10))
|
'Regression test for #12822: DatabaseError: aggregates not allowed in
WHERE clause
Tests that the subselect works and returns results equivalent to a
query with the IDs listed.
Before the corresponding fix for this bug, this test passed in 1.1 and
failed in 1.2-beta (trunk).'
| def test_aggregates_in_where_clause(self):
| qs = Book.objects.values(u'contact').annotate(Max(u'id'))
qs = qs.order_by(u'contact').values_list(u'id__max', flat=True)
books = Book.objects.order_by(u'id')
qs1 = books.filter(id__in=qs)
qs2 = books.filter(id__in=list(qs))
self.assertEqual(list(qs1), list(qs2))
|
'Regression test for #12822: DatabaseError: aggregates not allowed in
WHERE clause
Same as the above test, but evaluates the queryset for the subquery
before it\'s used as a subquery.
Before the corresponding fix for this bug, this test failed in both
1.1 and 1.2-beta (trunk).'
| def test_aggregates_in_where_clause_pre_eval(self):
| qs = Book.objects.values(u'contact').annotate(Max(u'id'))
qs = qs.order_by(u'contact').values_list(u'id__max', flat=True)
list(qs)
books = Book.objects.order_by(u'id')
qs1 = books.filter(id__in=qs)
qs2 = books.filter(id__in=list(qs))
self.assertEqual(list(qs1), list(qs2))
|
'Regression test for #11916: Extra params + aggregation creates
incorrect SQL.'
| @skipUnlessDBFeature(u'supports_subqueries_in_group_by')
def test_annotate_with_extra(self):
| shortest_book_sql = u'\n SELECT name\n FROM aggregation_regress_book b\n WHERE b.publisher_id = aggregation_regress_publisher.id\n ORDER BY b.pages\n LIMIT 1\n '
qs = Publisher.objects.extra(select={u'name_of_shortest_book': shortest_book_sql}).annotate(total_books=Count(u'book'))
list(qs)
|
'Test that the base table\'s join isn\'t promoted to LOUTER. This could
cause the query generation to fail if there is an exclude() for fk-field
in the query, too. Refs #19087.'
| def test_annotate_joins(self):
| qs = Book.objects.annotate(n=Count(u'pk'))
self.assertIs(qs.query.alias_map[u'aggregation_regress_book'].join_type, None)
self.assertEqual(len(qs.exclude(publisher=(-1))), 6)
|
'Introspection of column names consist/start with digits (#16536/#17676)'
| def test_digits_column_name_introspection(self):
| out = StringIO()
call_command(u'inspectdb', table_name_filter=(lambda tn: tn.startswith(u'inspectdb_')), stdout=out)
output = out.getvalue()
error_message = u'inspectdb generated a model field name which is a number'
self.assertNotIn(u' 123 = models.CharField', output, msg=error_message)
self.assertIn(u'number_123 = models.CharField', output)
error_message = u'inspectdb generated a model field name which starts with a digit'
self.assertNotIn(u' 4extra = models.CharField', output, msg=error_message)
self.assertIn(u'number_4extra = models.CharField', output)
self.assertNotIn(u' 45extra = models.CharField', output, msg=error_message)
self.assertIn(u'number_45extra = models.CharField', output)
|
'Introspection of column names containing special characters,
unsuitable for Python identifiers'
| def test_special_column_name_introspection(self):
| out = StringIO()
call_command(u'inspectdb', stdout=out)
output = out.getvalue()
base_name = (u'Field' if (connection.vendor != u'oracle') else u'field')
self.assertIn(u'field = models.IntegerField()', output)
self.assertIn((u"field_field = models.IntegerField(db_column='%s_')" % base_name), output)
self.assertIn((u"field_field_0 = models.IntegerField(db_column='%s__')" % base_name), output)
self.assertIn(u"field_field_1 = models.IntegerField(db_column='__field')", output)
self.assertIn(u"prc_x = models.IntegerField(db_column='prc(%) x')", output)
|
'Model saves should throw some signals.'
| def test_model_signals(self):
| a1 = Author(name='Neal Stephenson')
self.assertEqual(self.get_signal_output(a1.save), ['pre_save signal, Neal Stephenson', 'post_save signal, Neal Stephenson', 'Is created'])
b1 = Book(name='Snow Crash')
self.assertEqual(self.get_signal_output(b1.save), ['pre_save signal, Snow Crash', 'post_save signal, Snow Crash', 'Is created'])
|
'Assigning and removing to/from m2m shouldn\'t generate an m2m signal'
| def test_m2m_signals(self):
| b1 = Book(name='Snow Crash')
self.get_signal_output(b1.save)
a1 = Author(name='Neal Stephenson')
self.get_signal_output(a1.save)
self.assertEqual(self.get_signal_output(setattr, b1, 'authors', [a1]), [])
self.assertEqual(self.get_signal_output(setattr, b1, 'authors', []), [])
|
'Even though the default manager filters out some records,
we must still be able to save (particularly, save by updating
existing records) those filtered instances. This is a
regression test for #8990, #9527'
| def test_filtered_default_manager(self):
| related = RelatedModel.objects.create(name='xyzzy')
obj = RestrictedModel.objects.create(name='hidden', related=related)
obj.name = 'still hidden'
obj.save()
self.assertEqual(RestrictedModel.plain_manager.count(), 1)
|
'Deleting related objects should also not be distracted by a
restricted manager on the related object. This is a regression
test for #2698.'
| def test_delete_related_on_filtered_manager(self):
| related = RelatedModel.objects.create(name='xyzzy')
for (name, public) in (('one', True), ('two', False), ('three', False)):
RestrictedModel.objects.create(name=name, is_public=public, related=related)
obj = RelatedModel.objects.get(name='xyzzy')
obj.delete()
self.assertEqual(len(RestrictedModel.plain_manager.all()), 0)
|
'A save method that modifies the data in the object'
| def save(self):
| self.data = 666
super(ModifyingSaveData, self).save(raw)
|
'#15889: get_serializer(\'nonsense\') raises a SerializerDoesNotExist'
| def test_get_unknown_serializer(self):
| with self.assertRaises(SerializerDoesNotExist):
serializers.get_serializer(u'nonsense')
with self.assertRaises(KeyError):
serializers.get_serializer(u'nonsense')
with self.assertRaises(SerializerDoesNotExist) as cm:
serializers.get_serializer(u'nonsense')
self.assertEqual(cm.exception.args, (u'nonsense',))
|
'The XML deserializer shouldn\'t allow a DTD.
This is the most straightforward way to prevent all entity definitions
and avoid both external entities and entity-expansion attacks.'
| def test_no_dtd(self):
| xml = u'<?xml version="1.0" standalone="no"?><!DOCTYPE example SYSTEM "http://example.com/example.dtd">'
with self.assertRaises(DTDForbidden):
next(serializers.deserialize(u'xml', xml))
|
'Ticket #13839: select_related() should NOT cache None
for missing objects on a reverse 1-1 relation.'
| def test_missing_reverse(self):
| with self.assertNumQueries(1):
user = User.objects.select_related('userprofile').get(username='bob')
with self.assertRaises(UserProfile.DoesNotExist):
user.userprofile
|
'Ticket #13839: select_related() should NOT cache None
for missing objects on a reverse 0-1 relation.'
| def test_nullable_missing_reverse(self):
| Image.objects.create(name='imag1')
with self.assertNumQueries(1):
image = Image.objects.select_related('product').get()
with self.assertRaises(Product.DoesNotExist):
image.product
|
'Rendering a template response triggers the post-render callbacks'
| def test_post_callbacks(self):
| post = []
def post1(obj):
post.append(u'post1')
def post2(obj):
post.append(u'post2')
response = SimpleTemplateResponse(u'first/test.html', {})
response.add_post_render_callback(post1)
response.add_post_render_callback(post2)
response.render()
self.assertEqual(response.content, 'First template\n')
self.assertEqual(post, [u'post1', u'post2'])
|
'Test that inclusion tag passes down `current_app` of context to the
Context of the included/rendered template as well.'
| def test_15070_current_app(self):
| c = template.Context({})
t = template.Template(u'{% load custom %}{% inclusion_tag_current_app %}')
self.assertEqual(t.render(c).strip(), u'None')
c.current_app = u'advanced'
self.assertEqual(t.render(c).strip(), u'advanced')
|
'Test that inclusion tag passes down `use_l10n` of context to the
Context of the included/rendered template as well.'
| def test_15070_use_l10n(self):
| c = template.Context({})
t = template.Template(u'{% load custom %}{% inclusion_tag_use_l10n %}')
self.assertEqual(t.render(c).strip(), u'None')
c.use_l10n = True
self.assertEqual(t.render(c).strip(), u'True')
|
'Tests that the correct template is identified as not existing
when {% include %} specifies a template that does not exist.'
| def test_include_missing_template(self):
| (old_td, settings.TEMPLATE_DEBUG) = (settings.TEMPLATE_DEBUG, True)
old_loaders = loader.template_source_loaders
try:
loader.template_source_loaders = (app_directories.Loader(),)
load_name = u'test_include_error.html'
r = None
try:
tmpl = loader.select_template([load_name])
r = tmpl.render(template.Context({}))
except template.TemplateDoesNotExist as e:
settings.TEMPLATE_DEBUG = old_td
self.assertEqual(e.args[0], u'missing.html')
self.assertEqual(r, None, (u'Template rendering unexpectedly succeeded, produced: ->%r<-' % r))
finally:
loader.template_source_loaders = old_loaders
settings.TEMPLATE_DEBUG = old_td
|
'Tests that the correct template is identified as not existing
when {% extends %} specifies a template that does exist, but
that template has an {% include %} of something that does not
exist. See #12787.'
| def test_extends_include_missing_baseloader(self):
| (old_td, settings.TEMPLATE_DEBUG) = (settings.TEMPLATE_DEBUG, True)
old_loaders = loader.template_source_loaders
try:
loader.template_source_loaders = (app_directories.Loader(),)
load_name = u'test_extends_error.html'
tmpl = loader.get_template(load_name)
r = None
try:
r = tmpl.render(template.Context({}))
except template.TemplateDoesNotExist as e:
settings.TEMPLATE_DEBUG = old_td
self.assertEqual(e.args[0], u'missing.html')
self.assertEqual(r, None, (u'Template rendering unexpectedly succeeded, produced: ->%r<-' % r))
finally:
loader.template_source_loaders = old_loaders
settings.TEMPLATE_DEBUG = old_td
|
'Same as test_extends_include_missing_baseloader, only tests
behavior of the cached loader instead of BaseLoader.'
| def test_extends_include_missing_cachedloader(self):
| (old_td, settings.TEMPLATE_DEBUG) = (settings.TEMPLATE_DEBUG, True)
old_loaders = loader.template_source_loaders
try:
cache_loader = cached.Loader((u'',))
cache_loader._cached_loaders = (app_directories.Loader(),)
loader.template_source_loaders = (cache_loader,)
load_name = u'test_extends_error.html'
tmpl = loader.get_template(load_name)
r = None
try:
r = tmpl.render(template.Context({}))
except template.TemplateDoesNotExist as e:
self.assertEqual(e.args[0], u'missing.html')
self.assertEqual(r, None, (u'Template rendering unexpectedly succeeded, produced: ->%r<-' % r))
tmpl = loader.get_template(load_name)
try:
tmpl.render(template.Context({}))
except template.TemplateDoesNotExist as e:
self.assertEqual(e.args[0], u'missing.html')
self.assertEqual(r, None, (u'Template rendering unexpectedly succeeded, produced: ->%r<-' % r))
finally:
loader.template_source_loaders = old_loaders
settings.TEMPLATE_DEBUG = old_td
|
'The template system doesn\'t wrap exceptions, but annotates them.
Refs #16770'
| @override_settings(DEBUG=True, TEMPLATE_DEBUG=True)
def test_no_wrapped_exception(self):
| c = Context({u'coconuts': (lambda : (42 / 0))})
t = Template(u'{{ coconuts }}')
with self.assertRaises(ZeroDivisionError) as cm:
t.render(c)
self.assertEqual(cm.exception.django_template_source[1], (0, 14))
|
'Regression test for #15721, ``{% include %}`` and ``RequestContext``
not playing together nicely.'
| def test_include_only(self):
| ctx = RequestContext(self.fake_request, {u'var': u'parent'})
self.assertEqual(template.Template(u'{% include "child" %}').render(ctx), u'parent')
self.assertEqual(template.Template(u'{% include "child" only %}').render(ctx), u'none')
|
'Loading any template on an empty egg should fail'
| def test_empty(self):
| settings.INSTALLED_APPS = ['egg_empty']
egg_loader = EggLoader()
self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, 'not-existing.html')
|
'Template loading fails if the template is not in the egg'
| def test_non_existing(self):
| settings.INSTALLED_APPS = ['egg_1']
egg_loader = EggLoader()
self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, 'not-existing.html')
|
'A template can be loaded from an egg'
| def test_existing(self):
| settings.INSTALLED_APPS = ['egg_1']
egg_loader = EggLoader()
(contents, template_name) = egg_loader.load_template_source('y.html')
self.assertEqual(contents, 'y')
self.assertEqual(template_name, 'egg:egg_1:templates/y.html')
|
'Loading an existent template from an egg not included in INSTALLED_APPS should fail'
| def test_not_installed(self):
| settings.INSTALLED_APPS = []
egg_loader = EggLoader()
self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, 'y.html')
|
'Check that the template directories form part of the template cache key. Refs #13573'
| def test_templatedir_caching(self):
| (t1, name) = loader.find_template('test.html', (os.path.join(os.path.dirname(upath(__file__)), 'templates', 'first'),))
(t2, name) = loader.find_template('test.html', (os.path.join(os.path.dirname(upath(__file__)), 'templates', 'second'),))
self.assertNotEqual(t1.render(Context({})), t2.render(Context({})))
|
'Tests that passing a URL path to ``resolve_url`` will result in the
same url.'
| def test_url_path(self):
| self.assertEqual(u'/something/', resolve_url(u'/something/'))
|
'Tests that passing a full URL to ``resolve_url`` will result in the
same url.'
| def test_full_url(self):
| url = u'http://example.com/'
self.assertEqual(url, resolve_url(url))
|
'Tests that passing a model to ``resolve_url`` will result in
``get_absolute_url`` being called on that model instance.'
| def test_model(self):
| m = UnimportantThing(importance=1)
self.assertEqual(m.get_absolute_url(), resolve_url(m))
|
'Tests that passing a view name to ``resolve_url`` will result in the
URL path mapping to that view name.'
| def test_view_function(self):
| resolved_url = resolve_url(logout)
self.assertEqual(u'/accounts/logout/', resolved_url)
|
'Tests that passing a view function to ``resolve_url`` will result in
the URL path mapping to that view.'
| def test_valid_view_name(self):
| resolved_url = resolve_url(u'django.contrib.auth.views.logout')
self.assertEqual(u'/accounts/logout/', resolved_url)
|
'Tests that passing a domain to ``resolve_url`` returns the same domain.'
| def test_domain(self):
| self.assertEqual(resolve_url(u'example.com'), u'example.com')
|
'Tests that passing a non-view callable into ``resolve_url`` raises a
``NoReverseMatch`` exception.'
| def test_non_view_callable_raises_no_reverse_match(self):
| with self.assertRaises(NoReverseMatch):
resolve_url((lambda : u'asdf'))
|
'can_delete should be passed to inlineformset factory.'
| def test_can_delete(self):
| response = self.client.get(self.change_url)
inner_formset = response.context[u'inline_admin_formsets'][0].formset
expected = InnerInline.can_delete
actual = inner_formset.can_delete
self.assertEqual(expected, actual, u'can_delete must be equal')
|
'Bug #13174.'
| def test_readonly_stacked_inline_label(self):
| holder = Holder.objects.create(dummy=42)
inner = Inner.objects.create(holder=holder, dummy=42, readonly=u'')
response = self.client.get((u'/admin/admin_inlines/holder/%i/' % holder.id))
self.assertContains(response, u'<label>Inner readonly label:</label>')
|
'Autogenerated many-to-many inlines are displayed correctly (#13407)'
| def test_many_to_many_inlines(self):
| response = self.client.get(u'/admin/admin_inlines/author/add/')
self.assertContains(response, u'<h2>Author-book relationships</h2>')
self.assertContains(response, u'Add another Author-Book Relationship')
self.assertContains(response, u'id="id_Author_books-TOTAL_FORMS"')
|
'Ensure that non_field_errors are displayed correctly, including the
right value for colspan. Refs #13510.'
| def test_tabular_non_field_errors(self):
| data = {u'title_set-TOTAL_FORMS': 1, u'title_set-INITIAL_FORMS': 0, u'title_set-MAX_NUM_FORMS': 0, u'_save': u'Save', u'title_set-0-title1': u'a title', u'title_set-0-title2': u'a different title'}
response = self.client.post(u'/admin/admin_inlines/titlecollection/add/', data)
self.assertContains(response, u'<tr><td colspan="4"><ul class="errorlist"><li>The two titles must be the same</li></ul></td></tr>')
|
'Admin inline `readonly_field` shouldn\'t invoke parent ModelAdmin callable'
| def test_no_parent_callable_lookup(self):
| response = self.client.get(u'/admin/admin_inlines/novel/add/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'<div class="inline-group" id="chapter_set-group">')
|
'Admin inline should invoke local callable when its name is listed in readonly_fields'
| def test_callable_lookup(self):
| response = self.client.get(u'/admin/admin_inlines/poll/add/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, u'<div class="inline-group" id="question_set-group">')
self.assertContains(response, u'<p>Callable in QuestionInline</p>')
|
'Ensure that the inlines\' model field help texts are displayed when
using both the stacked and tabular layouts.
Ref #8190.'
| def test_help_text(self):
| response = self.client.get(u'/admin/admin_inlines/holder4/add/')
self.assertContains(response, u'<p class="help">Awesome stacked help text is awesome.</p>', 4)
self.assertContains(response, u'<img src="/static/admin/img/icon-unknown.gif" class="help help-tooltip" width="10" height="10" alt="(Awesome tabular help text is awesome.)" title="Awesome tabular help text is awesome." />', 1)
|
'Ensure that multiple inlines with related_name=\'+\' have correct form
prefixes. Bug #16838.'
| def test_non_related_name_inline(self):
| response = self.client.get(u'/admin/admin_inlines/capofamiglia/add/')
self.assertContains(response, u'<input type="hidden" name="-1-0-id" id="id_-1-0-id" />', html=True)
self.assertContains(response, u'<input type="hidden" name="-1-0-capo_famiglia" id="id_-1-0-capo_famiglia" />', html=True)
self.assertContains(response, u'<input id="id_-1-0-name" type="text" class="vTextField" name="-1-0-name" maxlength="100" />', html=True)
self.assertContains(response, u'<input type="hidden" name="-2-0-id" id="id_-2-0-id" />', html=True)
self.assertContains(response, u'<input type="hidden" name="-2-0-capo_famiglia" id="id_-2-0-capo_famiglia" />', html=True)
self.assertContains(response, u'<input id="id_-2-0-name" type="text" class="vTextField" name="-2-0-name" maxlength="100" />', html=True)
|
'Ensure that the "View on Site" link is correct for locales that use
thousand separators'
| @override_settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True)
def test_localize_pk_shortcut(self):
| holder = Holder.objects.create(pk=123456789, dummy=42)
inner = Inner.objects.create(pk=987654321, holder=holder, dummy=42, readonly=u'')
response = self.client.get((u'/admin/admin_inlines/holder/%i/' % holder.id))
inner_shortcut = (u'r/%s/%s/' % (ContentType.objects.get_for_model(inner).pk, inner.pk))
self.assertContains(response, inner_shortcut)
|
'Ensure that the "View on Site" link is correct for models with a
custom primary key field. Bug #18433.'
| def test_custom_pk_shortcut(self):
| parent = ParentModelWithCustomPk.objects.create(my_own_pk=u'foo', name=u'Foo')
child1 = ChildModel1.objects.create(my_own_pk=u'bar', name=u'Bar', parent=parent)
child2 = ChildModel2.objects.create(my_own_pk=u'baz', name=u'Baz', parent=parent)
response = self.client.get(u'/admin/admin_inlines/parentmodelwithcustompk/foo/')
child1_shortcut = (u'r/%s/%s/' % (ContentType.objects.get_for_model(child1).pk, child1.pk))
child2_shortcut = (u'r/%s/%s/' % (ContentType.objects.get_for_model(child2).pk, child2.pk))
self.assertContains(response, child1_shortcut)
self.assertContains(response, child2_shortcut)
|
'Ensure that an object can be created with inlines when it inherits
another class. Bug #19524.'
| def test_create_inlines_on_inherited_model(self):
| data = {u'name': u'Martian', u'sighting_set-TOTAL_FORMS': 1, u'sighting_set-INITIAL_FORMS': 0, u'sighting_set-MAX_NUM_FORMS': 0, u'sighting_set-0-place': u'Zone 51', u'_save': u'Save'}
response = self.client.post(u'/admin/admin_inlines/extraterrestrial/add/', data)
self.assertEqual(response.status_code, 302)
self.assertEqual(Sighting.objects.filter(et__name=u'Martian').count(), 1)
|
'Regression for #9362
The problem depends only on InlineAdminForm and its "original"
argument, so we can safely set the other arguments to None/{}. We just
need to check that the content_type argument of Child isn\'t altered by
the internals of the inline form.'
| def test_immutable_content_type(self):
| sally = Teacher.objects.create(name=u'Sally')
john = Parent.objects.create(name=u'John')
joe = Child.objects.create(name=u'Joe', teacher=sally, parent=john)
iaf = InlineAdminForm(None, None, {}, {}, joe)
parent_ct = ContentType.objects.get_for_model(Parent)
self.assertEqual(iaf.original.content_type, parent_ct)
|
'Ensure that the "Add another XXX" link correctly adds items to the
stacked formset.'
| def test_add_stackeds(self):
| self.admin_login(username=u'super', password=u'secret')
self.selenium.get((u'%s%s' % (self.live_server_url, u'/admin/admin_inlines/holder4/add/')))
inline_id = u'#inner4stacked_set-group'
rows_length = (lambda : len(self.selenium.find_elements_by_css_selector((u'%s .dynamic-inner4stacked_set' % inline_id))))
self.assertEqual(rows_length(), 3)
add_button = self.selenium.find_element_by_link_text(u'Add another Inner4 Stacked')
add_button.click()
self.assertEqual(rows_length(), 4)
|
'Ensure that the "Add another XXX" link correctly adds items to the
inline form.'
| def test_add_inlines(self):
| from selenium.common.exceptions import TimeoutException
self.admin_login(username=u'super', password=u'secret')
self.selenium.get((u'%s%s' % (self.live_server_url, u'/admin/admin_inlines/profilecollection/add/')))
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set')), 1)
self.assertEqual(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set')[0].get_attribute(u'id'), u'profile_set-0')
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set#profile_set-0 input[name=profile_set-0-first_name]')), 1)
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set#profile_set-0 input[name=profile_set-0-last_name]')), 1)
self.selenium.find_element_by_link_text(u'Add another Profile').click()
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set')), 2)
self.assertEqual(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set')[1].get_attribute(u'id'), u'profile_set-1')
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set#profile_set-1 input[name=profile_set-1-first_name]')), 1)
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set#profile_set-1 input[name=profile_set-1-last_name]')), 1)
self.selenium.find_element_by_link_text(u'Add another Profile').click()
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set')), 3)
self.assertEqual(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set')[2].get_attribute(u'id'), u'profile_set-2')
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set#profile_set-2 input[name=profile_set-2-first_name]')), 1)
self.assertEqual(len(self.selenium.find_elements_by_css_selector(u'.dynamic-profile_set#profile_set-2 input[name=profile_set-2-last_name]')), 1)
self.selenium.find_element_by_name(u'profile_set-0-first_name').send_keys(u'0 first name 1')
self.selenium.find_element_by_name(u'profile_set-0-last_name').send_keys(u'0 last name 2')
self.selenium.find_element_by_name(u'profile_set-1-first_name').send_keys(u'1 first name 1')
self.selenium.find_element_by_name(u'profile_set-1-last_name').send_keys(u'1 last name 2')
self.selenium.find_element_by_name(u'profile_set-2-first_name').send_keys(u'2 first name 1')
self.selenium.find_element_by_name(u'profile_set-2-last_name').send_keys(u'2 last name 2')
self.selenium.find_element_by_xpath(u'//input[@value="Save"]').click()
self.wait_page_loaded()
self.assertEqual(ProfileCollection.objects.all().count(), 1)
self.assertEqual(Profile.objects.all().count(), 3)
|
'Regression tests for #7314 and #7372'
| def test_regression_7314_7372(self):
| rm = RevisionableModel.objects.create(title=u'First Revision', when=datetime.datetime(2008, 9, 28, 10, 30, 0))
self.assertEqual(rm.pk, rm.base.pk)
rm2 = rm.new_revision()
rm2.title = u'Second Revision'
rm.when = datetime.datetime(2008, 9, 28, 14, 25, 0)
rm2.save()
self.assertEqual(rm2.title, u'Second Revision')
self.assertEqual(rm2.base.title, u'First Revision')
self.assertNotEqual(rm2.pk, rm.pk)
self.assertEqual(rm2.base.pk, rm.pk)
qs = RevisionableModel.objects.extra(where=[(u'%(table)s.id IN (SELECT MAX(rev.id) FROM %(table)s rev GROUP BY rev.base_id)' % {u'table': RevisionableModel._meta.db_table})])
self.assertQuerysetEqual(qs, [(u'Second Revision', u'First Revision')], transform=(lambda r: (r.title, r.base.title)))
qs2 = RevisionableModel.objects.filter(title__contains=u'Revision')
self.assertQuerysetEqual(qs2, [(u'First Revision', u'First Revision'), (u'Second Revision', u'First Revision')], transform=(lambda r: (r.title, r.base.title)))
self.assertQuerysetEqual((qs & qs2), [(u'Second Revision', u'First Revision')], transform=(lambda r: (r.title, r.base.title)))
|
'Regression test for #7957: Combining extra() calls should leave the
corresponding parameters associated with the right extra() bit. I.e.
internal dictionary must remain sorted.'
| def test_regression_7957(self):
| self.assertEqual(User.objects.extra(select={u'alpha': u'%s'}, select_params=(1,)).extra(select={u'beta': u'%s'}, select_params=(2,))[0].alpha, 1)
self.assertEqual(User.objects.extra(select={u'beta': u'%s'}, select_params=(1,)).extra(select={u'alpha': u'%s'}, select_params=(2,))[0].alpha, 2)
|
'Regression test for #7961: When not using a portion of an
extra(...) in a query, remove any corresponding parameters from the
query as well.'
| def test_regression_7961(self):
| self.assertEqual(list(User.objects.extra(select={u'alpha': u'%s'}, select_params=((-6),)).filter(id=self.u.id).values_list(u'id', flat=True)), [self.u.id])
|
'Regression test for #8063: limiting a query shouldn\'t discard any
extra() bits.'
| def test_regression_8063(self):
| qs = User.objects.all().extra(where=[u'id=%s'], params=[self.u.id])
self.assertQuerysetEqual(qs, [u'<User: fred>'])
self.assertQuerysetEqual(qs[:1], [u'<User: fred>'])
|
'Regression test for #8039: Ordering sometimes removed relevant tables
from extra(). This test is the critical case: ordering uses a table,
but then removes the reference because of an optimisation. The table
should still be present because of the extra() call.'
| def test_regression_8039(self):
| self.assertQuerysetEqual(Order.objects.extra(where=[u'username=%s'], params=[u'fred'], tables=[u'auth_user']).order_by(u'created_by'), [])
|
'Regression test for #8819: Fields in the extra(select=...) list
should be available to extra(order_by=...).'
| def test_regression_8819(self):
| self.assertQuerysetEqual(User.objects.filter(pk=self.u.id).extra(select={u'extra_field': 1}).distinct(), [u'<User: fred>'])
self.assertQuerysetEqual(User.objects.filter(pk=self.u.id).extra(select={u'extra_field': 1}, order_by=[u'extra_field']), [u'<User: fred>'])
self.assertQuerysetEqual(User.objects.filter(pk=self.u.id).extra(select={u'extra_field': 1}, order_by=[u'extra_field']).distinct(), [u'<User: fred>'])
|
'When calling the dates() method on a queryset with extra selection
columns, we can (and should) ignore those columns. They don\'t change
the result and cause incorrect SQL to be produced otherwise.'
| def test_dates_query(self):
| rm = RevisionableModel.objects.create(title=u'First Revision', when=datetime.datetime(2008, 9, 28, 10, 30, 0))
self.assertQuerysetEqual(RevisionableModel.objects.extra(select={u'the_answer': u'id'}).dates(u'when', u'month'), [u'datetime.datetime(2008, 9, 1, 0, 0)'])
|
'Regression test for #10256... If there is a values() clause, Extra
columns are only returned if they are explicitly mentioned.'
| def test_values_with_extra(self):
| obj = TestObject(first=u'first', second=u'second', third=u'third')
obj.save()
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values()), [{u'bar': u'second', u'third': u'third', u'second': u'second', u'whiz': u'third', u'foo': u'first', u'id': obj.pk, u'first': u'first'}])
self.assertEqual(list(TestObject.objects.values().extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third'))))), [{u'bar': u'second', u'third': u'third', u'second': u'second', u'whiz': u'third', u'foo': u'first', u'id': obj.pk, u'first': u'first'}])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values(u'first', u'second')), [{u'second': u'second', u'first': u'first'}])
self.assertEqual(list(TestObject.objects.values(u'first', u'second').extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third'))))), [{u'second': u'second', u'first': u'first'}])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values(u'first', u'second', u'foo')), [{u'second': u'second', u'foo': u'first', u'first': u'first'}])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values(u'foo', u'whiz')), [{u'foo': u'first', u'whiz': u'third'}])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list()), [(u'first', u'second', u'third', obj.pk, u'first', u'second', u'third')])
self.assertEqual(list(TestObject.objects.values_list().extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third'))))), [(u'first', u'second', u'third', obj.pk, u'first', u'second', u'third')])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'first', u'second')), [(u'first', u'second')])
self.assertEqual(list(TestObject.objects.values_list(u'first', u'second').extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third'))))), [(u'first', u'second')])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'second', flat=True)), [u'second'])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'first', u'second', u'whiz')), [(u'first', u'second', u'third')])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'foo', u'whiz')), [(u'first', u'third')])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'whiz', flat=True)), [u'third'])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'whiz', u'foo')), [(u'third', u'first')])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'first', u'id')), [(u'first', obj.pk)])
self.assertEqual(list(TestObject.objects.extra(select=SortedDict(((u'foo', u'first'), (u'bar', u'second'), (u'whiz', u'third')))).values_list(u'whiz', u'first', u'bar', u'id')), [(u'third', u'first', u'second', obj.pk)])
|
'Regression for #10847: the list of extra columns can always be
accurately evaluated. Using an inner query ensures that as_sql() is
producing correct output without requiring full evaluation and
execution of the inner query.'
| def test_regression_10847(self):
| obj = TestObject(first=u'first', second=u'second', third=u'third')
obj.save()
self.assertEqual(list(TestObject.objects.extra(select={u'extra': 1}).values(u'pk')), [{u'pk': obj.pk}])
self.assertQuerysetEqual(TestObject.objects.filter(pk__in=TestObject.objects.extra(select={u'extra': 1}).values(u'pk')), [u'<TestObject: TestObject: first,second,third>'])
self.assertEqual(list(TestObject.objects.values(u'pk').extra(select={u'extra': 1})), [{u'pk': obj.pk}])
self.assertQuerysetEqual(TestObject.objects.filter(pk__in=TestObject.objects.values(u'pk').extra(select={u'extra': 1})), [u'<TestObject: TestObject: first,second,third>'])
self.assertQuerysetEqual((TestObject.objects.filter(pk=obj.pk) | TestObject.objects.extra(where=[u'id > %s'], params=[obj.pk])), [u'<TestObject: TestObject: first,second,third>'])
|
'Ensure that extra WHERE clauses get correctly ANDed, even when they
contain OR operations.'
| def test_regression_17877(self):
| t = TestObject(first=u'a', second=u'a', third=u'a')
t.save()
t = TestObject(first=u'b', second=u'a', third=u'a')
t.save()
t = TestObject(first=u'a', second=u'a', third=u'b')
t.save()
t = TestObject(first=u'b', second=u'a', third=u'b')
t.save()
t = TestObject(first=u'b', second=u'b', third=u'a')
t.save()
t = TestObject(first=u'a', second=u'b', third=u'b')
t.save()
self.assertQuerysetEqual(TestObject.objects.extra(where=[u"first = 'a' OR second = 'a'", u"third = 'a'"]), [u'<TestObject: TestObject: a,a,a>', u'<TestObject: TestObject: b,a,a>'])
|
'This is a regression test for ticket #3790.'
| def test_duplicate_pk(self):
| management.call_command(u'loaddata', u'sequence', verbosity=0, commit=False)
animal = Animal(name=u'Platypus', latin_name=u'Ornithorhynchus anatinus', count=2, weight=2.2)
animal.save()
self.assertGreater(animal.id, 1)
|
'Test for ticket #9279 -- Error is raised for entries in
the serialised data for fields that have been removed
from the database when not ignored.'
| def test_loaddata_not_found_fields_not_ignore(self):
| with self.assertRaises(DeserializationError):
management.call_command(u'loaddata', u'sequence_extra', verbosity=0)
|
'Test for ticket #9279 -- Ignores entries in
the serialised data for fields that have been removed
from the database.'
| def test_loaddata_not_found_fields_ignore(self):
| management.call_command(u'loaddata', u'sequence_extra', ignore=True, verbosity=0, commit=False)
self.assertEqual(Animal.specimens.all()[0].name, u'Lion')
|
'Regression test for ticket #4558 -- pretty printing of XML fixtures
doesn\'t affect parsing of None values.'
| @skipIfDBFeature(u'interprets_empty_strings_as_nulls')
def test_pretty_print_xml(self):
| management.call_command(u'loaddata', u'pretty.xml', verbosity=0, commit=False)
self.assertEqual(Stuff.objects.all()[0].name, None)
self.assertEqual(Stuff.objects.all()[0].owner, None)
|
'Regression test for ticket #4558 -- pretty printing of XML fixtures
doesn\'t affect parsing of None values.'
| @skipUnlessDBFeature(u'interprets_empty_strings_as_nulls')
def test_pretty_print_xml_empty_strings(self):
| management.call_command(u'loaddata', u'pretty.xml', verbosity=0, commit=False)
self.assertEqual(Stuff.objects.all()[0].name, u'')
self.assertEqual(Stuff.objects.all()[0].owner, None)
|
'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.'
| def test_absolute_path(self):
| load_absolute_path = os.path.join(os.path.dirname(upath(__file__)), u'fixtures', u'absolute.json')
management.call_command(u'loaddata', load_absolute_path, verbosity=0, commit=False)
self.assertEqual(Absolute.load_count, 1)
|
'Test for ticket #4371 -- Loading data of an unknown format should fail
Validate that error conditions are caught correctly'
| def test_unknown_format(self):
| with six.assertRaisesRegex(self, management.CommandError, u"Problem installing fixture 'bad_fixture1': unkn is not a known serialization format."):
management.call_command(u'loaddata', u'bad_fixture1.unkn', verbosity=0, commit=False)
|
'Test that failing serializer import raises the proper error'
| @override_settings(SERIALIZATION_MODULES={u'unkn': u'unexistent.path'})
def test_unimportable_serializer(self):
| with six.assertRaisesRegex(self, ImportError, u'No module named.*unexistent'):
management.call_command(u'loaddata', u'bad_fixture1.unkn', verbosity=0, commit=False)
|
'Test for ticket #4371 -- Loading a fixture file with invalid data
using explicit filename.
Validate that error conditions are caught correctly'
| def test_invalid_data(self):
| with six.assertRaisesRegex(self, management.CommandError, u"No fixture data found for 'bad_fixture2'. \\(File format may be invalid.\\)"):
management.call_command(u'loaddata', u'bad_fixture2.xml', verbosity=0, commit=False)
|
'Test for ticket #4371 -- Loading a fixture file with invalid data
without file extension.
Validate that error conditions are caught correctly'
| def test_invalid_data_no_ext(self):
| with six.assertRaisesRegex(self, management.CommandError, u"No fixture data found for 'bad_fixture2'. \\(File format may be invalid.\\)"):
management.call_command(u'loaddata', u'bad_fixture2', verbosity=0, commit=False)
|
'Test for ticket #4371 -- Loading a fixture file with no data returns an error.
Validate that error conditions are caught correctly'
| def test_empty(self):
| with six.assertRaisesRegex(self, management.CommandError, u"No fixture data found for 'empty'. \\(File format may be invalid.\\)"):
management.call_command(u'loaddata', u'empty', verbosity=0, commit=False)
|
'(Regression for #9011 - error message is correct)'
| def test_error_message(self):
| with six.assertRaisesRegex(self, management.CommandError, u"^No fixture data found for 'bad_fixture2'. \\(File format may be invalid.\\)$"):
management.call_command(u'loaddata', u'bad_fixture2', u'animal', verbosity=0, commit=False)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.