desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Check that if the token is longer than expected, it is ignored and
a new token is created.'
| def test_process_view_token_too_long(self):
| req = self._get_GET_no_csrf_cookie_request()
req.COOKIES[settings.CSRF_COOKIE_NAME] = ('x' * 10000000)
CsrfViewMiddleware().process_view(req, token_view, (), {})
resp = token_view(req)
resp2 = CsrfViewMiddleware().process_response(req, resp)
csrf_cookie = resp2.cookies.get(settings.CSRF_COOKIE_N... |
'When get_token is used, check that the cookie is created and headers
patched.'
| def test_process_response_get_token_used(self):
| req = self._get_GET_no_csrf_cookie_request()
with self.settings(CSRF_COOKIE_NAME='myname', CSRF_COOKIE_DOMAIN='.example.com', CSRF_COOKIE_PATH='/test/', CSRF_COOKIE_SECURE=True):
CsrfViewMiddleware().process_view(req, token_view, (), {})
resp = token_view(req)
resp2 = CsrfViewMiddleware(... |
'Check that if get_token() is not called, the view middleware does not
add a cookie.'
| def test_process_response_get_token_not_used(self):
| req = self._get_GET_no_csrf_cookie_request()
CsrfViewMiddleware().process_view(req, non_token_view_using_request_processor, (), {})
resp = non_token_view_using_request_processor(req)
resp2 = CsrfViewMiddleware().process_response(req, resp)
csrf_cookie = resp2.cookies.get(settings.CSRF_COOKIE_NAME, F... |
'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['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 = 'PUT'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEqual(403, req2.status_code)
req = TestingHttpRequest()
req.method = 'DELETE'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertEq... |
'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 = 'PUT'
req.META['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 = 'DELETE'
req.META['HTTP_X_CS... |
'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(u'', 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'
| def test_https_bad_referer(self):
| req = self._get_POST_request_with_token()
req._is_secure_override = True
req.META['HTTP_HOST'] = 'www.example.com'
req.META['HTTP_REFERER'] = 'https://www.evil.org/somepage'
req2 = CsrfViewMiddleware().process_view(req, post_form_view, (), {})
self.assertNotEqual(None, req2)
self.assertEqual... |
'Test that a POST HTTPS request with a good referer is accepted'
| def test_https_good_referer(self):
| req = self._get_POST_request_with_token()
req._is_secure_override = True
req.META['HTTP_HOST'] = 'www.example.com'
req.META['HTTP_REFERER'] = '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'
| def test_https_good_referer_2(self):
| req = self._get_POST_request_with_token()
req._is_secure_override = True
req.META['HTTP_HOST'] = 'www.example.com'
req.META['HTTP_REFERER'] = '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='')
req = self._get_GET_no_csrf_cookie_request()
resp = view(req)
self.assertTrue(resp.cookies.get(settings.CSRF_COOKIE_NAME, False))
self.assertTrue(('Cookie' in resp.get('Vary', '')))
|
'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='')
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(setting... |
'Year boundary tests (ticket #3689)'
| def test_year_boundaries(self):
| d = Donut.objects.create(name='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='Date Test 2006', baked_date=datetime.datetime(year=2006, month=1, day=... |
'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, unicode))
|
'Regression test for #8354: the MySQL and Oracle backends should raise
an error if given a timezone-aware datetime object.'
| @skipIfDBFeature('supports_timezones')
def test_error_on_timezone(self):
| dt = datetime.datetime(2008, 8, 31, 16, 20, tzinfo=utc)
d = Donut(name='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='Foo1')
f1.save()
f2 = Foo(name='Foo2')
f2.save()
w1 = Whiz(name='Whiz1')
w1.save()
b1 = Bar(name='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='Base... |
'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='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='Test', text='The quick brown fox jumps over the lazy dog.')
a.save()
self.assertEqual(Article.objects.get(text__exact='The quick brown fox jumps over the lazy dog.'), a)
self.assertEqual(Article.objects.get(text__contains='quick brown ... |
'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='IP test', text='The body', submitted_from='192.0.2.100')
a.save()
self.assertEqual(repr(Article.objects.filter(submitted_from__contains='192.0.2')), repr([a]))
|
'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.assertTrue((len(connection.queries) < 10))
self.assertEqual(TwoFields.objects.count(), 1000)
... |
'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('contact').annotate(Max('id'))
qs = qs.order_by('contact').values_list('id__max', flat=True)
books = Book.objects.order_by('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('contact').annotate(Max('id'))
qs = qs.order_by('contact').values_list('id__max', flat=True)
list(qs)
books = Book.objects.order_by('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('supports_subqueries_in_group_by')
def test_annotate_with_extra(self):
| shortest_book_sql = '\n SELECT name\n FROM aggregation_regress_book b\n WHERE b.publisher_id = aggregation_regress_publisher.id\n ORDER BY b.pages\n ... |
'Introspection of column names consist/start with digits (#16536/#17676)'
| def test_digits_column_name_introspection(self):
| out = StringIO()
call_command('inspectdb', stdout=out)
error_message = 'inspectdb generated a model field name which is a number'
self.assertNotIn(' 123 = models.CharField', out.getvalue(), msg=error_message)
self.assertIn('number_123 = models.Ch... |
'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, ... |
'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(RestrictedM... |
'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('nonsense')
with self.assertRaises(KeyError):
serializers.get_serializer('nonsense')
with self.assertRaises(SerializerDoesNotExist) as cm:
serializers.get_serializer('nonsense')
self.assertEqual(cm.excepti... |
'Test that the get_*_display() methods are added to the model instances.'
| def test_get_display_methods(self):
| place = self.form.save()
self.assertEqual(place.get_state_display(), 'Georgia')
self.assertEqual(place.get_state_req_display(), 'North Carolina')
|
'Test that required USStateFields throw appropriate errors.'
| def test_required(self):
| form = USPlaceForm({'state': 'GA', 'name': 'Place in GA'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['state_req'], [u'This field is required.'])
|
'Test that the empty option is there.'
| def test_field_blank_option(self):
| state_select_html = '<select name="state" id="id_state">\n<option value="">---------</option>\n<option value="AL">Alabama</option>\n<option value="AK">Alaska</option>\n<option value="AS">American Samoa</option>\n<option value="AZ">Arizona</option>\n<option value="AR">Arkansas</option>\n<o... |
'Test that the full USPS code field is really the full list.'
| def test_full_postal_code_list(self):
| usps_select_html = '<select name="postal_code" id="id_postal_code">\n<option value="">---------</option>\n<option value="AL">Alabama</option>\n<option value="AK">Alaska</option>\n<option value="AS">American Samoa</option>\n<option value="AZ">Arizona</option>\n<option value="AR">Arkansas</... |
'Test that the get_*_display() methods are added to the model instances.'
| def test_get_display_methods(self):
| place = self.form.save()
self.assertEqual(place.get_state_display(), u'Michoac\xe1n')
|
'Test that required MXFields throw appropriate errors.'
| def test_errors(self):
| form = MXPersonProfileForm({'state': 'Invalid state', 'rfc': 'invalid rfc', 'curp': 'invalid curp', 'zip_code': 'xxx'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['state'], [u'Select a valid choice. Invalid state is not one of the available ch... |
'Test that the empty option is there.'
| def test_field_blank_option(self):
| state_select_html = '<select name="state" id="id_state">\n<option value="">---------</option>\n<option value="AGU">Aguascalientes</option>\n<option value="BCN">Baja California</option>\n<option value="BCS">Baja California Sur</option>\n<option value="CAM">Campeche</option>\n<option ... |
'Test that the get_*_display() methods are added to the model instances.'
| def test_get_display_methods(self):
| person = self.form.save()
self.assertEqual(person.get_municipality_display(), 'Ohrid')
self.assertEqual(person.get_municipality_req_display(), 'Veles')
|
'Test that required MKMunicipalityFields throw appropriate errors.'
| def test_municipality_required(self):
| form = MKPersonForm({'first_name': 'Someone', 'last_name': 'Something', 'umcn': '2402983450006', 'municipality': 'OD', 'id_number': 'A1234567'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['municipality_req'], [u'This field is required.'])
|
'Test that UMCNFields throw appropriate errors for invalid UMCNs.'
| def test_umcn_invalid(self):
| form = MKPersonForm({'first_name': 'Someone', 'last_name': 'Something', 'umcn': '2402983450007', 'municipality': 'OD', 'municipality_req': 'VE', 'id_number': 'A1234567'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['umcn'], [u'The UMCN is not valid.'])
form = MKPersonForm(... |
'Test that MKIdentityCardNumberFields throw
appropriate errors for invalid values'
| def test_idnumber_invalid(self):
| form = MKPersonForm({'first_name': 'Someone', 'last_name': 'Something', 'umcn': '2402983450007', 'municipality': 'OD', 'municipality_req': 'VE', 'id_number': 'A123456a'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['id_number'], [u'Identity card numbers must contain either ... |
'Test that the empty option is there.'
| def test_field_blank_option(self):
| municipality_select_html = '<select name="municipality" id="id_municipality">\n<option value="">---------</option>\n<option value="AD">Aerodrom</option>\n<option value="AR">Ara\xc4\x8dinovo</option>\n<option value="BR">Berovo</option>\n<option value="TL">Bitola</option>\n<option value="BG">B... |
'Ensure get_*_display() methods are added to model instances.'
| def test_get_display_methods(self):
| place = self.form.save()
self.assertEqual(place.get_state_display(), 'Western Australia')
self.assertEqual(place.get_state_required_display(), 'Queensland')
|
'Ensure that default values are selected in forms.'
| def test_default_values(self):
| form = AustralianPlaceForm()
self.assertTrue(re.search((SELECTED_OPTION_PATTERN % 'NSW'), str(form['state_default'])))
self.assertTrue(re.search((INPUT_VALUE_PATTERN % '2500'), str(form['postcode_default'])))
|
'Test that required AUStateFields throw appropriate errors.'
| def test_required(self):
| form = AustralianPlaceForm({'state': 'NSW', 'name': 'Wollongong'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['state_required'], [u'This field is required.'])
self.assertEqual(form.errors['postcode_required'], [u'This field is required.'])
|
'Test that the empty option is there.'
| def test_field_blank_option(self):
| self.assertTrue(re.search(BLANK_OPTION_PATTERN, str(self.form['state'])))
|
'Ensure selected states match the initial values provided.'
| def test_selected_values(self):
| self.assertTrue(re.search((SELECTED_OPTION_PATTERN % 'WA'), str(self.form['state'])))
self.assertTrue(re.search((SELECTED_OPTION_PATTERN % 'QLD'), str(self.form['state_required'])))
self.assertTrue(re.search((INPUT_VALUE_PATTERN % '1234'), str(self.form['postcode'])))
self.assertTrue(re.search((INPUT_VA... |
'Rendering a template response triggers the post-render callbacks'
| def test_post_callbacks(self):
| post = []
def post1(obj):
post.append('post1')
def post2(obj):
post.append('post2')
response = SimpleTemplateResponse('first/test.html', {})
response.add_post_render_callback(post1)
response.add_post_render_callback(post2)
response.render()
self.assertEqual('First temp... |
'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('{% load custom %}{% inclusion_tag_current_app %}')
self.assertEqual(t.render(c).strip(), u'None')
c.current_app = '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('{% 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 = 'test_include_error.html'
r = None
try:
tmpl = loader.select_template([lo... |
'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 = 'test_extends_error.html'
tmpl = loader.get_template(load_name)
r = None
try:... |
'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(('',))
cache_loader._cached_loaders = (app_directories.Loader(),)
loader.template_source_loaders = (cache_loader,)
load_name = 't... |
'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({'coconuts': (lambda : (42 / 0))})
t = Template('{{ 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, {'var': 'parent'})
self.assertEqual(template.Template('{% include "child" %}').render(ctx), 'parent')
self.assertEqual(template.Template('{% include "child" only %}').render(ctx), '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(__file__), 'templates', 'first'),))
(t2, name) = loader.find_template('test.html', (os.path.join(os.path.dirname(__file__), 'templates', 'second'),))
self.assertNotEqual(t1.render(Context({})), t2.render(Context({})))
|
'can_delete should be passed to inlineformset factory.'
| def test_can_delete(self):
| response = self.client.get(self.change_url)
inner_formset = response.context['inline_admin_formsets'][0].formset
expected = InnerInline.can_delete
actual = inner_formset.can_delete
self.assertEqual(expected, actual, '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='')
response = self.client.get(('/admin/admin_inlines/holder/%i/' % holder.id))
self.assertContains(response, '<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('/admin/admin_inlines/author/add/')
self.assertContains(response, '<h2>Author-book relationships</h2>')
self.assertContains(response, 'Add another Author-Book Relationship')
self.assertContains(response, '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 = {'title_set-TOTAL_FORMS': 1, 'title_set-INITIAL_FORMS': 0, 'title_set-MAX_NUM_FORMS': 0, '_save': u'Save', 'title_set-0-title1': 'a title', 'title_set-0-title2': 'a different title'}
response = self.client.post('/admin/admin_inlines/titlecollection/add/', data)
self.assertContains(response, ... |
'Admin inline `readonly_field` shouldn\'t invoke parent ModelAdmin callable'
| def test_no_parent_callable_lookup(self):
| response = self.client.get('/admin/admin_inlines/novel/add/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, '<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('/admin/admin_inlines/poll/add/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, '<div class="inline-group" id="question_set-group">')
self.assertContains(response, '<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('/admin/admin_inlines/holder4/add/')
self.assertContains(response, '<p class="help">Awesome stacked help text is awesome.</p>', 4)
self.assertContains(response, '<img src="/static/admin/img/icon-unknown.gif" class="help help-tooltip" width="10" hei... |
'Ensure that multiple inlines with related_name=\'+\' have correct form
prefixes. Bug #16838.'
| def test_non_related_name_inline(self):
| response = self.client.get('/admin/admin_inlines/capofamiglia/add/')
self.assertContains(response, '<input type="hidden" name="-1-0-id" id="id_-1-0-id" />')
self.assertContains(response, '<input type="hidden" name="-1-0-capo_famiglia" id="id_-1-0-capo_famiglia" />')
self.assertCo... |
'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='Sally')
john = Parent.objects.create(name='John')
joe = Child.objects.create(name='Joe', teacher=sally, parent=john)
iaf = InlineAdminForm(None, None, {}, {}, joe)
parent_ct = ContentType.objects.get_for_model(Parent)
self.assertEqual(iaf.original.content_typ... |
'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='super', password='secret')
self.selenium.get(('%s%s' % (self.live_server_url, '/admin/admin_inlines/profilecollection/add/')))
self.failUnlessEqual(len(self.selenium.find_elements_by_css_selector('.dynamic-profile_set')),... |
'Regression tests for #7314 and #7372'
| def test_regression_7314_7372(self):
| rm = RevisionableModel.objects.create(title='First Revision', when=datetime.datetime(2008, 9, 28, 10, 30, 0))
self.assertEqual(rm.pk, rm.base.pk)
rm2 = rm.new_revision()
rm2.title = 'Second Revision'
rm.when = datetime.datetime(2008, 9, 28, 14, 25, 0)
rm2.save()
self.assertEqual(rm2.ti... |
'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={'alpha': '%s'}, select_params=(1,)).extra(select={'beta': '%s'}, select_params=(2,))[0].alpha, 1)
self.assertEqual(User.objects.extra(select={'beta': '%s'}, select_params=(1,)).extra(select={'alpha': '%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={'alpha': '%s'}, select_params=((-6),)).filter(id=self.u.id).values_list('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=['id=%s'], params=[self.u.id])
self.assertQuerysetEqual(qs, ['<User: fred>'])
self.assertQuerysetEqual(qs[:1], ['<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=['username=%s'], params=['fred'], tables=['auth_user']).order_by('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={'extra_field': 1}).distinct(), ['<User: fred>'])
self.assertQuerysetEqual(User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}, order_by=['extra_field']), ['<User: fred>'])
self.assertQuerysetEqual(User.objects.filte... |
'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='First Revision', when=datetime.datetime(2008, 9, 28, 10, 30, 0))
self.assertQuerysetEqual(RevisionableModel.objects.extra(select={'the_answer': 'id'}).dates('when', 'month'), ['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='first', second='second', third='third')
obj.save()
self.assertEqual(list(TestObject.objects.extra(select=SortedDict((('foo', 'first'), ('bar', 'second'), ('whiz', 'third')))).values()), [{'bar': u'second', 'third': u'third', 'second': u'second', 'whiz': u'third', 'foo': u'first', 'id... |
'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='first', second='second', third='third')
obj.save()
self.assertEqual(list(TestObject.objects.extra(select={'extra': 1}).values('pk')), [{'pk': obj.pk}])
self.assertQuerysetEqual(TestObject.objects.filter(pk__in=TestObject.objects.extra(select={'extra': 1}).values('pk')), ['<TestOb... |
'This is a regression test for ticket #3790.'
| def test_duplicate_pk(self):
| management.call_command('loaddata', 'sequence', verbosity=0, commit=False)
animal = Animal(name='Platypus', latin_name='Ornithorhynchus anatinus', count=2, weight=2.2)
animal.save()
self.assertGreater(animal.id, 1)
|
'Regression test for ticket #4558 -- pretty printing of XML fixtures
doesn\'t affect parsing of None values.'
| @skipIfDBFeature('interprets_empty_strings_as_nulls')
def test_pretty_print_xml(self):
| 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)
|
'Regression test for ticket #4558 -- pretty printing of XML fixtures
doesn\'t affect parsing of None values.'
| @skipUnlessDBFeature('interprets_empty_strings_as_nulls')
def test_pretty_print_xml_empty_strings(self):
| 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)
|
'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(__file__), 'fixtures', 'absolute.json')
management.call_command('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):
| 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")
|
'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):
| 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")
|
'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):
| 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")
|
'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):
| 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")
|
'Test for ticket #4371 -- If any of the fixtures contain an error,
loading is aborted.
Validate that error conditions are caught correctly'
| def test_abort_loaddata_on_error(self):
| 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")
|
'(Regression for #9011 - error message is correct)'
| def test_error_message(self):
| 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")
|
'Test for ticket #7565 -- PostgreSQL sequence resetting checks shouldn\'t
ascend to parent models when inheritance is used
(since they are treated individually).'
| def test_pg_sequence_resetting_checks(self):
| 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)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.