desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'sign/unsign should be reversible'
| def test_sign_unsign(self):
| signer = signing.Signer('predictable-secret')
examples = ('q;wjmbk;wkmb', '3098247529087', '3098247:529:087:', 'jkw osanteuh ,rcuh nthu aou oauh ,ud du', u'\u2019')
for example in examples:
self.assertNotEqual(force_unicode(example), force_unicode(signer.sign(example)))
... |
'unsign should raise an exception if the value has been tampered with'
| def unsign_detects_tampering(self):
| signer = signing.Signer('predictable-secret')
value = 'Another string'
signed_value = signer.sign(value)
transforms = ((lambda s: s.upper()), (lambda s: (s + 'a')), (lambda s: ('a' + s[1:])), (lambda s: s.replace(':', '')))
self.assertEqual(value, signer.unsign(signed_value))
for transform in... |
'dumps and loads be reversible for any JSON serializable object'
| def test_dumps_loads(self):
| objects = (['a', 'list'], 'a string', u'a unicode string \u2019', {'a': 'dictionary'})
for o in objects:
self.assertNotEqual(o, signing.dumps(o))
self.assertEqual(o, signing.loads(signing.dumps(o)))
|
'loads should raise exception for tampered objects'
| def test_decode_detects_tampering(self):
| transforms = ((lambda s: s.upper()), (lambda s: (s + 'a')), (lambda s: ('a' + s[1:])), (lambda s: s.replace(':', '')))
value = {'foo': 'bar', 'baz': 1}
encoded = signing.dumps(value)
self.assertEqual(value, signing.loads(encoded))
for transform in transforms:
self.assertRaises(signing.BadSig... |
'RegexURLResolver should raise an exception when no urlpatterns exist.'
| def test_no_urls_exception(self):
| resolver = RegexURLResolver('^$', self.urls)
self.assertRaisesMessage(ImproperlyConfigured, "The included urlconf regressiontests.urlpatterns_reverse.no_urls doesn't have any patterns in it", getattr, resolver, 'url_patterns')
|
'Verifies that we raise a Resolver404 if what we are resolving doesn\'t
meet the basic requirements of a path to match - i.e., at the very
least, it matches the root pattern \'^/\'. We must never return None
from resolve, or we will get a TypeError further down the line.
Regression for #10834.'
| def test_non_regex(self):
| self.assertRaises(Resolver404, resolve, '')
self.assertRaises(Resolver404, resolve, 'a')
self.assertRaises(Resolver404, resolve, '\\')
self.assertRaises(Resolver404, resolve, '.')
|
'Verifies that the list of URLs that come back from a Resolver404
exception contains a list in the right format for printing out in
the DEBUG 404 page with both the patterns and URL names, if available.'
| def test_404_tried_urls_have_names(self):
| urls = 'regressiontests.urlpatterns_reverse.named_urls'
url_types_names = [[{'type': RegexURLPattern, 'name': 'named-url1'}], [{'type': RegexURLPattern, 'name': 'named-url2'}], [{'type': RegexURLPattern, 'name': None}], [{'type': RegexURLResolver}, {'type': RegexURLPattern, 'name': 'named-url3'}], [{'type': Reg... |
'Names deployed via dynamic URL objects that require namespaces can\'t be resolved'
| def test_ambiguous_object(self):
| self.assertRaises(NoReverseMatch, reverse, 'urlobject-view')
self.assertRaises(NoReverseMatch, reverse, 'urlobject-view', args=[37, 42])
self.assertRaises(NoReverseMatch, reverse, 'urlobject-view', kwargs={'arg1': 42, 'arg2': 37})
|
'Names deployed via dynamic URL objects that require namespaces can\'t be resolved'
| def test_ambiguous_urlpattern(self):
| self.assertRaises(NoReverseMatch, reverse, 'inner-nothing')
self.assertRaises(NoReverseMatch, reverse, 'inner-nothing', args=[37, 42])
self.assertRaises(NoReverseMatch, reverse, 'inner-nothing', kwargs={'arg1': 42, 'arg2': 37})
|
'Non-existent namespaces raise errors'
| def test_non_existent_namespace(self):
| self.assertRaises(NoReverseMatch, reverse, 'blahblah:urlobject-view')
self.assertRaises(NoReverseMatch, reverse, 'test-ns1:blahblah:urlobject-view')
|
'Normal lookups work as expected'
| def test_normal_name(self):
| self.assertEqual('/normal/', reverse('normal-view'))
self.assertEqual('/normal/37/42/', reverse('normal-view', args=[37, 42]))
self.assertEqual('/normal/42/37/', reverse('normal-view', kwargs={'arg1': 42, 'arg2': 37}))
self.assertEqual('/+%5C$*/', reverse('special-view'))
|
'Normal lookups work on names included from other patterns'
| def test_simple_included_name(self):
| self.assertEqual('/included/normal/', reverse('inc-normal-view'))
self.assertEqual('/included/normal/37/42/', reverse('inc-normal-view', args=[37, 42]))
self.assertEqual('/included/normal/42/37/', reverse('inc-normal-view', kwargs={'arg1': 42, 'arg2': 37}))
self.assertEqual('/included/+%5C$*/', reverse(... |
'Dynamic URL objects can be found using a namespace'
| def test_namespace_object(self):
| self.assertEqual('/test1/inner/', reverse('test-ns1:urlobject-view'))
self.assertEqual('/test1/inner/37/42/', reverse('test-ns1:urlobject-view', args=[37, 42]))
self.assertEqual('/test1/inner/42/37/', reverse('test-ns1:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
self.assertEqual('/test1/inner/+%5... |
'Namespaces can be installed anywhere in the URL pattern tree'
| def test_embedded_namespace_object(self):
| self.assertEqual('/included/test3/inner/', reverse('test-ns3:urlobject-view'))
self.assertEqual('/included/test3/inner/37/42/', reverse('test-ns3:urlobject-view', args=[37, 42]))
self.assertEqual('/included/test3/inner/42/37/', reverse('test-ns3:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
self.as... |
'Namespaces can be applied to include()\'d urlpatterns'
| def test_namespace_pattern(self):
| self.assertEqual('/ns-included1/normal/', reverse('inc-ns1:inc-normal-view'))
self.assertEqual('/ns-included1/normal/37/42/', reverse('inc-ns1:inc-normal-view', args=[37, 42]))
self.assertEqual('/ns-included1/normal/42/37/', reverse('inc-ns1:inc-normal-view', kwargs={'arg1': 42, 'arg2': 37}))
self.asser... |
'When using a include with namespaces when there is a regex variable in front of it'
| def test_namespace_pattern_with_variable_prefix(self):
| self.assertEqual('/ns-outer/42/normal/', reverse('inc-outer:inc-normal-view', kwargs={'outer': 42}))
self.assertEqual('/ns-outer/42/normal/', reverse('inc-outer:inc-normal-view', args=[42]))
self.assertEqual('/ns-outer/42/normal/37/4/', reverse('inc-outer:inc-normal-view', kwargs={'outer': 42, 'arg1': 37, '... |
'Namespaces can be embedded'
| def test_multiple_namespace_pattern(self):
| self.assertEqual('/ns-included1/test3/inner/', reverse('inc-ns1:test-ns3:urlobject-view'))
self.assertEqual('/ns-included1/test3/inner/37/42/', reverse('inc-ns1:test-ns3:urlobject-view', args=[37, 42]))
self.assertEqual('/ns-included1/test3/inner/42/37/', reverse('inc-ns1:test-ns3:urlobject-view', kwargs={'... |
'Namespaces can be nested'
| def test_nested_namespace_pattern(self):
| self.assertEqual('/ns-included1/ns-included4/ns-included1/test3/inner/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view'))
self.assertEqual('/ns-included1/ns-included4/ns-included1/test3/inner/37/42/', reverse('inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view', args=[37, 42]))
self.assertEqual('/ns... |
'A default application namespace can be used for lookup'
| def test_app_lookup_object(self):
| self.assertEqual('/default/inner/', reverse('testapp:urlobject-view'))
self.assertEqual('/default/inner/37/42/', reverse('testapp:urlobject-view', args=[37, 42]))
self.assertEqual('/default/inner/42/37/', reverse('testapp:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
self.assertEqual('/default/inne... |
'A default application namespace is sensitive to the \'current\' app can be used for lookup'
| def test_app_lookup_object_with_default(self):
| self.assertEqual('/included/test3/inner/', reverse('testapp:urlobject-view', current_app='test-ns3'))
self.assertEqual('/included/test3/inner/37/42/', reverse('testapp:urlobject-view', args=[37, 42], current_app='test-ns3'))
self.assertEqual('/included/test3/inner/42/37/', reverse('testapp:urlobject-view', ... |
'An application namespace without a default is sensitive to the \'current\' app can be used for lookup'
| def test_app_lookup_object_without_default(self):
| self.assertEqual('/other2/inner/', reverse('nodefault:urlobject-view'))
self.assertEqual('/other2/inner/37/42/', reverse('nodefault:urlobject-view', args=[37, 42]))
self.assertEqual('/other2/inner/42/37/', reverse('nodefault:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
self.assertEqual('/other2/in... |
'Namespace prefixes can capture variables: see #15900'
| def test_namespaces_with_variables(self):
| self.assertEqual('/inc70/', reverse('inc-ns5:inner-nothing', kwargs={'outer': '70'}))
self.assertEqual('/inc78/extra/foobar/', reverse('inc-ns5:inner-extra', kwargs={'outer': '78', 'extra': 'foobar'}))
self.assertEqual('/inc70/', reverse('inc-ns5:inner-nothing', args=['70']))
self.assertEqual('/inc78/ex... |
'If the urls.py doesn\'t specify handlers, the defaults are used'
| def test_default_handler(self):
| try:
response = self.client.get('/test/')
self.assertEqual(response.status_code, 404)
except AttributeError:
self.fail("Shouldn't get an AttributeError due to undefined 404 handler")
try:
self.assertRaises(ValueError, self.client.get, '/bad_view/')
... |
'Test that ModelMultipleChoiceField does O(1) queries instead of
O(n) (#10156).'
| def test_model_multiple_choice_number_of_queries(self):
| persons = [Person.objects.create(name=('Person %s' % i)) for i in range(30)]
f = forms.ModelMultipleChoiceField(queryset=Person.objects.all())
self.assertNumQueries(1, f.clean, [p.pk for p in persons[1:11:2]])
|
'Test that ModelMultipleChoiceField run given validators (#14144).'
| def test_model_multiple_choice_run_validators(self):
| for i in range(30):
Person.objects.create(name=('Person %s' % i))
self._validator_run = False
def my_validator(value):
self._validator_run = True
f = forms.ModelMultipleChoiceField(queryset=Person.objects.all(), validators=[my_validator])
f.clean([p.pk for p in Person.objects.all(... |
'When the same field is involved in multiple unique_together
constraints, we need to make sure we don\'t remove the data for it
before doing all the validation checking (not just failing after
the first one).'
| def test_multiple_field_unique_together(self):
| Triple.objects.create(left=1, middle=2, right=3)
form = TripleForm({'left': '1', 'middle': '2', 'right': '3'})
self.assertFalse(form.is_valid())
form = TripleForm({'left': '1', 'middle': '3', 'right': '1'})
self.assertTrue(form.is_valid())
|
'Regression for #12596: Calling super from ModelForm.clean() should be
optional.'
| def test_override_clean(self):
| form = TripleFormWithCleanOverride({'left': 1, 'middle': 2, 'right': 1})
self.assertTrue(form.is_valid())
self.assertEqual(form.instance.left, 1)
|
'Regression test for #8842: FilePathField(blank=True)'
| def test_file_path_field_blank(self):
| form = FPForm()
names = [p[1] for p in form['path'].field.choices]
names.sort()
self.assertEqual(names, ['---------', '__init__.py', 'models.py', 'tests.py'])
|
'Regression for #10349: A callable can be provided as the initial value for an m2m field'
| def test_callable(self):
| def formfield_for_dbfield(db_field, **kwargs):
if (db_field.name == 'publications'):
kwargs['initial'] = (lambda : Publication.objects.all().order_by('date_published')[:2])
return db_field.formfield(**kwargs)
book1 = Publication.objects.create(title='First Book', date_published=da... |
'Regression for #11149: save_form_data should be called only once'
| def test_save(self):
| form = CFFForm(data={'f': None})
form.save()
|
'Check basic URL field validation on model forms'
| def test_url_on_modelform(self):
| self.assertFalse(HomepageForm({'url': 'foo'}).is_valid())
self.assertFalse(HomepageForm({'url': 'http://'}).is_valid())
self.assertFalse(HomepageForm({'url': 'http://example'}).is_valid())
self.assertFalse(HomepageForm({'url': 'http://example.'}).is_valid())
self.assertFalse(HomepageForm({'url': 'ht... |
'If the http:// prefix is omitted on form input, the field adds it again. (Refs #13613)'
| def test_http_prefixing(self):
| form = HomepageForm({'url': 'example.com'})
form.is_valid()
form = HomepageForm({'url': 'example.com/test'})
form.is_valid()
|
'Regression for #13095: Using base forms with widgets defined in Meta should not raise errors.'
| def test_baseform_with_widgets_in_meta(self):
| widget = forms.Textarea()
class BaseForm(forms.ModelForm, ):
class Meta:
model = Person
widgets = {'name': widget}
Form = modelform_factory(Person, form=BaseForm)
self.assertTrue((Form.base_fields['name'].widget is widget))
|
'Regression for #15315: modelform_factory should accept widgets
argument'
| def test_factory_with_widget_argument(self):
| widget = forms.Textarea()
Form = modelform_factory(Person)
self.assertNotEqual(Form.base_fields['name'].widget.__class__, forms.Textarea)
Form = modelform_factory(Person, widgets={'name': widget})
self.assertEqual(Form.base_fields['name'].widget.__class__, forms.Textarea)
|
'Test that a custom formfield_callback is used if provided'
| def test_custom_callback(self):
| callback_args = []
def callback(db_field, **kwargs):
callback_args.append((db_field, kwargs))
return db_field.formfield(**kwargs)
widget = forms.Textarea()
class BaseForm(forms.ModelForm, ):
class Meta:
model = Person
widgets = {'name': widget}
_ = mod... |
'If the ``clean`` method on a non-required FileField receives False as
the data (meaning clear the field value), it returns False, regardless
of the value of ``initial``.'
| def test_clean_false(self):
| f = forms.FileField(required=False)
self.assertEqual(f.clean(False), False)
self.assertEqual(f.clean(False, 'initial'), False)
|
'If the ``clean`` method on a required FileField receives False as the
data, it has the same effect as None: initial is returned if non-empty,
otherwise the validation catches the lack of a required value.'
| def test_clean_false_required(self):
| f = forms.FileField(required=True)
self.assertEqual(f.clean(False, 'initial'), 'initial')
self.assertRaises(ValidationError, f.clean, False)
|
'Integration happy-path test that a model FileField can actually be set
and cleared via a ModelForm.'
| def test_full_clear(self):
| form = DocumentForm()
self.assertTrue(('name="myfile"' in unicode(form)))
self.assertTrue(('myfile-clear' not in unicode(form)))
form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')})
self.assertTrue(form.is_valid())
doc = form.save(commit=False)
self.assertEqu... |
'If the user submits a new file upload AND checks the clear checkbox,
they get a validation error, and the bound redisplay of the form still
includes the current file and the clear checkbox.'
| def test_clear_and_file_contradiction(self):
| form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')})
self.assertTrue(form.is_valid())
doc = form.save(commit=False)
form = DocumentForm(instance=doc, files={'myfile': SimpleUploadedFile('something.txt', 'content')}, data={'myfile-clear': 'true'})
self.assertTrue((not... |
'An argument of fields=() to fields_for_model should return an empty dictionary'
| def test_empty_fields_to_fields_for_model(self):
| field_dict = fields_for_model(Person, fields=())
self.assertEqual(len(field_dict), 0)
|
'No fields on a ModelForm should actually result in no fields'
| def test_empty_fields_on_modelform(self):
| form = self.EmptyPersonForm()
self.assertEqual(len(form.fields), 0)
|
'No fields should be set on a model instance if construct_instance receives fields=()'
| def test_empty_fields_to_construct_instance(self):
| form = modelform_factory(Person)({'name': 'John Doe'})
self.assertTrue(form.is_valid())
instance = construct_instance(form, Person(), fields=())
self.assertEqual(instance.name, '')
|
'This test is related to the above one, testing that there aren\'t
old JOINs in the query.'
| def test_order_by_join_unref(self):
| qs = Celebrity.objects.order_by('greatest_fan__fan_of')
self.assertIn('OUTER JOIN', str(qs.query))
qs = qs.order_by('id')
self.assertNotIn('OUTER JOIN', str(qs.query))
|
'Ensure that Meta.ordering=None works the same as Meta.ordering=[]'
| def test_ticket17429(self):
| original_ordering = Tag._meta.ordering
Tag._meta.ordering = None
self.assertQuerysetEqual(Tag.objects.all(), ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'])
Tag._meta.ordering = original_ordering
|
'Subselects honor any manual ordering'
| def test_ordered_subselect(self):
| try:
query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[0:2])
self.assertEqual(set(query.values_list('id', flat=True)), set([2, 3]))
query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[:2])
self.assertEqual(set(query.values_lis... |
'Delete queries can safely contain sliced subqueries'
| def test_sliced_delete(self):
| try:
DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[0:1]).delete()
self.assertEqual(set(DumbCategory.objects.values_list('id', flat=True)), set([1, 2]))
except DatabaseError:
self.assertFalse(connections[DEFAULT_DB_ALIAS].features.allow_sliced_subqueries)
|
'#13227 -- If a queryset is already evaluated, it can still be used as a query arg'
| def test_evaluated_queryset_as_argument(self):
| n = Note(note='Test1', misc='misc')
n.save()
e = ExtraInfo(info='good', note=n)
e.save()
n_list = Note.objects.all()
list(n_list)
try:
self.assertEqual(ExtraInfo.objects.filter(note__in=n_list)[0].info, 'good')
except:
self.fail('Query should be clonable')
|
'Test QueryDict with one key/value pair'
| def test_single_key_value(self):
| q = QueryDict('foo=bar')
self.assertEqual(q['foo'], 'bar')
self.assertRaises(KeyError, q.__getitem__, 'bar')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('foo', 'default'), 'bar')
self.assertEqual(q.get('bar', 'default'), 'default')
self.assertE... |
'A copy of a QueryDict is mutable.'
| def test_mutable_copy(self):
| q = QueryDict('').copy()
self.assertRaises(KeyError, q.__getitem__, 'foo')
q['name'] = 'john'
self.assertEqual(q['name'], 'john')
|
'Test QueryDict with two key/value pairs with same keys.'
| def test_multiple_keys(self):
| q = QueryDict('vote=yes&vote=no')
self.assertEqual(q['vote'], u'no')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('vote', 'default'), u'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), [u'yes', u'no'])
... |
'QueryDicts must be able to handle invalid input encoding (in this
case, bad UTF-8 encoding).'
| def test_invalid_input_encoding(self):
| q = QueryDict('foo=bar&foo=\xff')
self.assertEqual(q['foo'], u'\ufffd')
self.assertEqual(q.getlist('foo'), [u'bar', u'\ufffd'])
|
'Regression test for #8278: QueryDict.update(QueryDict)'
| def test_update_from_querydict(self):
| x = QueryDict('a=1&a=2', mutable=True)
y = QueryDict('a=3&a=4')
x.update(y)
self.assertEqual(x.getlist('a'), [u'1', u'2', u'3', u'4'])
|
'#13572 - QueryDict with a non-default encoding'
| def test_non_default_encoding(self):
| q = QueryDict('sbb=one', encoding='rot_13')
self.assertEqual(q.encoding, 'rot_13')
self.assertEqual(q.items(), [(u'foo', u'bar')])
self.assertEqual(q.urlencode(), 'sbb=one')
q = q.copy()
self.assertEqual(q.encoding, 'rot_13')
self.assertEqual(q.items(), [(u'foo', u'bar')])
self.assertEqu... |
'Test for bug #14020: Make HttpResponse.get work like dict.get'
| def test_dict_behavior(self):
| r = HttpResponse()
self.assertEqual(r.get('test'), None)
|
'Test that we don\'t output tricky characters in encoded value'
| def test_encode(self):
| c = SimpleCookie()
c['test'] = 'An,awkward;value'
self.assertTrue((';' not in c.output().rstrip(';')))
self.assertTrue((',' not in c.output().rstrip(';')))
|
'Test that we can still preserve semi-colons and commas'
| def test_decode(self):
| c = SimpleCookie()
c['test'] = 'An,awkward;value'
c2 = SimpleCookie()
c2.load(c.output())
self.assertEqual(c['test'].value, c2['test'].value)
|
'Test that we haven\'t broken normal encoding'
| def test_decode_2(self):
| c = SimpleCookie()
c['test'] = '\xf0'
c2 = SimpleCookie()
c2.load(c.output())
self.assertEqual(c['test'].value, c2['test'].value)
|
'Test that a single non-standard cookie name doesn\'t affect all cookies. Ticket #13007.'
| def test_nonstandard_keys(self):
| self.assertTrue(('good_cookie' in parse_cookie('good_cookie=yes;bad:cookie=yes').keys()))
|
'Test that a repeated non-standard name doesn\'t affect all cookies. Ticket #15852'
| def test_repeated_nonstandard_keys(self):
| self.assertTrue(('good_cookie' in parse_cookie('a,=b; a,=c; good_cookie=yes').keys()))
|
'Test that we can use httponly attribute on cookies that we load'
| def test_httponly_after_load(self):
| c = SimpleCookie()
c.load('name=val')
c['name']['httponly'] = True
self.assertTrue(c['name']['httponly'])
|
'Tests that django decorators set certain attributes of the wrapped
function.'
| def test_attributes(self):
| self.assertEqual(fully_decorated.__name__, 'fully_decorated')
self.assertEqual(fully_decorated.__doc__, 'Expected __doc__')
self.assertEqual(fully_decorated.__dict__['anything'], 'Expected __dict__')
|
'Test that the user_passes_test decorator can be applied multiple times
(#9474).'
| def test_user_passes_test_composition(self):
| def test1(user):
user.decorators_applied.append('test1')
return True
def test2(user):
user.decorators_applied.append('test2')
return True
def callback(request):
return request.user.decorators_applied
callback = user_passes_test(test1)(callback)
callback = user... |
'Test that we can call cache_page the new way'
| def test_cache_page_new_style(self):
| def my_view(request):
return 'response'
my_view_cached = cache_page(123)(my_view)
self.assertEqual(my_view_cached(HttpRequest()), 'response')
my_view_cached2 = cache_page(123, key_prefix='test')(my_view)
self.assertEqual(my_view_cached2(HttpRequest()), 'response')
|
'Test that we can call cache_page the old way'
| def test_cache_page_old_style(self):
| def my_view(request):
return 'response'
my_view_cached = cache_page(my_view, 123)
self.assertEqual(my_view_cached(HttpRequest()), 'response')
my_view_cached2 = cache_page(my_view, 123, key_prefix='test')
self.assertEqual(my_view_cached2(HttpRequest()), 'response')
my_view_cached3 = cache... |
'Test for the require_safe decorator.
A view returns either a response or an exception.
Refs #15637.'
| def test_require_safe_accepts_only_safe_methods(self):
| def my_view(request):
return HttpResponse('OK')
my_safe_view = require_safe(my_view)
request = HttpRequest()
request.method = 'GET'
self.assertTrue(isinstance(my_safe_view(request), HttpResponse))
request.method = 'HEAD'
self.assertTrue(isinstance(my_safe_view(request), HttpResponse)... |
'Ensures @xframe_options_deny properly sets the X-Frame-Options header.'
| def test_deny_decorator(self):
| @xframe_options_deny
def a_view(request):
return HttpResponse()
r = a_view(HttpRequest())
self.assertEqual(r['X-Frame-Options'], 'DENY')
|
'Ensures @xframe_options_sameorigin properly sets the X-Frame-Options
header.'
| def test_sameorigin_decorator(self):
| @xframe_options_sameorigin
def a_view(request):
return HttpResponse()
r = a_view(HttpRequest())
self.assertEqual(r['X-Frame-Options'], 'SAMEORIGIN')
|
'Ensures @xframe_options_exempt properly instructs the
XFrameOptionsMiddleware to NOT set the header.'
| def test_exempt_decorator(self):
| @xframe_options_exempt
def a_view(request):
return HttpResponse()
req = HttpRequest()
resp = a_view(req)
self.assertEqual(resp.get('X-Frame-Options', None), None)
self.assertTrue(resp.xframe_options_exempt)
r = XFrameOptionsMiddleware().process_response(req, resp)
self.assertEqua... |
'Test the custom ``django_date_trunc method``, in particular against
fields which clash with strings passed to it (e.g. \'year\') - see
#12818__.
__: http://code.djangoproject.com/ticket/12818'
| def test_django_date_trunc(self):
| updated = datetime.datetime(2010, 2, 20)
models.SchoolClass.objects.create(year=2009, last_updated=updated)
years = models.SchoolClass.objects.dates('last_updated', 'year')
self.assertEqual(list(years), [datetime.datetime(2010, 1, 1, 0, 0)])
|
'Test the custom ``django_extract method``, in particular against fields
which clash with strings passed to it (e.g. \'day\') - see #12818__.
__: http://code.djangoproject.com/ticket/12818'
| def test_django_extract(self):
| updated = datetime.datetime(2010, 2, 20)
models.SchoolClass.objects.create(year=2009, last_updated=updated)
classes = models.SchoolClass.objects.filter(last_updated__day=20)
self.assertEqual(len(classes), 1)
|
'An executemany call with too many/not enough parameters will raise an exception (Refs #12612)'
| def test_bad_parameter_count(self):
| cursor = connection.cursor()
query = ('INSERT INTO %s (%s, %s) VALUES (%%s, %%s)' % (connection.introspection.table_name_converter('backends_square'), connection.ops.quote_name('root'), connection.ops.quote_name('square')))
self.assertRaises(Exception, cursor.executemany, query, [(1, 2,... |
'Test creation of model with long name and long pk name doesn\'t error. Ref #8901'
| @skipUnlessDBFeature('supports_long_model_names')
def test_sequence_name_length_limits_create(self):
| models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
|
'Test an m2m save of a model with a long name and a long m2m field name doesn\'t error as on Django >=1.2 this now uses object saves. Ref #8901'
| @skipUnlessDBFeature('supports_long_model_names')
def test_sequence_name_length_limits_m2m(self):
| obj = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
rel_obj = models.Person.objects.create(first_name='Django', last_name='Reinhardt')
obj.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.add(rel_obj)
|
'Test that sequence resetting as part of a flush with model with long name and long pk name doesn\'t error. Ref #8901'
| @skipUnlessDBFeature('supports_long_model_names')
def test_sequence_name_length_limits_flush(self):
| VLM = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
VLM_m2m = VLM.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.through
tables = [VLM._meta.db_table, VLM_m2m._meta.db_table]
sequences = [{'column': VLM._meta.pk.column, 'table': VLM._meta.db_table}]
c... |
'Sequence names are correct when resetting generic relations (Ref #13941)'
| def test_generic_relation(self):
| models.Post.objects.create(id=10, name='1st post', text='hello world')
cursor = connection.cursor()
commands = connections[DEFAULT_DB_ALIAS].ops.sequence_reset_sql(no_style(), [models.Post])
for sql in commands:
cursor.execute(sql)
obj = models.Post.objects.create(name='New post', t... |
'Test PostgreSQL version parsing from `SELECT version()` output'
| def test_parsing(self):
| self.assert_parses('PostgreSQL 8.3 beta4', 80300)
self.assert_parses('PostgreSQL 8.3', 80300)
self.assert_parses('EnterpriseDB 8.3', 80300)
self.assert_parses('PostgreSQL 8.3.6', 80306)
self.assert_parses('PostgreSQL 8.4beta1', 80400)
self.assert_parses('PostgreSQL 8.3.1 ... |
'Test PostgreSQL version detection'
| def test_version_detection(self):
| class CursorMock(object, ):
'Very simple mock of DB-API cursor'
def execute(self, arg):
pass
def fetchone(self):
return ['PostgreSQL 8.3']
class OlderConnectionMock(object, ):
'Mock of psycopg2 (< 2.0.12) connection'
... |
'Test that creating an existing table returns a DatabaseError'
| def test_duplicate_table_error(self):
| cursor = connection.cursor()
query = ('CREATE TABLE %s (id INTEGER);' % models.Article._meta.db_table)
with self.assertRaises(DatabaseError):
cursor.execute(query)
|
'Try to create a model instance that violates a FK constraint. If it
fails it should fail with IntegrityError.'
| def test_integrity_checks_on_creation(self):
| a = models.Article(headline='This is a test', pub_date=datetime.datetime(2005, 7, 27), reporter_id=30)
try:
a.save()
except IntegrityError:
return
self.skipTest('This backend does not support integrity checks.')
|
'Try to update a model instance introducing a FK constraint violation.
If it fails it should fail with IntegrityError.'
| def test_integrity_checks_on_update(self):
| models.Article.objects.create(headline='Test article', pub_date=datetime.datetime(2010, 9, 4), reporter=self.r)
a = models.Article.objects.get(headline='Test article')
a.reporter_id = 30
try:
a.save()
except IntegrityError:
return
self.skipTest('This backend does n... |
'When constraint checks are disabled, should be able to write bad data without IntegrityErrors.'
| def test_disable_constraint_checks_manually(self):
| with transaction.commit_manually():
models.Article.objects.create(headline='Test article', pub_date=datetime.datetime(2010, 9, 4), reporter=self.r)
a = models.Article.objects.get(headline='Test article')
a.reporter_id = 30
try:
connection.disable_constraint_checking... |
'When constraint checks are disabled (using context manager), should be able to write bad data without IntegrityErrors.'
| def test_disable_constraint_checks_context_manager(self):
| with transaction.commit_manually():
models.Article.objects.create(headline='Test article', pub_date=datetime.datetime(2010, 9, 4), reporter=self.r)
a = models.Article.objects.get(headline='Test article')
a.reporter_id = 30
try:
with connection.constraint_checks_disa... |
'Constraint checks should raise an IntegrityError when bad data is in the DB.'
| def test_check_constraints(self):
| with transaction.commit_manually():
models.Article.objects.create(headline='Test article', pub_date=datetime.datetime(2010, 9, 4), reporter=self.r)
a = models.Article.objects.get(headline='Test article')
a.reporter_id = 30
try:
with connection.constraint_checks_disa... |
'Ensure that the default connection (i.e. django.db.connection) is
different for each thread.
Refs #17258.'
| def test_default_connection_thread_local(self):
| connections_set = set()
connection.cursor()
connections_set.add(connection.connection)
def runner():
from django.db import connection
connection.cursor()
connections_set.add(connection.connection)
for x in xrange(2):
t = threading.Thread(target=runner)
t.start... |
'Ensure that the connections are different for each thread.
Refs #17258.'
| def test_connections_thread_local(self):
| connections_set = set()
for conn in connections.all():
connections_set.add(conn)
def runner():
from django.db import connections
for conn in connections.all():
conn.allow_thread_sharing = True
connections_set.add(conn)
for x in xrange(2):
t = threa... |
'Ensure that a connection can be passed from one thread to the other.
Refs #17258.'
| def test_pass_connection_between_threads(self):
| models.Person.objects.create(first_name='John', last_name='Doe')
def do_thread():
def runner(main_thread_connection):
from django.db import connections
connections['default'] = main_thread_connection
try:
models.Person.objects.get(first_name='John', la... |
'Ensure that a connection that is not explicitly shareable cannot be
closed by another thread.
Refs #17258.'
| def test_closing_non_shared_connections(self):
| exceptions = set()
def runner1():
def runner2(other_thread_connection):
try:
other_thread_connection.close()
except DatabaseError as e:
exceptions.add(e)
t2 = threading.Thread(target=runner2, args=[connections['default']])
t2.start(... |
'Regression test for the use of None as a query value.
None is interpreted as an SQL NULL, but only in __exact queries.
Set up some initial polls and choices'
| def test_none_as_null(self):
| p1 = Poll(question='Why?')
p1.save()
c1 = Choice(poll=p1, choice='Because.')
c1.save()
c2 = Choice(poll=p1, choice='Why Not?')
c2.save()
self.assertQuerysetEqual(Choice.objects.filter(choice__exact=None), [])
self.assertQuerysetEqual(Choice.objects.exclude(choice=None).order_by('id'),... |
'Querying across reverse relations and then another relation should
insert outer joins correctly so as not to exclude results.'
| def test_reverse_relations(self):
| obj = OuterA.objects.create()
self.assertQuerysetEqual(OuterA.objects.filter(inner__second=None), ['<OuterA: OuterA object>'])
self.assertQuerysetEqual(OuterA.objects.filter(inner__second__data=None), ['<OuterA: OuterA object>'])
inner_obj = Inner.objects.create(first=obj)
self.assertQue... |
'Tests that URLs that look like absolute file paths after the
settings.STATIC_URL don\'t turn into absolute file paths.'
| def test_media_urls(self):
| data = ((('%scss/base.css' % self.admin_media_url), ('css', 'base.css')),)
bad_data = ()
if (os.sep == '/'):
data += ((('%s\\css/base.css' % self.admin_media_url), ('\\css', 'base.css')),)
bad_data += (('%s/css/base.css' % self.admin_media_url), ('%s///css/base.css' % self.admin_media_url), ... |
'Ensure that the LiveServerTestCase serves 404s.
Refs #2879.'
| def test_404(self):
| try:
self.urlopen('/')
except urllib2.HTTPError as err:
self.assertEquals(err.code, 404, 'Expected 404 response')
else:
self.fail('Expected 404 response')
|
'Ensure that the LiveServerTestCase serves views.
Refs #2879.'
| def test_view(self):
| f = self.urlopen('/example_view/')
self.assertEquals(f.read(), 'example view')
|
'Ensure that the LiveServerTestCase serves static files.
Refs #2879.'
| def test_static_files(self):
| f = self.urlopen('/static/example_static_file.txt')
self.assertEquals(f.read(), 'example static file\n')
|
'Ensure that the LiveServerTestCase serves media files.
Refs #2879.'
| def test_media_files(self):
| f = self.urlopen('/media/example_media_file.txt')
self.assertEquals(f.read(), 'example media file\n')
|
'Ensure that fixtures are properly loaded and visible to the
live server thread.
Refs #2879.'
| def test_fixtures_loaded(self):
| f = self.urlopen('/model_view/')
self.assertEquals(f.read().splitlines(), ['jane', 'robert'])
|
'Ensure that data written to the database by a view can be read.
Refs #2879.'
| def test_database_writes(self):
| self.urlopen('/create_model_instance/')
names = [person.name for person in Person.objects.all()]
self.assertEquals(names, ['jane', 'robert', 'emily'])
|
'If you leave off the trailing slash, app should redirect and add it.'
| def testTrailingSlashRequired(self):
| request = self.client.get(('/test_admin/%s/admin_views/article/add' % self.urlbit))
self.assertRedirects(request, ('/test_admin/%s/admin_views/article/add/' % self.urlbit), status_code=301)
|
'A smoke test to ensure GET on the add_view works.'
| def testBasicAddGet(self):
| response = self.client.get(('/test_admin/%s/admin_views/section/add/' % self.urlbit))
self.assertIsInstance(response, TemplateResponse)
self.assertEqual(response.status_code, 200)
|
'A smoke test to ensure GET on the change_view works.'
| def testBasicEditGet(self):
| response = self.client.get(('/test_admin/%s/admin_views/section/1/' % self.urlbit))
self.assertIsInstance(response, TemplateResponse)
self.assertEqual(response.status_code, 200)
|
'A smoke test to ensure GET on the change_view works (returns an HTTP
404 error, see #11191) when passing a string as the PK argument for a
model with an integer PK field.'
| def testBasicEditGetStringPK(self):
| response = self.client.get(('/test_admin/%s/admin_views/section/abc/' % self.urlbit))
self.assertEqual(response.status_code, 404)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.