desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Test a middleware that implements process_view, operating on a callable class.'
| def test_callable_process_view_middleware(self):
| class_xview(self.rf.get('/'))
|
'Test that all methods of middleware are called for normal HttpResponses'
| def test_full_dec_normal(self):
| @full_dec
def normal_view(request):
t = Template('Hello world')
return HttpResponse(t.render(Context({})))
request = self.rf.get('/')
response = normal_view(request)
self.assertTrue(getattr(request, 'process_request_reached', False))
self.assertTrue(getattr(request, 'process_v... |
'Test that all methods of middleware are called for TemplateResponses in
the right sequence.'
| def test_full_dec_templateresponse(self):
| @full_dec
def template_response_view(request):
t = Template('Hello world')
return TemplateResponse(request, t, {})
request = self.rf.get('/')
response = template_response_view(request)
self.assertTrue(getattr(request, 'process_request_reached', False))
self.assertTrue(getattr(... |
'Check that function(value) equals output. If output is None,
check that function(value) equals value.'
| def check_output(self, function, value, output=None):
| if (output is None):
output = value
self.assertEqual(function(value), output)
|
'Test that signals that disconnect when being called don\'t mess future
dispatching.'
| def test_disconnect_in_dispatch(self):
| (a, b) = (MyReceiver(1), MyReceiver(2))
signals.post_save.connect(sender=Person, receiver=a)
signals.post_save.connect(sender=Person, receiver=b)
p = Person.objects.create(first_name='John', last_name='Smith')
self.assertTrue(a._run)
self.assertTrue(b._run)
self.assertEqual(signals.post_save... |
'GET a view'
| def test_get_view(self):
| data = {'var': u'\xf2'}
response = self.client.get('/test_client/get_view/', data)
self.assertContains(response, 'This is a test')
self.assertEqual(response.context['var'], u'\xf2')
self.assertEqual(response.templates[0].name, 'GET Template')
|
'GET a view that normally expects POSTs'
| def test_get_post_view(self):
| response = self.client.get('/test_client/post_view/', {})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.templates[0].name, 'Empty GET Template')
self.assertTemplateUsed(response, 'Empty GET Template')
self.assertTemplateNotUsed(response, 'Empty POST Template... |
'POST an empty dictionary to a view'
| def test_empty_post(self):
| response = self.client.post('/test_client/post_view/', {})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.templates[0].name, 'Empty POST Template')
self.assertTemplateNotUsed(response, 'Empty GET Template')
self.assertTemplateUsed(response, 'Empty POST Templa... |
'POST some data to a view'
| def test_post(self):
| post_data = {'value': 37}
response = self.client.post('/test_client/post_view/', post_data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['data'], '37')
self.assertEqual(response.templates[0].name, 'POST Template')
self.assertTrue(('Data received' in respons... |
'Check the value of HTTP headers returned in a response'
| def test_response_headers(self):
| response = self.client.get('/test_client/header_view/')
self.assertEqual(response['X-DJANGO-TEST'], 'Slartibartfast')
|
'POST raw data (with a content type) to a view'
| def test_raw_post(self):
| test_doc = '<?xml version="1.0" encoding="utf-8"?><library><book><title>Blink</title><author>Malcolm Gladwell</author></book></library>'
response = self.client.post('/test_client/raw_post_view/', test_doc, content_type='text/xml')
self.assertEqual(response.status_code, 200)
self.assertEqual(res... |
'GET a URL that redirects elsewhere'
| def test_redirect(self):
| response = self.client.get('/test_client/redirect_view/')
self.assertRedirects(response, '/test_client/get_view/')
host = 'django.testserver'
client_providing_host = Client(HTTP_HOST=host)
response = client_providing_host.get('/test_client/redirect_view/')
self.assertRedirects(response, '/test_c... |
'GET a URL that redirects with given GET parameters'
| def test_redirect_with_query(self):
| response = self.client.get('/test_client/redirect_view/', {'var': 'value'})
self.assertRedirects(response, 'http://testserver/test_client/get_view/?var=value')
|
'GET a URL that redirects permanently elsewhere'
| def test_permanent_redirect(self):
| response = self.client.get('/test_client/permanent_redirect_view/')
self.assertRedirects(response, 'http://testserver/test_client/get_view/', status_code=301)
client_providing_host = Client(HTTP_HOST='django.testserver')
response = client_providing_host.get('/test_client/permanent_redirect_view/')
s... |
'GET a URL that does a non-permanent redirect'
| def test_temporary_redirect(self):
| response = self.client.get('/test_client/temporary_redirect_view/')
self.assertRedirects(response, 'http://testserver/test_client/get_view/', status_code=302)
|
'GET a URL that redirects to a non-200 page'
| def test_redirect_to_strange_location(self):
| response = self.client.get('/test_client/double_redirect_view/')
self.assertRedirects(response, 'http://testserver/test_client/permanent_redirect_view/', target_status_code=301)
|
'A URL that redirects can be followed to termination.'
| def test_follow_redirect(self):
| response = self.client.get('/test_client/double_redirect_view/', follow=True)
self.assertRedirects(response, 'http://testserver/test_client/get_view/', status_code=302, target_status_code=200)
self.assertEqual(len(response.redirect_chain), 2)
|
'GET a URL that redirects to an http URI'
| def test_redirect_http(self):
| response = self.client.get('/test_client/http_redirect_view/', follow=True)
self.assertFalse(response.test_was_secure_request)
|
'GET a URL that redirects to an https URI'
| def test_redirect_https(self):
| response = self.client.get('/test_client/https_redirect_view/', follow=True)
self.assertTrue(response.test_was_secure_request)
|
'GET a URL that responds as \'404:Not Found\''
| def test_notfound_response(self):
| response = self.client.get('/test_client/bad_view/')
self.assertContains(response, 'MAGIC', status_code=404)
|
'POST valid data to a form'
| def test_valid_form(self):
| post_data = {'text': 'Hello World', 'email': 'foo@example.com', 'value': 37, 'single': 'b', 'multi': ('b', 'c', 'e')}
response = self.client.post('/test_client/form_view/', post_data)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Valid POST Template')
|
'GET a form, providing hints in the GET data'
| def test_valid_form_with_hints(self):
| hints = {'text': 'Hello World', 'multi': ('b', 'c', 'e')}
response = self.client.get('/test_client/form_view/', data=hints)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Form GET Template')
self.assertContains(response, 'Select a valid choice.', 0)
|
'POST incomplete data to a form'
| def test_incomplete_data_form(self):
| post_data = {'text': 'Hello World', 'value': 37}
response = self.client.post('/test_client/form_view/', post_data)
self.assertContains(response, 'This field is required.', 3)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Invalid POST Template')
... |
'POST erroneous data to a form'
| def test_form_error(self):
| post_data = {'text': 'Hello World', 'email': 'not an email address', 'value': 37, 'single': 'b', 'multi': ('b', 'c', 'e')}
response = self.client.post('/test_client/form_view/', post_data)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'Invalid POST Templ... |
'POST valid data to a form using multiple templates'
| def test_valid_form_with_template(self):
| post_data = {'text': 'Hello World', 'email': 'foo@example.com', 'value': 37, 'single': 'b', 'multi': ('b', 'c', 'e')}
response = self.client.post('/test_client/form_view_with_template/', post_data)
self.assertContains(response, 'POST data OK')
self.assertTemplateUsed(response, 'form_view.html')... |
'POST incomplete data to a form using multiple templates'
| def test_incomplete_data_form_with_template(self):
| post_data = {'text': 'Hello World', 'value': 37}
response = self.client.post('/test_client/form_view_with_template/', post_data)
self.assertContains(response, 'POST data has errors')
self.assertTemplateUsed(response, 'form_view.html')
self.assertTemplateUsed(response, 'base.html')
se... |
'POST erroneous data to a form using multiple templates'
| def test_form_error_with_template(self):
| post_data = {'text': 'Hello World', 'email': 'not an email address', 'value': 37, 'single': 'b', 'multi': ('b', 'c', 'e')}
response = self.client.post('/test_client/form_view_with_template/', post_data)
self.assertContains(response, 'POST data has errors')
self.assertTemplateUsed(re... |
'GET an invalid URL'
| def test_unknown_page(self):
| response = self.client.get('/test_client/unknown_view/')
self.assertEqual(response.status_code, 404)
|
'Make sure that URL ;-parameters are not stripped.'
| def test_url_parameters(self):
| response = self.client.get('/test_client/unknown_view/;some-parameter')
self.assertEqual(response.request['PATH_INFO'], '/test_client/unknown_view/;some-parameter')
|
'Request a page that is protected with @login_required'
| def test_view_with_login(self):
| response = self.client.get('/test_client/login_protected_view/')
self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/login_protected_view/')
login = self.client.login(username='testclient', password='password')
self.assertTrue(login, 'Could not log in')
respo... |
'Request a page that is protected with a @login_required method'
| def test_view_with_method_login(self):
| response = self.client.get('/test_client/login_protected_method_view/')
self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/login_protected_method_view/')
login = self.client.login(username='testclient', password='password')
self.assertTrue(login, 'Could not log ... |
'Request a page that is protected with @login_required(redirect_field_name=\'redirect_to\')'
| def test_view_with_login_and_custom_redirect(self):
| response = self.client.get('/test_client/login_protected_view_custom_redirect/')
self.assertRedirects(response, 'http://testserver/accounts/login/?redirect_to=/test_client/login_protected_view_custom_redirect/')
login = self.client.login(username='testclient', password='password')
self.assertTrue(login,... |
'Request a page that is protected with @login, but use bad credentials'
| def test_view_with_bad_login(self):
| login = self.client.login(username='otheruser', password='nopassword')
self.assertFalse(login)
|
'Request a page that is protected with @login, but use an inactive login'
| def test_view_with_inactive_login(self):
| login = self.client.login(username='inactive', password='password')
self.assertFalse(login)
|
'Request a logout after logging in'
| def test_logout(self):
| self.client.login(username='testclient', password='password')
response = self.client.get('/test_client/login_protected_view/')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['user'].username, 'testclient')
self.client.logout()
response = self.client.get('/test_clie... |
'Request a page that is protected with @permission_required'
| def test_view_with_permissions(self):
| response = self.client.get('/test_client/permission_protected_view/')
self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/permission_protected_view/')
login = self.client.login(username='testclient', password='password')
self.assertTrue(login, 'Could not log in')... |
'Request a page that is protected with a @permission_required method'
| def test_view_with_method_permissions(self):
| response = self.client.get('/test_client/permission_protected_method_view/')
self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/permission_protected_method_view/')
login = self.client.login(username='testclient', password='password')
self.assertTrue(login, 'Could not ... |
'Request a page that modifies the session'
| def test_session_modifying_view(self):
| try:
self.client.session['tobacconist']
self.fail("Shouldn't have a session value")
except KeyError:
pass
from django.contrib.sessions.models import Session
response = self.client.post('/test_client/session_view/')
self.assertEqual(self.client.session['tobacconist... |
'Request a page that is known to throw an error'
| def test_view_with_exception(self):
| self.assertRaises(KeyError, self.client.get, '/test_client/broken_view/')
try:
self.client.get('/test_client/broken_view/')
self.fail('Should raise an error')
except KeyError:
pass
|
'Test that mail is redirected to a dummy outbox during test setup'
| def test_mail_sending(self):
| response = self.client.get('/test_client/mail_sending_view/')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, 'Test message')
self.assertEqual(mail.outbox[0].body, 'This is a test email')
self.assertEqual(m... |
'Test that mass mail is redirected to a dummy outbox during test setup'
| def test_mass_mail_sending(self):
| response = self.client.get('/test_client/mass_mail_sending_view/')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, 'First Test message')
self.assertEqual(mail.outbox[0].body, 'This is the first test email... |
'A client can be instantiated with CSRF checks enabled'
| def test_csrf_enabled_client(self):
| csrf_client = Client(enforce_csrf_checks=True)
response = self.client.post('/test_client/post_view/', {})
self.assertEqual(response.status_code, 200)
response = csrf_client.post('/test_client/post_view/', {})
self.assertEqual(response.status_code, 403)
|
'A test case can specify a custom class for self.client.'
| def test_custom_test_client(self):
| self.assertEqual(hasattr(self.client, 'i_am_customized'), True)
|
'Verbose version of get_articles_from_same_day_1, which does a custom
database query for the sake of demonstration.'
| def articles_from_same_day_2(self):
| from django.db import connection
cursor = connection.cursor()
cursor.execute('\n SELECT id, headline, pub_date\n FROM custom_methods_article\n WHERE pub... |
'If a related_name is given you can\'t use the field name instead'
| def test_reverse_field_name_disallowed(self):
| self.assertRaises(FieldError, Poll.objects.get, choice__name__exact='This is the answer')
|
'Test that update changes the right number of rows for a nonempty queryset'
| def test_nonempty_update(self):
| num_updated = self.a1.b_set.update(y=100)
self.assertEqual(num_updated, 20)
cnt = B.objects.filter(y=100).count()
self.assertEqual(cnt, 20)
|
'Test that update changes the right number of rows for an empty queryset'
| def test_empty_update(self):
| num_updated = self.a2.b_set.update(y=100)
self.assertEqual(num_updated, 0)
cnt = B.objects.filter(y=100).count()
self.assertEqual(cnt, 0)
|
'Test that update changes the right number of rows for an empty queryset
when the update affects only a base table'
| def test_nonempty_update_with_inheritance(self):
| num_updated = self.a1.d_set.update(y=100)
self.assertEqual(num_updated, 20)
cnt = D.objects.filter(y=100).count()
self.assertEqual(cnt, 20)
|
'Test that update changes the right number of rows for an empty queryset
when the update affects only a base table'
| def test_empty_update_with_inheritance(self):
| num_updated = self.a2.d_set.update(y=100)
self.assertEqual(num_updated, 0)
cnt = D.objects.filter(y=100).count()
self.assertEqual(cnt, 0)
|
'Objects are updated by first filtering the candidates into a queryset
and then calling the update() method. It executes immediately and
returns nothing.'
| def test_update(self):
| resp = DataPoint.objects.filter(value='apple').update(name='d1')
self.assertEqual(resp, 1)
resp = DataPoint.objects.filter(value='apple')
self.assertEqual(list(resp), [self.d0])
|
'We can update multiple objects at once.'
| def test_update_multiple_objects(self):
| resp = DataPoint.objects.filter(value='banana').update(value='pineapple')
self.assertEqual(resp, 2)
self.assertEqual(DataPoint.objects.get(name='d2').value, u'pineapple')
|
'Foreign key fields can also be updated, although you can only update
the object referred to, not anything inside the related object.'
| def test_update_fk(self):
| resp = RelatedPoint.objects.filter(name='r1').update(data=self.d0)
self.assertEqual(resp, 1)
resp = RelatedPoint.objects.filter(data__name='d0')
self.assertEqual(list(resp), [self.r1])
|
'Multiple fields can be updated at once'
| def test_update_multiple_fields(self):
| resp = DataPoint.objects.filter(value='apple').update(value='fruit', another_value='peach')
self.assertEqual(resp, 1)
d = DataPoint.objects.get(name='d0')
self.assertEqual(d.value, u'fruit')
self.assertEqual(d.another_value, u'peach')
|
'In the rare case you want to update every instance of a model, update()
is also a manager method.'
| def test_update_all(self):
| self.assertEqual(DataPoint.objects.update(value='thing'), 3)
resp = DataPoint.objects.values('value').distinct()
self.assertEqual(list(resp), [{'value': u'thing'}])
|
'We do not support update on already sliced query sets.'
| def test_update_slice_fail(self):
| method = DataPoint.objects.all()[:2].update
self.assertRaises(AssertionError, method, another_value='another thing')
|
'The main test here is that the all the models can be created without
any database errors. We can also do some more simple insertion and
lookup tests whilst we\'re here to show that the second of models do
refer to the tables from the first set.'
| def test_simple(self):
| a = A01.objects.create(f_a='foo', f_b=42)
B01.objects.create(fk_a=a, f_a='fred', f_b=1729)
c = C01.objects.create(f_a='barney', f_b=1)
c.mm_a = [a]
a2 = A02.objects.all()[0]
self.assertTrue(isinstance(a2, A02))
self.assertEqual(a2.f_a, 'foo')
b2 = B02.objects.all()[0]
self.assertTrue... |
'The intermediary table between two unmanaged models should not be created.'
| def test_many_to_many_between_unmanaged(self):
| table = Unmanaged2._meta.get_field('mm').m2m_db_table()
tables = connection.introspection.table_names()
self.assertTrue((table not in tables), ("Table '%s' should not exist, but it does." % table))
|
'An intermediary table between a managed and an unmanaged model should be created.'
| def test_many_to_many_between_unmanaged_and_managed(self):
| table = Managed1._meta.get_field('mm').m2m_db_table()
tables = connection.introspection.table_names()
self.assertTrue((table in tables), ("Table '%s' does not exist." % table))
|
'The MyPerson model should be generating the same database queries as
the Person model (when the same manager is used in each case).'
| def test_same_manager_queries(self):
| my_person_sql = MyPerson.other.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
person_sql = Person.objects.order_by('name').query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
self.assertEqual(my_person_sql, person_sql)
|
'The StatusPerson models should have its own table (it\'s using ORM-level
inheritance).'
| def test_inheretance_new_table(self):
| sp_sql = StatusPerson.objects.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
p_sql = Person.objects.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
self.assertNotEqual(sp_sql, p_sql)
|
'Creating a Person makes them accessible through the MyPerson proxy.'
| def test_basic_proxy(self):
| person = Person.objects.create(name='Foo McBar')
self.assertEqual(len(Person.objects.all()), 1)
self.assertEqual(len(MyPerson.objects.all()), 1)
self.assertEqual(MyPerson.objects.get(name='Foo McBar').id, person.id)
self.assertFalse(MyPerson.objects.get(id=person.id).has_special_name())
|
'Person is not proxied by StatusPerson subclass.'
| def test_no_proxy(self):
| Person.objects.create(name='Foo McBar')
self.assertEqual(list(StatusPerson.objects.all()), [])
|
'A new MyPerson also shows up as a standard Person.'
| def test_basic_proxy_reverse(self):
| MyPerson.objects.create(name='Bazza del Frob')
self.assertEqual(len(MyPerson.objects.all()), 1)
self.assertEqual(len(Person.objects.all()), 1)
LowerStatusPerson.objects.create(status='low', name='homer')
lsps = [lsp.name for lsp in LowerStatusPerson.objects.all()]
self.assertEqual(lsps, ['... |
'Correct type when querying a proxy of proxy'
| def test_correct_type_proxy_of_proxy(self):
| Person.objects.create(name='Foo McBar')
MyPerson.objects.create(name='Bazza del Frob')
LowerStatusPerson.objects.create(status='low', name='homer')
pp = sorted([mpp.name for mpp in MyPersonProxy.objects.all()])
self.assertEqual(pp, ['Bazza del Frob', 'Foo McBar', 'homer'])
|
'Proxy models are included in the ancestors for a model\'s DoesNotExist
and MultipleObjectsReturned'
| def test_proxy_included_in_ancestors(self):
| Person.objects.create(name='Foo McBar')
MyPerson.objects.create(name='Bazza del Frob')
LowerStatusPerson.objects.create(status='low', name='homer')
max_id = Person.objects.aggregate(max_id=models.Max('id'))['max_id']
self.assertRaises(Person.DoesNotExist, MyPersonProxy.objects.get, name='Za... |
'All base classes must be non-abstract'
| def test_abc(self):
| def build_abc():
class NoAbstract(Abstract, ):
class Meta:
proxy = True
self.assertRaises(TypeError, build_abc)
|
'The proxy must actually have one concrete base class'
| def test_no_cbc(self):
| def build_no_cbc():
class TooManyBases(Person, Abstract, ):
class Meta:
proxy = True
self.assertRaises(TypeError, build_no_cbc)
|
'Test save signals for proxy models'
| def test_proxy_model_signals(self):
| output = []
def make_handler(model, event):
def _handler(*args, **kwargs):
output.append(('%s %s save' % (model, event)))
return _handler
h1 = make_handler('MyPerson', 'pre')
h2 = make_handler('MyPerson', 'post')
h3 = make_handler('Person', 'pre')
h4 = make_hand... |
'Proxy objects can be deleted'
| def test_proxy_delete(self):
| User.objects.create(name='Bruce')
u2 = UserProxy.objects.create(name='George')
resp = [u.name for u in UserProxy.objects.all()]
self.assertEqual(resp, ['Bruce', 'George'])
u2.delete()
resp = [u.name for u in UserProxy.objects.all()]
self.assertEqual(resp, ['Bruce'])
|
'We can still use `select_related()` to include related models in our
querysets.'
| def test_select_related(self):
| country = Country.objects.create(name='Australia')
state = State.objects.create(name='New South Wales', country=country)
resp = [s.name for s in State.objects.select_related()]
self.assertEqual(resp, ['New South Wales'])
resp = [s.name for s in StateProxy.objects.select_related()]
se... |
'Registering a new serializer populates the full registry. Refs #14823'
| def test_register(self):
| serializers.register_serializer('json3', 'django.core.serializers.json')
public_formats = serializers.get_public_serializer_formats()
self.assertIn('json3', public_formats)
self.assertIn('json2', public_formats)
self.assertIn('xml', public_formats)
|
'Unregistering a serializer doesn\'t cause the registry to be repopulated. Refs #14823'
| def test_unregister(self):
| serializers.unregister_serializer('xml')
serializers.register_serializer('json3', 'django.core.serializers.json')
public_formats = serializers.get_public_serializer_formats()
self.assertNotIn('xml', public_formats)
self.assertIn('json3', public_formats)
|
'Requesting a list of serializer formats popuates the registry'
| def test_builtin_serializers(self):
| all_formats = set(serializers.get_serializer_formats())
public_formats = set(serializers.get_public_serializer_formats())
(self.assertIn('xml', all_formats),)
self.assertIn('xml', public_formats)
self.assertIn('json2', all_formats)
self.assertIn('json2', public_formats)
self.assertIn('python... |
'Tests that basic serialization works.'
| def test_serialize(self):
| serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
self.assertTrue(self._validate_output(serial_str))
|
'Tests that serialized content can be deserialized.'
| def test_serializer_roundtrip(self):
| serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
models = list(serializers.deserialize(self.serializer_name, serial_str))
self.assertEqual(len(models), 2)
|
'Tests the ability to create new objects by
modifying serialized content.'
| def test_altering_serialized_output(self):
| old_headline = 'Poker has no place on ESPN'
new_headline = 'Poker has no place on television'
serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
serial_str = serial_str.replace(old_headline, new_headline)
models = list(serializers.deserializ... |
'Tests that if you use your own primary key field
(such as a OneToOneField), it doesn\'t appear in the
serialized field list - it replaces the pk identifier.'
| def test_one_to_one_as_pk(self):
| profile = AuthorProfile(author=self.joe, date_of_birth=datetime(1970, 1, 1))
profile.save()
serial_str = serializers.serialize(self.serializer_name, AuthorProfile.objects.all())
self.assertFalse(self._get_field_values(serial_str, 'author'))
for obj in serializers.deserialize(self.serializer_name, se... |
'Tests that output can be restricted to a subset of fields'
| def test_serialize_field_subset(self):
| valid_fields = ('headline', 'pub_date')
invalid_fields = ('author', 'categories')
serial_str = serializers.serialize(self.serializer_name, Article.objects.all(), fields=valid_fields)
for field_name in invalid_fields:
self.assertFalse(self._get_field_values(serial_str, field_name))
for field_... |
'Tests that unicode makes the roundtrip intact'
| def test_serialize_unicode(self):
| actor_name = u'Za\u017c\xf3\u0142\u0107'
movie_title = u'G\u0119\u015bl\u0105 ja\u017a\u0144'
ac = Actor(name=actor_name)
mv = Movie(title=movie_title, actor=ac)
ac.save()
mv.save()
serial_str = serializers.serialize(self.serializer_name, [mv])
self.assertEqual(self._get_field_values(... |
'Tests that serialized data with no primary key results
in a model instance with no id'
| def test_serialize_with_null_pk(self):
| category = Category(name='Reference')
serial_str = serializers.serialize(self.serializer_name, [category])
pk_value = self._get_pk_values(serial_str)[0]
self.assertFalse(pk_value)
cat_obj = list(serializers.deserialize(self.serializer_name, serial_str))[0].object
self.assertEqual(cat_obj.id, Non... |
'Tests that float values serialize and deserialize intact'
| def test_float_serialization(self):
| sc = Score(score=3.4)
sc.save()
serial_str = serializers.serialize(self.serializer_name, [sc])
deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
self.assertEqual(deserial_objs[0].object.score, Approximate(3.4, places=1))
|
'Tests that custom fields serialize and deserialize intact'
| def test_custom_field_serialization(self):
| team_str = 'Spartak Moskva'
player = Player()
player.name = 'Soslan Djanaev'
player.rank = 1
player.team = Team(team_str)
player.save()
serial_str = serializers.serialize(self.serializer_name, Player.objects.all())
team = self._get_field_values(serial_str, 'team')
self.assertTr... |
'Tests that year values before 1000AD are properly formatted'
| def test_pre_1000ad_date(self):
| a = Article.objects.create(author=self.jane, headline='Nobody remembers the early years', pub_date=datetime(1, 2, 3, 4, 5, 6))
serial_str = serializers.serialize(self.serializer_name, [a])
date_values = self._get_field_values(serial_str, 'pub_date')
self.assertEqual(date_values[0], '0001-02-... |
'Tests that serialized strings without PKs
can be turned into models'
| def test_pkless_serialized_strings(self):
| deserial_objs = list(serializers.deserialize(self.serializer_name, self.pkless_str))
for obj in deserial_objs:
self.assertFalse(obj.object.id)
obj.save()
self.assertEqual(Category.objects.all().count(), 4)
|
'Tests that objects ids can be referenced before they are
defined in the serialization data.'
| def test_forward_refs(self):
| transaction.enter_transaction_management()
transaction.managed(True)
objs = serializers.deserialize(self.serializer_name, self.fwd_ref_str)
for obj in objs:
obj.save()
transaction.commit()
transaction.leave_transaction_management()
for model_cls in (Category, Author, Article):
... |
'ModelForm test of unique_together constraint'
| def test_unique_together(self):
| form = PriceForm({'price': '6.00', 'quantity': '1'})
self.assertTrue(form.is_valid())
form.save()
form = PriceForm({'price': '6.00', 'quantity': '1'})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 1)
self.assertEqual(form.errors['__all__'], [u'Price with this ... |
'Test for primary_key being in the form and failing validation.'
| def test_explicitpk_unspecified(self):
| form = ExplicitPKForm({'key': u'', 'desc': u''})
self.assertFalse(form.is_valid())
|
'Ensure keys and blank character strings are tested for uniqueness.'
| def test_explicitpk_unique(self):
| form = ExplicitPKForm({'key': u'key1', 'desc': u''})
self.assertTrue(form.is_valid())
form.save()
form = ExplicitPKForm({'key': u'key1', 'desc': u''})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 3)
self.assertEqual(form.errors['__all__'], [u'Explicit pk with ... |
'Execute the passed query against the passed model and check the output'
| def assertSuccessfulRawQuery(self, model, query, expected_results, expected_annotations=(), params=[], translations=None):
| results = list(model.objects.raw(query, params=params, translations=translations))
self.assertProcessed(model, results, expected_results, expected_annotations)
self.assertAnnotations(results, expected_annotations)
|
'Compare the results of a raw query against expected results'
| def assertProcessed(self, model, results, orig, expected_annotations=()):
| self.assertEqual(len(results), len(orig))
for (index, item) in enumerate(results):
orig_item = orig[index]
for annotation in expected_annotations:
setattr(orig_item, *annotation)
for field in model._meta.fields:
self.assertEqual(getattr(item, field.attname), getat... |
'Check that the results of a raw query contain no annotations'
| def assertNoAnnotations(self, results):
| self.assertAnnotations(results, ())
|
'Check that the passed raw query results contain the expected
annotations'
| def assertAnnotations(self, results, expected_annotations):
| if expected_annotations:
for (index, result) in enumerate(results):
(annotation, value) = expected_annotations[index]
self.assertTrue(hasattr(result, annotation))
self.assertEqual(getattr(result, annotation), value)
|
'Basic test of raw query with a simple database query'
| def testSimpleRawQuery(self):
| query = 'SELECT * FROM raw_query_author'
authors = Author.objects.all()
self.assertSuccessfulRawQuery(Author, query, authors)
|
'Raw queries are lazy: they aren\'t actually executed until they\'re
iterated over.'
| def testRawQueryLazy(self):
| q = Author.objects.raw('SELECT * FROM raw_query_author')
self.assertTrue((q.query.cursor is None))
list(q)
self.assertTrue((q.query.cursor is not None))
|
'Test of a simple raw query against a model containing a foreign key'
| def testFkeyRawQuery(self):
| query = 'SELECT * FROM raw_query_book'
books = Book.objects.all()
self.assertSuccessfulRawQuery(Book, query, books)
|
'Test of a simple raw query against a model containing a field with
db_column defined.'
| def testDBColumnHandler(self):
| query = 'SELECT * FROM raw_query_coffee'
coffees = Coffee.objects.all()
self.assertSuccessfulRawQuery(Coffee, query, coffees)
|
'Test of raw raw query\'s tolerance for columns being returned in any
order'
| def testOrderHandler(self):
| selects = ('dob, last_name, first_name, id', 'last_name, dob, first_name, id', 'first_name, last_name, dob, id')
for select in selects:
query = ('SELECT %s FROM raw_query_author' % select)
authors = Author.objects.all()
self.assertSuccessfulRawQuery(Au... |
'Test of raw query\'s optional ability to translate unexpected result
column names to specific model fields'
| def testTranslations(self):
| query = 'SELECT first_name AS first, last_name AS last, dob, id FROM raw_query_author'
translations = {'first': 'first_name', 'last': 'last_name'}
authors = Author.objects.all()
self.assertSuccessfulRawQuery(Author, query, authors, translations=translations)
|
'Test passing optional query parameters'
| def testParams(self):
| query = 'SELECT * FROM raw_query_author WHERE first_name = %s'
author = Author.objects.all()[2]
params = [author.first_name]
results = list(Author.objects.raw(query, params=params))
self.assertProcessed(Author, results, [author])
self.assertNoAnnotations(results)
self.as... |
'Test of a simple raw query against a model containing a m2m field'
| def testManyToMany(self):
| query = 'SELECT * FROM raw_query_reviewer'
reviewers = Reviewer.objects.all()
self.assertSuccessfulRawQuery(Reviewer, query, reviewers)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.