desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Each EnumValue instance should have same hash as its value.'
| def test_hash_equal(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
instance = params['values'][key]
self.failUnlessEqual(hash(i), hash(instance))
|
'Different EnumValue instances should have different hashes.'
| def test_hash_unequal(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
instance = params['values'][key]
for (j, other_key) in enumerate(params['keys']):
if (i == j):
continue
other_instance = params['values'][other_key]
self.failIfEqual(hash(instance), hash(other_instance))
|
'Comparison method should have matching name for attribute.'
| def test_comparison_method_has_matching_name(self):
| for compare_func in compare_functions:
func_name = compare_func.__name__
expect_name = func_name
compare_method = getattr(enum.EnumValue, func_name)
self.failUnlessEqual(expect_name, compare_method.__name__)
|
'Comparison method should have docstring.'
| def test_comparison_method_has_docstring(self):
| for compare_func in compare_functions:
func_name = compare_func.__name__
compare_method = getattr(enum.EnumValue, func_name)
self.failUnless(isinstance(compare_method.__doc__, basestring))
|
'An EnumValue should compare equal to its value.'
| def test_compare_equal(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
instance = params['values'][key]
self.failUnlessEqual(instance, enum.EnumValue(enumtype, i, key))
|
'An EnumValue should compare different to other values.'
| def test_compare_unequal(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
instance = params['values'][key]
self.failIfEqual(instance, enum.EnumValue(enumtype, None, None))
|
'EnumValue instances should compare as their sequence order.'
| def test_compare_sequence(self):
| for (enumtype, params) in self.valid_values.items():
for (i, left_key) in enumerate(params['keys']):
for (j, right_key) in enumerate(params['keys']):
for compare_func in compare_functions:
self.failUnlessEqual(compare_func(i, j), compare_func(params['values'][left_key], enum.EnumValue(enumtype, j, right_key)))
|
'An EnumValue should not implement comparison to other enums.'
| def test_compare_different_enum(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
for compare_func in compare_functions:
instance = params['values'][key]
test_value = enum.EnumValue(self.SimpleEnum, i, key)
compare_method = getattr(instance, compare_func.__name__)
compare_result = compare_method(test_value)
self.failUnlessEqual(NotImplemented, compare_result)
|
'An EnumValue should not implement comparison to other types.'
| def test_compare_non_enum(self):
| test_value = enum.EnumValue(self.SimpleEnum, 0, 'test')
for other_value in self.other_values:
for compare_func in compare_functions:
compare_method = getattr(test_value, compare_func.__name__)
compare_result = compare_method(other_value)
self.failUnlessEqual(NotImplemented, compare_result)
|
'An EnumValue should compare inequal to values of other enums.'
| def test_compare_equality_different_enum(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
instance = params['values'][key]
test_value = enum.EnumValue(self.SimpleEnum, i, key)
self.failIfEqual(test_value, instance)
|
'An EnumValue should compare inequal to any other value.'
| def test_compare_equality_non_enum(self):
| test_value = enum.EnumValue(self.SimpleEnum, 0, 'test')
for other_value in self.other_values:
self.failIfEqual(test_value, other_value)
|
'An EnumValue should compare sequentially to other values.'
| def test_sequence_other_values(self):
| test_value = enum.EnumValue(self.SimpleEnum, 0, 'test')
test_list = list(self.other_values)
test_list.append(test_value)
test_list.sort()
self.failUnless((test_value in test_list))
|
'An EnumValue should have the specified key.'
| def test_value_key(self):
| for (enumtype, params) in self.valid_values.items():
for (key, instance) in params['values'].items():
self.failUnlessEqual(key, instance.key)
|
'An EnumValue should have its associated enumtype.'
| def test_value_enumtype(self):
| for (enumtype, params) in self.valid_values.items():
for (key, instance) in params['values'].items():
self.failUnlessEqual(enumtype, instance.enumtype)
|
'Set up the test fixtures.'
| def setUp(self):
| setup_enum_value_fixtures(self)
|
'Enum constructor should refuse empty keys sequence.'
| def test_empty_enum(self):
| self.failUnlessRaises(enum.EnumEmptyError, enum.Enum)
|
'Enum constructor should refuse non-string keys.'
| def test_bad_key(self):
| for key in self.bad_keys:
args = ('valid', key, 'valid')
self.failUnlessRaises(enum.EnumBadKeyError, enum.Enum, *args)
|
'Enumeration should have attributes for each value.'
| def test_value_attributes(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
instance = getattr(enumtype, key)
test_value = enum.EnumValue(enumtype, i, key)
self.failUnlessEqual(test_value, instance)
|
'Enumeration should have length of its value set.'
| def test_length(self):
| for (enumtype, params) in self.valid_values.items():
self.failUnlessEqual(len(params['values']), len(enumtype))
|
'Enumeration should have items for each value.'
| def test_value_items(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
value = enumtype[i]
test_value = enum.EnumValue(enumtype, i, key)
self.failUnlessEqual(test_value, value)
|
'Enumeration class should iterate over its values.'
| def test_iterable(self):
| for (enumtype, params) in self.valid_values.items():
for (i, value) in enumerate(enumtype):
key = params['keys'][i]
test_value = params['values'][key]
self.failUnlessEqual(value, test_value)
|
'Enumeration iteration should match specified sequence.'
| def test_iterate_sequence(self):
| for (enumtype, params) in self.valid_values.items():
values_dict = params['values']
values_seq = [values_dict[key] for key in params['keys']]
enum_seq = [val for val in enumtype]
self.failUnlessEqual(values_seq, enum_seq)
self.failIfEqual(values_seq.reverse(), enum_seq)
|
'Enumeration should not contain bogus values.'
| def test_membership_bogus(self):
| for (enumtype, params) in self.valid_values.items():
for value in self.other_values:
self.failIf((value in enumtype))
|
'Enumeration should contain explicit value.'
| def test_membership_value(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
value = params['values'][key]
self.failUnless((value in enumtype))
|
'Enumeration should contain key string.'
| def test_membership_key(self):
| for (enumtype, params) in self.valid_values.items():
for key in params['keys']:
self.failUnless((key in enumtype))
|
'Enumeration should refuse attribute addition.'
| def test_add_attribute(self):
| for (enumtype, params) in self.valid_values.items():
self.failUnlessRaises(enum.EnumImmutableError, setattr, enumtype, 'bogus', 'bogus')
|
'Enumeration should refuse attribute modification.'
| def test_modify_attribute(self):
| for (enumtype, params) in self.valid_values.items():
for key in params['keys']:
self.failUnlessRaises(enum.EnumImmutableError, setattr, enumtype, key, 'bogus')
|
'Enumeration should refuse attribute deletion.'
| def test_delete_attribute(self):
| for (enumtype, params) in self.valid_values.items():
for key in params['keys']:
self.failUnlessRaises(enum.EnumImmutableError, delattr, enumtype, key)
|
'Enumeration should refuse item addition.'
| def test_add_item(self):
| for (enumtype, params) in self.valid_values.items():
index = len(params['keys'])
self.failUnlessRaises(enum.EnumImmutableError, enumtype.__setitem__, index, 'bogus')
|
'Enumeration should refuse item modification.'
| def test_modify_item(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
self.failUnlessRaises(enum.EnumImmutableError, enumtype.__setitem__, i, 'bogus')
|
'Enumeration should refuse item deletion.'
| def test_delete_item(self):
| for (enumtype, params) in self.valid_values.items():
for (i, key) in enumerate(params['keys']):
self.failUnlessRaises(enum.EnumImmutableError, enumtype.__delitem__, i)
|
'Overriding a method on a super class and then calling that method on
the super class should not trigger infinite recursion. See #17011.'
| def test_max_recursion_error(self):
| try:
super(ClassDecoratedTestCase, self).test_max_recursion_error()
except RuntimeError:
self.fail()
|
'Allow deletion of a setting in an overriden settings set (#18824)'
| def test_override_settings_delete(self):
| previous_i18n = settings.USE_I18N
with self.settings(USE_I18N=False):
del settings.USE_I18N
self.assertRaises(AttributeError, getattr, settings, 'USE_I18N')
self.assertEqual(settings.USE_I18N, previous_i18n)
|
'ALLOWED_INCLUDE_ROOTS is not allowed to be incorrectly set to a string
rather than a tuple.'
| def test_allowed_include_roots_string(self):
| self.assertRaises(ValueError, setattr, settings, 'ALLOWED_INCLUDE_ROOTS', '/var/www/ssi/')
|
'The empty string is accepted, even though it doesn\'t end in a slash.'
| def test_blank(self):
| self.settings_module.MEDIA_URL = ''
self.assertEqual('', self.settings_module.MEDIA_URL)
self.settings_module.STATIC_URL = ''
self.assertEqual('', self.settings_module.STATIC_URL)
|
'It works if the value ends in a slash.'
| def test_end_slash(self):
| self.settings_module.MEDIA_URL = '/foo/'
self.assertEqual('/foo/', self.settings_module.MEDIA_URL)
self.settings_module.MEDIA_URL = 'http://media.foo.com/'
self.assertEqual('http://media.foo.com/', self.settings_module.MEDIA_URL)
self.settings_module.STATIC_URL = '/foo/'
self.assertEqual('/foo/', self.settings_module.STATIC_URL)
self.settings_module.STATIC_URL = 'http://static.foo.com/'
self.assertEqual('http://static.foo.com/', self.settings_module.STATIC_URL)
|
'An ImproperlyConfigured exception is raised if the value doesn\'t end
in a slash.'
| def test_no_end_slash(self):
| with self.assertRaises(ImproperlyConfigured):
self.settings_module.MEDIA_URL = '/foo'
with self.assertRaises(ImproperlyConfigured):
self.settings_module.MEDIA_URL = 'http://media.foo.com'
with self.assertRaises(ImproperlyConfigured):
self.settings_module.STATIC_URL = '/foo'
with self.assertRaises(ImproperlyConfigured):
self.settings_module.STATIC_URL = 'http://static.foo.com'
|
'If the value ends in more than one slash, presume they know what
they\'re doing.'
| def test_double_slash(self):
| self.settings_module.MEDIA_URL = '/stupid//'
self.assertEqual('/stupid//', self.settings_module.MEDIA_URL)
self.settings_module.MEDIA_URL = 'http://media.foo.com/stupid//'
self.assertEqual('http://media.foo.com/stupid//', self.settings_module.MEDIA_URL)
self.settings_module.STATIC_URL = '/stupid//'
self.assertEqual('/stupid//', self.settings_module.STATIC_URL)
self.settings_module.STATIC_URL = 'http://static.foo.com/stupid//'
self.assertEqual('http://static.foo.com/stupid//', self.settings_module.STATIC_URL)
|
'If the environment variable is set, do not ignore it. However, the
kwarg original_settings_path takes precedence.
This tests both plus the default (neither set).'
| def test_env_var_used(self):
| from django.core.management import setup_environ
original_module = os.environ.get('DJANGO_SETTINGS_MODULE', 'the default')
user_override = 'custom.settings'
orig_path = 'original.path'
setup_environ(global_settings)
self.assertEqual(os.environ.get('DJANGO_SETTINGS_MODULE'), original_module)
os.environ['DJANGO_SETTINGS_MODULE'] = user_override
setup_environ(global_settings)
self.assertEqual(os.environ.get('DJANGO_SETTINGS_MODULE'), user_override)
os.environ['DJANGO_SETTINGS_MODULE'] = user_override
setup_environ(global_settings, original_settings_path=orig_path)
self.assertEqual(os.environ.get('DJANGO_SETTINGS_MODULE'), orig_path)
|
'If ALLOWED_HOSTS is empty and DEBUG is True, all hosts pass.'
| @override_settings(DEBUG=True, ALLOWED_HOSTS=[])
def test_host_validation_disabled_in_debug_mode(self):
| request = HttpRequest()
request.META = {u'HTTP_HOST': u'example.com'}
self.assertEqual(request.get_host(), u'example.com')
|
'Cookie will expire when an near expiration time is provided'
| def test_near_expiration(self):
| response = HttpResponse()
expires = (datetime.utcnow() + timedelta(seconds=10))
time.sleep(0.001)
response.set_cookie(u'datetime', expires=expires)
datetime_cookie = response.cookies[u'datetime']
self.assertEqual(datetime_cookie[u'max-age'], 10)
|
'Cookie accepts an aware datetime as expiration time'
| def test_aware_expiration(self):
| response = HttpResponse()
expires = (datetime.utcnow() + timedelta(seconds=10)).replace(tzinfo=utc)
time.sleep(0.001)
response.set_cookie(u'datetime', expires=expires)
datetime_cookie = response.cookies[u'datetime']
self.assertEqual(datetime_cookie[u'max-age'], 10)
|
'Cookie will expire when an distant expiration time is provided'
| def test_far_expiration(self):
| response = HttpResponse()
response.set_cookie(u'datetime', expires=datetime(2028, 1, 1, 4, 5, 6))
datetime_cookie = response.cookies[u'datetime']
self.assertEqual(datetime_cookie[u'expires'], u'Sat, 01-Jan-2028 04:05:06 GMT')
|
'Cookie will expire if max_age is provided'
| def test_max_age_expiration(self):
| response = HttpResponse()
response.set_cookie(u'max_age', max_age=10)
max_age_cookie = response.cookies[u'max_age']
self.assertEqual(max_age_cookie[u'max-age'], 10)
self.assertEqual(max_age_cookie[u'expires'], cookie_date((time.time() + 10)))
|
'Reading from request is allowed after accessing request contents as
POST or body.'
| def test_read_after_value(self):
| payload = FakePayload(u'name=value')
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'application/x-www-form-urlencoded', u'CONTENT_LENGTH': len(payload), u'wsgi.input': payload})
self.assertEqual(request.POST, {u'name': [u'value']})
self.assertEqual(request.body, 'name=value')
self.assertEqual(request.read(), 'name=value')
|
'Construction of POST or body is not allowed after reading
from request.'
| def test_value_after_read(self):
| payload = FakePayload(u'name=value')
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'application/x-www-form-urlencoded', u'CONTENT_LENGTH': len(payload), u'wsgi.input': payload})
self.assertEqual(request.read(2), 'na')
self.assertRaises(Exception, (lambda : request.body))
self.assertEqual(request.POST, {})
|
'Test a POST with non-utf-8 payload encoding.'
| def test_alternate_charset_POST(self):
| from django.utils.http import urllib_parse
payload = FakePayload(urllib_parse.urlencode({u'key': u'Espa\xf1a'.encode(u'latin-1')}))
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_LENGTH': len(payload), u'CONTENT_TYPE': u'application/x-www-form-urlencoded; charset=iso-8859-1', u'wsgi.input': payload})
self.assertEqual(request.POST, {u'key': [u'Espa\xf1a']})
|
'Reading body after parsing multipart is not allowed'
| def test_body_after_POST_multipart(self):
| payload = FakePayload(u'\r\n'.join([u'--boundary', u'Content-Disposition: form-data; name="name"', u'', u'value', u'--boundary--']))
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'multipart/form-data; boundary=boundary', u'CONTENT_LENGTH': len(payload), u'wsgi.input': payload})
self.assertEqual(request.POST, {u'name': [u'value']})
self.assertRaises(Exception, (lambda : request.body))
|
'Multipart POST requests with Content-Length >= 0 are valid and need to be handled.'
| def test_POST_multipart_with_content_length_zero(self):
| payload = FakePayload(u'\r\n'.join([u'--boundary', u'Content-Disposition: form-data; name="name"', u'', u'value', u'--boundary--']))
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'multipart/form-data; boundary=boundary', u'CONTENT_LENGTH': 0, u'wsgi.input': payload})
self.assertEqual(request.POST, {})
|
'POST should be populated even if body is read first'
| def test_POST_after_body_read(self):
| payload = FakePayload(u'name=value')
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'application/x-www-form-urlencoded', u'CONTENT_LENGTH': len(payload), u'wsgi.input': payload})
raw_data = request.body
self.assertEqual(request.POST, {u'name': [u'value']})
|
'POST should be populated even if body is read first, and then
the stream is read second.'
| def test_POST_after_body_read_and_stream_read(self):
| payload = FakePayload(u'name=value')
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'application/x-www-form-urlencoded', u'CONTENT_LENGTH': len(payload), u'wsgi.input': payload})
raw_data = request.body
self.assertEqual(request.read(1), 'n')
self.assertEqual(request.POST, {u'name': [u'value']})
|
'POST should be populated even if body is read first, and then
the stream is read second. Using multipart/form-data instead of urlencoded.'
| def test_POST_after_body_read_and_stream_read_multipart(self):
| payload = FakePayload(u'\r\n'.join([u'--boundary', u'Content-Disposition: form-data; name="name"', u'', u'value', u'--boundary--']))
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'multipart/form-data; boundary=boundary', u'CONTENT_LENGTH': len(payload), u'wsgi.input': payload})
raw_data = request.body
self.assertEqual(request.read(13), '--boundary\r\nC')
self.assertEqual(request.POST, {u'name': [u'value']})
|
'HttpRequest.raw_post_body should be the same as HttpRequest.body'
| def test_raw_post_data_returns_body(self):
| payload = FakePayload(u'Hello There!')
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_LENGTH': len(payload), u'wsgi.input': payload})
with warnings.catch_warnings(record=True):
self.assertEqual(request.body, request.raw_post_data)
|
'If wsgi.input.read() raises an exception while trying to read() the
POST, the exception should be identifiable (not a generic IOError).'
| def test_POST_connection_error(self):
| class ExplodingBytesIO(BytesIO, ):
def read(self, len=0):
raise IOError(u'kaboom!')
payload = 'name=value'
request = WSGIRequest({u'REQUEST_METHOD': u'POST', u'CONTENT_TYPE': u'application/x-www-form-urlencoded', u'CONTENT_LENGTH': len(payload), u'wsgi.input': ExplodingBytesIO(payload)})
with self.assertRaises(UnreadablePostError):
request.body
|
'signature() method should generate a signature'
| def test_signature(self):
| signer = signing.Signer(u'predictable-secret')
signer2 = signing.Signer(u'predictable-secret2')
for s in ('hello', '3098247:529:087:', u'\u2019'.encode(u'utf-8')):
self.assertEqual(signer.signature(s), signing.base64_hmac((signer.salt + u'signer'), s, u'predictable-secret').decode())
self.assertNotEqual(signer.signature(s), signer2.signature(s))
|
'signature(value, salt=...) should work'
| def test_signature_with_salt(self):
| signer = signing.Signer(u'predictable-secret', salt=u'extra-salt')
self.assertEqual(signer.signature(u'hello'), signing.base64_hmac((u'extra-salt' + u'signer'), u'hello', u'predictable-secret').decode())
self.assertNotEqual(signing.Signer(u'predictable-secret', salt=u'one').signature(u'hello'), signing.Signer(u'predictable-secret', salt=u'two').signature(u'hello'))
|
'sign/unsign should be reversible'
| def test_sign_unsign(self):
| signer = signing.Signer(u'predictable-secret')
examples = [u'q;wjmbk;wkmb', u'3098247529087', u'3098247:529:087:', u'jkw osanteuh ,rcuh nthu aou oauh ,ud du', u'\u2019']
if (not six.PY3):
examples.append('a byte string')
for example in examples:
signed = signer.sign(example)
self.assertIsInstance(signed, str)
self.assertNotEqual(force_str(example), signed)
self.assertEqual(example, signer.unsign(signed))
|
'unsign should raise an exception if the value has been tampered with'
| def unsign_detects_tampering(self):
| signer = signing.Signer(u'predictable-secret')
value = u'Another string'
signed_value = signer.sign(value)
transforms = ((lambda s: s.upper()), (lambda s: (s + u'a')), (lambda s: (u'a' + s[1:])), (lambda s: s.replace(u':', u'')))
self.assertEqual(value, signer.unsign(signed_value))
for transform in transforms:
self.assertRaises(signing.BadSignature, signer.unsign, transform(signed_value))
|
'dumps and loads be reversible for any JSON serializable object'
| def test_dumps_loads(self):
| objects = [[u'a', u'list'], u'a unicode string \u2019', {u'a': u'dictionary'}]
if (not six.PY3):
objects.append('a byte string')
for o in objects:
self.assertNotEqual(o, signing.dumps(o))
self.assertEqual(o, signing.loads(signing.dumps(o)))
self.assertNotEqual(o, signing.dumps(o, compress=True))
self.assertEqual(o, signing.loads(signing.dumps(o, compress=True)))
|
'loads should raise exception for tampered objects'
| def test_decode_detects_tampering(self):
| transforms = ((lambda s: s.upper()), (lambda s: (s + u'a')), (lambda s: (u'a' + s[1:])), (lambda s: s.replace(u':', u'')))
value = {u'foo': u'bar', u'baz': 1}
encoded = signing.dumps(value)
self.assertEqual(value, signing.loads(encoded))
for transform in transforms:
self.assertRaises(signing.BadSignature, signing.loads, transform(encoded))
|
'RegexURLResolver should raise an exception when no urlpatterns exist.'
| def test_no_urls_exception(self):
| resolver = RegexURLResolver(u'^$', self.urls)
self.assertRaisesMessage(ImproperlyConfigured, u"The included urlconf regressiontests.urlpatterns_reverse.no_urls doesn't have any patterns in it", getattr, resolver, u'url_patterns')
|
'Test repr of RegexURLResolver, especially when urlconf_name is a list
(#17892).'
| def test_resolver_repr(self):
| resolver = get_resolver(u'regressiontests.urlpatterns_reverse.namespace_urls')
sub_resolver = resolver.namespace_dict[u'test-ns1'][1]
self.assertIn(u'<RegexURLPattern list>', repr(sub_resolver))
|
'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, u'')
self.assertRaises(Resolver404, resolve, u'a')
self.assertRaises(Resolver404, resolve, u'\\')
self.assertRaises(Resolver404, resolve, u'.')
|
'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 = u'regressiontests.urlpatterns_reverse.named_urls'
url_types_names = [[{u'type': RegexURLPattern, u'name': u'named-url1'}], [{u'type': RegexURLPattern, u'name': u'named-url2'}], [{u'type': RegexURLPattern, u'name': None}], [{u'type': RegexURLResolver}, {u'type': RegexURLPattern, u'name': u'named-url3'}], [{u'type': RegexURLResolver}, {u'type': RegexURLPattern, u'name': u'named-url4'}], [{u'type': RegexURLResolver}, {u'type': RegexURLPattern, u'name': None}], [{u'type': RegexURLResolver}, {u'type': RegexURLResolver}]]
try:
resolve(u'/included/non-existent-url', urlconf=urls)
self.fail(u'resolve did not raise a 404')
except Resolver404 as e:
self.assertTrue((u'tried' in e.args[0]))
tried = e.args[0][u'tried']
self.assertEqual(len(e.args[0][u'tried']), len(url_types_names), (u'Wrong number of tried URLs returned. Expected %s, got %s.' % (len(url_types_names), len(e.args[0][u'tried']))))
for (tried, expected) in zip(e.args[0][u'tried'], url_types_names):
for (t, e) in zip(tried, expected):
self.assertTrue(isinstance(t, e[u'type']), (str(u'%s is not an instance of %s') % (t, e[u'type'])))
if (u'name' in e):
if (not e[u'name']):
self.assertTrue((t.name is None), (u'Expected no URL name but found %s.' % t.name))
else:
self.assertEqual(t.name, e[u'name'], (u'Wrong URL name. Expected "%s", got "%s".' % (e[u'name'], t.name)))
|
'Names deployed via dynamic URL objects that require namespaces can\'t be resolved'
| def test_ambiguous_object(self):
| self.assertRaises(NoReverseMatch, reverse, u'urlobject-view')
self.assertRaises(NoReverseMatch, reverse, u'urlobject-view', args=[37, 42])
self.assertRaises(NoReverseMatch, reverse, u'urlobject-view', kwargs={u'arg1': 42, u'arg2': 37})
|
'Names deployed via dynamic URL objects that require namespaces can\'t be resolved'
| def test_ambiguous_urlpattern(self):
| self.assertRaises(NoReverseMatch, reverse, u'inner-nothing')
self.assertRaises(NoReverseMatch, reverse, u'inner-nothing', args=[37, 42])
self.assertRaises(NoReverseMatch, reverse, u'inner-nothing', kwargs={u'arg1': 42, u'arg2': 37})
|
'Non-existent namespaces raise errors'
| def test_non_existent_namespace(self):
| self.assertRaises(NoReverseMatch, reverse, u'blahblah:urlobject-view')
self.assertRaises(NoReverseMatch, reverse, u'test-ns1:blahblah:urlobject-view')
|
'Normal lookups work as expected'
| def test_normal_name(self):
| self.assertEqual(u'/normal/', reverse(u'normal-view'))
self.assertEqual(u'/normal/37/42/', reverse(u'normal-view', args=[37, 42]))
self.assertEqual(u'/normal/42/37/', reverse(u'normal-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/+%5C$*/', reverse(u'special-view'))
|
'Normal lookups work on names included from other patterns'
| def test_simple_included_name(self):
| self.assertEqual(u'/included/normal/', reverse(u'inc-normal-view'))
self.assertEqual(u'/included/normal/37/42/', reverse(u'inc-normal-view', args=[37, 42]))
self.assertEqual(u'/included/normal/42/37/', reverse(u'inc-normal-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/included/+%5C$*/', reverse(u'inc-special-view'))
|
'Dynamic URL objects can be found using a namespace'
| def test_namespace_object(self):
| self.assertEqual(u'/test1/inner/', reverse(u'test-ns1:urlobject-view'))
self.assertEqual(u'/test1/inner/37/42/', reverse(u'test-ns1:urlobject-view', args=[37, 42]))
self.assertEqual(u'/test1/inner/42/37/', reverse(u'test-ns1:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/test1/inner/+%5C$*/', reverse(u'test-ns1:urlobject-special-view'))
|
'Namespaces can be installed anywhere in the URL pattern tree'
| def test_embedded_namespace_object(self):
| self.assertEqual(u'/included/test3/inner/', reverse(u'test-ns3:urlobject-view'))
self.assertEqual(u'/included/test3/inner/37/42/', reverse(u'test-ns3:urlobject-view', args=[37, 42]))
self.assertEqual(u'/included/test3/inner/42/37/', reverse(u'test-ns3:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/included/test3/inner/+%5C$*/', reverse(u'test-ns3:urlobject-special-view'))
|
'Namespaces can be applied to include()\'d urlpatterns'
| def test_namespace_pattern(self):
| self.assertEqual(u'/ns-included1/normal/', reverse(u'inc-ns1:inc-normal-view'))
self.assertEqual(u'/ns-included1/normal/37/42/', reverse(u'inc-ns1:inc-normal-view', args=[37, 42]))
self.assertEqual(u'/ns-included1/normal/42/37/', reverse(u'inc-ns1:inc-normal-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/ns-included1/+%5C$*/', reverse(u'inc-ns1:inc-special-view'))
|
'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(u'/ns-outer/42/normal/', reverse(u'inc-outer:inc-normal-view', kwargs={u'outer': 42}))
self.assertEqual(u'/ns-outer/42/normal/', reverse(u'inc-outer:inc-normal-view', args=[42]))
self.assertEqual(u'/ns-outer/42/normal/37/4/', reverse(u'inc-outer:inc-normal-view', kwargs={u'outer': 42, u'arg1': 37, u'arg2': 4}))
self.assertEqual(u'/ns-outer/42/normal/37/4/', reverse(u'inc-outer:inc-normal-view', args=[42, 37, 4]))
self.assertEqual(u'/ns-outer/42/+%5C$*/', reverse(u'inc-outer:inc-special-view', kwargs={u'outer': 42}))
self.assertEqual(u'/ns-outer/42/+%5C$*/', reverse(u'inc-outer:inc-special-view', args=[42]))
|
'Namespaces can be embedded'
| def test_multiple_namespace_pattern(self):
| self.assertEqual(u'/ns-included1/test3/inner/', reverse(u'inc-ns1:test-ns3:urlobject-view'))
self.assertEqual(u'/ns-included1/test3/inner/37/42/', reverse(u'inc-ns1:test-ns3:urlobject-view', args=[37, 42]))
self.assertEqual(u'/ns-included1/test3/inner/42/37/', reverse(u'inc-ns1:test-ns3:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/ns-included1/test3/inner/+%5C$*/', reverse(u'inc-ns1:test-ns3:urlobject-special-view'))
|
'Namespaces can be nested'
| def test_nested_namespace_pattern(self):
| self.assertEqual(u'/ns-included1/ns-included4/ns-included1/test3/inner/', reverse(u'inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view'))
self.assertEqual(u'/ns-included1/ns-included4/ns-included1/test3/inner/37/42/', reverse(u'inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view', args=[37, 42]))
self.assertEqual(u'/ns-included1/ns-included4/ns-included1/test3/inner/42/37/', reverse(u'inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/ns-included1/ns-included4/ns-included1/test3/inner/+%5C$*/', reverse(u'inc-ns1:inc-ns4:inc-ns1:test-ns3:urlobject-special-view'))
|
'A default application namespace can be used for lookup'
| def test_app_lookup_object(self):
| self.assertEqual(u'/default/inner/', reverse(u'testapp:urlobject-view'))
self.assertEqual(u'/default/inner/37/42/', reverse(u'testapp:urlobject-view', args=[37, 42]))
self.assertEqual(u'/default/inner/42/37/', reverse(u'testapp:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/default/inner/+%5C$*/', reverse(u'testapp:urlobject-special-view'))
|
'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(u'/included/test3/inner/', reverse(u'testapp:urlobject-view', current_app=u'test-ns3'))
self.assertEqual(u'/included/test3/inner/37/42/', reverse(u'testapp:urlobject-view', args=[37, 42], current_app=u'test-ns3'))
self.assertEqual(u'/included/test3/inner/42/37/', reverse(u'testapp:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}, current_app=u'test-ns3'))
self.assertEqual(u'/included/test3/inner/+%5C$*/', reverse(u'testapp:urlobject-special-view', current_app=u'test-ns3'))
|
'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(u'/other2/inner/', reverse(u'nodefault:urlobject-view'))
self.assertEqual(u'/other2/inner/37/42/', reverse(u'nodefault:urlobject-view', args=[37, 42]))
self.assertEqual(u'/other2/inner/42/37/', reverse(u'nodefault:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}))
self.assertEqual(u'/other2/inner/+%5C$*/', reverse(u'nodefault:urlobject-special-view'))
self.assertEqual(u'/other1/inner/', reverse(u'nodefault:urlobject-view', current_app=u'other-ns1'))
self.assertEqual(u'/other1/inner/37/42/', reverse(u'nodefault:urlobject-view', args=[37, 42], current_app=u'other-ns1'))
self.assertEqual(u'/other1/inner/42/37/', reverse(u'nodefault:urlobject-view', kwargs={u'arg1': 42, u'arg2': 37}, current_app=u'other-ns1'))
self.assertEqual(u'/other1/inner/+%5C$*/', reverse(u'nodefault:urlobject-special-view', current_app=u'other-ns1'))
|
'Namespace prefixes can capture variables: see #15900'
| def test_namespaces_with_variables(self):
| self.assertEqual(u'/inc70/', reverse(u'inc-ns5:inner-nothing', kwargs={u'outer': u'70'}))
self.assertEqual(u'/inc78/extra/foobar/', reverse(u'inc-ns5:inner-extra', kwargs={u'outer': u'78', u'extra': u'foobar'}))
self.assertEqual(u'/inc70/', reverse(u'inc-ns5:inner-nothing', args=[u'70']))
self.assertEqual(u'/inc78/extra/foobar/', reverse(u'inc-ns5:inner-extra', args=[u'78', u'foobar']))
|
'If the urls.py doesn\'t specify handlers, the defaults are used'
| def test_default_handler(self):
| try:
response = self.client.get(u'/test/')
self.assertEqual(response.status_code, 404)
except AttributeError:
self.fail(u"Shouldn't get an AttributeError due to undefined 404 handler")
try:
self.assertRaises(ValueError, self.client.get, u'/bad_view/')
except AttributeError:
self.fail(u"Shouldn't get an AttributeError due to undefined 500 handler")
|
'Ensure that a useful exception is raised when a regex is invalid in the
URLConf.
Refs #6170.'
| def test_erroneous_reverse(self):
| self.assertRaises(ImproperlyConfigured, reverse, u'whatever blah blah')
|
'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=(u'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=(u'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()[8:9]])
self.assertTrue(self._validator_run)
|
'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({u'left': u'1', u'middle': u'2', u'right': u'3'})
self.assertFalse(form.is_valid())
form = TripleForm({u'left': u'1', u'middle': u'3', u'right': u'1'})
self.assertTrue(form.is_valid())
|
'Regression for #12596: Calling super from ModelForm.clean() should be
optional.'
| def test_override_clean(self):
| form = TripleFormWithCleanOverride({u'left': 1, u'middle': 2, u'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[u'path'].field.choices]
names.sort()
self.assertEqual(names, [u'---------', u'__init__.py', u'models.py', u'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 == u'publications'):
kwargs[u'initial'] = (lambda : Publication.objects.all().order_by(u'date_published')[:2])
return db_field.formfield(**kwargs)
book1 = Publication.objects.create(title=u'First Book', date_published=date(2007, 1, 1))
book2 = Publication.objects.create(title=u'Second Book', date_published=date(2008, 1, 1))
book3 = Publication.objects.create(title=u'Third Book', date_published=date(2009, 1, 1))
ModelForm = modelform_factory(Article, formfield_callback=formfield_for_dbfield)
form = ModelForm()
self.assertHTMLEqual(form.as_ul(), (u'<li><label for="id_headline">Headline:</label> <input id="id_headline" type="text" name="headline" maxlength="100" /></li>\n<li><label for="id_publications">Publications:</label> <select multiple="multiple" name="publications" id="id_publications">\n<option value="%d" selected="selected">First Book</option>\n<option value="%d" selected="selected">Second Book</option>\n<option value="%d">Third Book</option>\n</select> <span class="helptext"> Hold down "Control", or "Command" on a Mac, to select more than one.</span></li>' % (book1.pk, book2.pk, book3.pk)))
|
'Regression for #11149: save_form_data should be called only once'
| def test_save(self):
| form = CFFForm(data={u'f': None})
form.save()
|
'Check basic URL field validation on model forms'
| def test_url_on_modelform(self):
| self.assertFalse(HomepageForm({u'url': u'foo'}).is_valid())
self.assertFalse(HomepageForm({u'url': u'http://'}).is_valid())
self.assertFalse(HomepageForm({u'url': u'http://example'}).is_valid())
self.assertFalse(HomepageForm({u'url': u'http://example.'}).is_valid())
self.assertFalse(HomepageForm({u'url': u'http://com.'}).is_valid())
self.assertTrue(HomepageForm({u'url': u'http://localhost'}).is_valid())
self.assertTrue(HomepageForm({u'url': u'http://example.com'}).is_valid())
self.assertTrue(HomepageForm({u'url': u'http://www.example.com'}).is_valid())
self.assertTrue(HomepageForm({u'url': u'http://www.example.com:8000'}).is_valid())
self.assertTrue(HomepageForm({u'url': u'http://www.example.com/test'}).is_valid())
self.assertTrue(HomepageForm({u'url': u'http://www.example.com:8000/test'}).is_valid())
self.assertTrue(HomepageForm({u'url': u'http://example.com/foo/bar'}).is_valid())
|
'If the http:// prefix is omitted on form input, the field adds it again. (Refs #13613)'
| def test_http_prefixing(self):
| form = HomepageForm({u'url': u'example.com'})
form.is_valid()
form = HomepageForm({u'url': u'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 = {u'name': widget}
Form = modelform_factory(Person, form=BaseForm)
self.assertTrue((Form.base_fields[u'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[u'name'].widget.__class__, forms.Textarea)
Form = modelform_factory(Person, widgets={u'name': widget})
self.assertEqual(Form.base_fields[u'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 = {u'name': widget}
_ = modelform_factory(Person, form=BaseForm, formfield_callback=callback)
(id_field, name_field) = Person._meta.fields
self.assertEqual(callback_args, [(id_field, {}), (name_field, {u'widget': widget})])
|
'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, u'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, u'initial'), u'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((u'name="myfile"' in six.text_type(form)))
self.assertTrue((u'myfile-clear' not in six.text_type(form)))
form = DocumentForm(files={u'myfile': SimpleUploadedFile(u'something.txt', 'content')})
self.assertTrue(form.is_valid())
doc = form.save(commit=False)
self.assertEqual(doc.myfile.name, u'something.txt')
form = DocumentForm(instance=doc)
self.assertTrue((u'myfile-clear' in six.text_type(form)))
form = DocumentForm(instance=doc, data={u'myfile-clear': u'true'})
doc = form.save(commit=False)
self.assertEqual(bool(doc.myfile), False)
|
'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={u'myfile': SimpleUploadedFile(u'something.txt', 'content')})
self.assertTrue(form.is_valid())
doc = form.save(commit=False)
form = DocumentForm(instance=doc, files={u'myfile': SimpleUploadedFile(u'something.txt', 'content')}, data={u'myfile-clear': u'true'})
self.assertTrue((not form.is_valid()))
self.assertEqual(form.errors[u'myfile'], [u'Please either submit a file or check the clear checkbox, not both.'])
rendered = six.text_type(form)
self.assertTrue((u'something.txt' in rendered))
self.assertTrue((u'myfile-clear' in rendered))
|
'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)({u'name': u'John Doe'})
self.assertTrue(form.is_valid())
instance = construct_instance(form, Person(), fields=())
self.assertEqual(instance.name, u'')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.