desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Make a OpenConnection RPC call.
Args:
request: a OpenConnectionRequest instance.
rpc: Optional RPC instance to use for the call.
callback: Optional final callback. Will be called as
callback(rpc, result) when the rpc completes. If None, the
call is synchronous.
response: Optional ProtocolMessage to be filled in with r... | def OpenConnection(self, request, rpc=None, callback=None, response=None):
| if (response is None):
response = OpenConnectionResponse
return self._MakeCall(rpc, self._full_name_OpenConnection, 'OpenConnection', request, response, callback, self._protorpc_OpenConnection)
|
'Make a CloseConnection RPC call.
Args:
request: a CloseConnectionRequest instance.
rpc: Optional RPC instance to use for the call.
callback: Optional final callback. Will be called as
callback(rpc, result) when the rpc completes. If None, the
call is synchronous.
response: Optional ProtocolMessage to be filled in with... | def CloseConnection(self, request, rpc=None, callback=None, response=None):
| if (response is None):
response = CloseConnectionResponse
return self._MakeCall(rpc, self._full_name_CloseConnection, 'CloseConnection', request, response, callback, self._protorpc_CloseConnection)
|
'Creates a Stubby RPC server.
See BaseRpcServer.__init__ in rpcserver.py for detail on arguments.'
| def __init__(self, *args, **kwargs):
| if (_server_stub_base_class is object):
raise NotImplementedError('Add //net/rpc/python:rpcserver as a dependency for Stubby server support.')
_server_stub_base_class.__init__(self, 'speckle.sql.SqlService', *args, **kwargs)
|
'Creates a new SqlService Stubby client stub.
Args:
rpc_stub_parameters: an RPC_StubParameter instance.
service_name: the service name used by the Stubby server.'
| @staticmethod
def NewStub(rpc_stub_parameters, service_name=None):
| if (_client_stub_base_class is object):
raise RuntimeError('Add //net/rpc/python as a dependency to use Stubby')
return _SqlService_ClientStub(rpc_stub_parameters, service_name)
|
'Creates a new SqlService Stubby2 client stub.
Args:
server: host:port or bns address.
channel: directly use a channel to create a stub. Will ignore server
argument if this is specified.
service_name: the service name used by the Stubby server.'
| @staticmethod
def NewRPC2Stub(server=None, channel=None, service_name=None):
| if (_client_stub_base_class is object):
raise RuntimeError('Add //net/rpc/python as a dependency to use Stubby')
return _SqlService_RPC2ClientStub(server, channel, service_name)
|
'Handles a Exec RPC call. You should override this.
Args:
rpc: a Stubby RPC object
request: a ExecRequest that contains the client request
response: a ExecResponse that should be modified to send the response'
| def Exec(self, rpc, request, response):
| raise NotImplementedError
|
'Handles a ExecOp RPC call. You should override this.
Args:
rpc: a Stubby RPC object
request: a ExecOpRequest that contains the client request
response: a ExecOpResponse that should be modified to send the response'
| def ExecOp(self, rpc, request, response):
| raise NotImplementedError
|
'Handles a GetMetadata RPC call. You should override this.
Args:
rpc: a Stubby RPC object
request: a MetadataRequest that contains the client request
response: a MetadataResponse that should be modified to send the response'
| def GetMetadata(self, rpc, request, response):
| raise NotImplementedError
|
'Handles a OpenConnection RPC call. You should override this.
Args:
rpc: a Stubby RPC object
request: a OpenConnectionRequest that contains the client request
response: a OpenConnectionResponse that should be modified to send the response'
| def OpenConnection(self, rpc, request, response):
| raise NotImplementedError
|
'Handles a CloseConnection RPC call. You should override this.
Args:
rpc: a Stubby RPC object
request: a CloseConnectionRequest that contains the client request
response: a CloseConnectionResponse that should be modified to send the response'
| def CloseConnection(self, rpc, request, response):
| raise NotImplementedError
|
'Sets attributes on Python RPC handlers.
See BaseRpcServer in rpcserver.py for details.'
| def _AddMethodAttributes(self):
| rpcserver._GetHandlerDecorator(self.Exec.im_func, ExecRequest, ExecResponse, None, 'none')
rpcserver._GetHandlerDecorator(self.ExecOp.im_func, ExecOpRequest, ExecOpResponse, None, 'none')
rpcserver._GetHandlerDecorator(self.GetMetadata.im_func, MetadataRequest, MetadataResponse, None, 'none')
rpcserver.... |
'DEPRECATED. Introduce no new call sites.'
| def __init__(self):
| Exception.__init__(self)
|
'RegexURLResolver should raise an exception when no urlpatterns exist.'
| def test_no_urls_exception(self):
| resolver = RegexURLResolver('^$', self.urls)
self.assertRaisesErrorWithMessage(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, '.')
|
'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.assertEquals('/normal/', reverse('normal-view'))
self.assertEquals('/normal/37/42/', reverse('normal-view', args=[37, 42]))
self.assertEquals('/normal/42/37/', reverse('normal-view', kwargs={'arg1': 42, 'arg2': 37}))
|
'Normal lookups work on names included from other patterns'
| def test_simple_included_name(self):
| self.assertEquals('/included/normal/', reverse('inc-normal-view'))
self.assertEquals('/included/normal/37/42/', reverse('inc-normal-view', args=[37, 42]))
self.assertEquals('/included/normal/42/37/', reverse('inc-normal-view', kwargs={'arg1': 42, 'arg2': 37}))
|
'Dynamic URL objects can be found using a namespace'
| def test_namespace_object(self):
| self.assertEquals('/test1/inner/', reverse('test-ns1:urlobject-view'))
self.assertEquals('/test1/inner/37/42/', reverse('test-ns1:urlobject-view', args=[37, 42]))
self.assertEquals('/test1/inner/42/37/', reverse('test-ns1:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
|
'Namespaces can be installed anywhere in the URL pattern tree'
| def test_embedded_namespace_object(self):
| self.assertEquals('/included/test3/inner/', reverse('test-ns3:urlobject-view'))
self.assertEquals('/included/test3/inner/37/42/', reverse('test-ns3:urlobject-view', args=[37, 42]))
self.assertEquals('/included/test3/inner/42/37/', reverse('test-ns3:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
|
'Namespaces can be applied to include()\'d urlpatterns'
| def test_namespace_pattern(self):
| self.assertEquals('/ns-included1/normal/', reverse('inc-ns1:inc-normal-view'))
self.assertEquals('/ns-included1/normal/37/42/', reverse('inc-ns1:inc-normal-view', args=[37, 42]))
self.assertEquals('/ns-included1/normal/42/37/', reverse('inc-ns1:inc-normal-view', kwargs={'arg1': 42, 'arg2': 37}))
|
'Namespaces can be embedded'
| def test_multiple_namespace_pattern(self):
| self.assertEquals('/ns-included1/test3/inner/', reverse('inc-ns1:test-ns3:urlobject-view'))
self.assertEquals('/ns-included1/test3/inner/37/42/', reverse('inc-ns1:test-ns3:urlobject-view', args=[37, 42]))
self.assertEquals('/ns-included1/test3/inner/42/37/', reverse('inc-ns1:test-ns3:urlobject-view', kwargs... |
'A default application namespace can be used for lookup'
| def test_app_lookup_object(self):
| self.assertEquals('/default/inner/', reverse('testapp:urlobject-view'))
self.assertEquals('/default/inner/37/42/', reverse('testapp:urlobject-view', args=[37, 42]))
self.assertEquals('/default/inner/42/37/', reverse('testapp:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
|
'A default application namespace is sensitive to the \'current\' app can be used for lookup'
| def test_app_lookup_object_with_default(self):
| self.assertEquals('/included/test3/inner/', reverse('testapp:urlobject-view', current_app='test-ns3'))
self.assertEquals('/included/test3/inner/37/42/', reverse('testapp:urlobject-view', args=[37, 42], current_app='test-ns3'))
self.assertEquals('/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.assertEquals('/other2/inner/', reverse('nodefault:urlobject-view'))
self.assertEquals('/other2/inner/37/42/', reverse('nodefault:urlobject-view', args=[37, 42]))
self.assertEquals('/other2/inner/42/37/', reverse('nodefault:urlobject-view', kwargs={'arg1': 42, 'arg2': 37}))
self.assertEquals('/other... |
'Test that ModelMultipleChoiceField does O(1) queries instead of
O(n) (#10156).'
| def test_model_multiple_choice_number_of_queries(self):
| for i in range(30):
Person.objects.create(name=('Person %s' % i))
db.reset_queries()
f = forms.ModelMultipleChoiceField(queryset=Person.objects.all())
selected = f.clean([1, 3, 5, 7, 9])
self.assertEquals(len(db.connection.queries), 1)
|
'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.assertEquals(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)
Publication(title='First Book', date_published=date(2007, 1, 1)).save()
... |
'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))
|
'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... |
'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.assertEquals(set(query.values_list('id', flat=True)), set([2, 3]))
query = DumbCategory.objects.filter(id__in=DumbCategory.objects.order_by('-id')[:2])
self.assertEquals(set(query.values_l... |
'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.assertEquals(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.assertEquals(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 that we don\'t output tricky characters in encoded value'
| def test_encode(self):
| c = CompatCookie()
c['test'] = 'An,awkward;value'
self.assert_((';' not in c.output().rstrip(';')))
self.assert_((',' not in c.output().rstrip(';')))
|
'Test that we can still preserve semi-colons and commas'
| def test_decode(self):
| c = CompatCookie()
c['test'] = 'An,awkward;value'
c2 = CompatCookie()
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 = CompatCookie()
c['test'] = '\xf0'
c2 = CompatCookie()
c2.load(c.output())
self.assertEqual(c['test'].value, c2['test'].value)
|
'Tests that django decorators set certain attributes of the wrapped
function.'
| def test_attributes(self):
| if ((version_info[0] >= 2) and (version_info[1] >= 4)):
self.assertEquals(fully_decorated.__name__, 'fully_decorated')
self.assertEquals(fully_decorated.__doc__, 'Expected __doc__')
self.assertEquals(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 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,... |
'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:
pass
|
'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:
pass
|
'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.ADMIN_MEDIA_PREFIX don\'t turn into absolute file paths.'
| def test_media_urls(self):
| data = (('/media/css/base.css', ('css', 'base.css')),)
bad_data = ()
if (os.sep == '/'):
data += (('/media/\\css/base.css', ('\\css', 'base.css')),)
bad_data += ('/media//css/base.css', '/media////css/base.css', '/media/../css/base.css')
elif (os.sep == '\\'):
bad_data += ('/medi... |
'Test that extra_context works'
| def changelist_view(self, request):
| return super(ArticleAdmin, self).changelist_view(request, extra_context={'extra_var': 'Hello!'})
|
'Test that extra_context works'
| def changelist_view(self, request):
| return super(CustomArticleAdmin, self).changelist_view(request, extra_context={'extra_var': 'Hello!'})
|
'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.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.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)
|
'A smoke test to ensure POST on add_view works.'
| def testBasicAddPost(self):
| post_data = {'name': u'Another Section', 'article_set-TOTAL_FORMS': u'3', 'article_set-INITIAL_FORMS': u'0', 'article_set-MAX_NUM_FORMS': u'0'}
response = self.client.post(('/test_admin/%s/admin_views/section/add/' % self.urlbit), post_data)
self.assertEqual(response.status_code, 302)
|
'Ensure http response from a popup is properly escaped.'
| def testPopupAddPost(self):
| post_data = {'_popup': u'1', 'title': u'title with a new\nline', 'content': u'some content', 'date_0': u'2010-09-10', 'date_1': u'14:55:39'}
response = self.client.post(('/test_admin/%s/admin_views/article/add/' % self.urlbit), post_data)
self.failUnlessEqual(response.status_code, 200)
self.... |
'A smoke test to ensure POST on edit_view works.'
| def testBasicEditPost(self):
| response = self.client.post(('/test_admin/%s/admin_views/section/1/' % self.urlbit), self.inline_post_data)
self.assertEqual(response.status_code, 302)
|
'Test "save as".'
| def testEditSaveAs(self):
| post_data = self.inline_post_data.copy()
post_data.update({'_saveasnew': u'Save+as+new', 'article_set-1-section': u'1', 'article_set-2-section': u'1', 'article_set-3-section': u'1', 'article_set-4-section': u'1', 'article_set-5-section': u'1'})
response = self.client.post(('/test_admin/%s/admin_views/sectio... |
'Ensure we can sort on a list_display field that is a callable
(column 2 is callable_year in ArticleAdmin)'
| def testChangeListSortingCallable(self):
| response = self.client.get(('/test_admin/%s/admin_views/article/' % self.urlbit), {'ot': 'asc', 'o': 2})
self.assertEqual(response.status_code, 200)
self.assertTrue(((response.content.index('Oldest content') < response.content.index('Middle content')) and (response.content.index('Middle content') <... |
'Ensure we can sort on a list_display field that is a Model method
(colunn 3 is \'model_year\' in ArticleAdmin)'
| def testChangeListSortingModel(self):
| response = self.client.get(('/test_admin/%s/admin_views/article/' % self.urlbit), {'ot': 'dsc', 'o': 3})
self.assertEqual(response.status_code, 200)
self.assertTrue(((response.content.index('Newest content') < response.content.index('Middle content')) and (response.content.index('Middle content') <... |
'Ensure we can sort on a list_display field that is a ModelAdmin method
(colunn 4 is \'modeladmin_year\' in ArticleAdmin)'
| def testChangeListSortingModelAdmin(self):
| response = self.client.get(('/test_admin/%s/admin_views/article/' % self.urlbit), {'ot': 'asc', 'o': 4})
self.assertEqual(response.status_code, 200)
self.assertTrue(((response.content.index('Oldest content') < response.content.index('Middle content')) and (response.content.index('Middle content') <... |
'Ensure admin changelist filters do not contain objects excluded via limit_choices_to.'
| def testLimitedFilter(self):
| response = self.client.get(('/test_admin/%s/admin_views/thing/' % self.urlbit))
self.assertEqual(response.status_code, 200)
self.assertTrue(('<div id="changelist-filter">' in response.content), 'Expected filter not found in changelist view.')
self.assertFalse(('<a href="?color__i... |
'Ensure incorrect lookup parameters are handled gracefully.'
| def testIncorrectLookupParameters(self):
| response = self.client.get(('/test_admin/%s/admin_views/thing/' % self.urlbit), {'notarealfield': '5'})
self.assertRedirects(response, ('/test_admin/%s/admin_views/thing/?e=1' % self.urlbit))
response = self.client.get(('/test_admin/%s/admin_views/thing/' % self.urlbit), {'color__id__exact': 'StringNotInteg... |
'Ensure is_null is handled correctly.'
| def testIsNullLookups(self):
| Article.objects.create(title='I Could Go Anywhere', content='Versatile', date=datetime.datetime.now())
response = self.client.get(('/test_admin/%s/admin_views/article/' % self.urlbit))
self.assertTrue(('4 articles' in response.content), '"4 articles" missing from response')
respo... |
'Ensures the admin changelist shows correct values in the relevant column
for rows corresponding to instances of a model in which a named group
has been used in the choices option of a field.'
| def testNamedGroupFieldChoicesChangeList(self):
| response = self.client.get(('/test_admin/%s/admin_views/fabric/' % self.urlbit))
self.assertEqual(response.status_code, 200)
self.assertTrue((('<a href="1/">Horizontal</a>' in response.content) and ('<a href="2/">Vertical</a>' in response.content)), "Changelist table isn't showing the r... |
'Ensures the filter UI shows correctly when at least one named group has
been used in the choices option of a model field.'
| def testNamedGroupFieldChoicesFilter(self):
| response = self.client.get(('/test_admin/%s/admin_views/fabric/' % self.urlbit))
self.assertEqual(response.status_code, 200)
self.assertTrue(('<div id="changelist-filter">' in response.content), 'Expected filter not found in changelist view.')
self.assertTrue((('<a href="?surface... |
'Check if the Javascript i18n view returns an empty language catalog
if the default language is non-English but the selected language
is English. See #13388 and #3594 for more details.'
| def testI18NLanguageNonEnglishDefault(self):
| try:
settings.LANGUAGE_CODE = 'fr'
activate('en-us')
response = self.client.get('/test_admin/admin/jsi18n/')
self.assertNotContains(response, 'Choisir une heure')
finally:
deactivate()
|
'Makes sure that the fallback language is still working properly
in cases where the selected language cannot be found.'
| def testI18NLanguageNonEnglishFallback(self):
| try:
settings.LANGUAGE_CODE = 'fr'
activate('none')
response = self.client.get('/test_admin/admin/jsi18n/')
self.assertContains(response, 'Choisir une heure')
finally:
deactivate()
|
'Check if L10N is deactivated, the Javascript i18n view doesn\'t
return localized date/time formats. Refs #14824.'
| def testL10NDeactivated(self):
| try:
settings.LANGUAGE_CODE = 'ru'
settings.USE_L10N = False
activate('ru')
response = self.client.get('/test_admin/admin/jsi18n/')
self.assertNotContains(response, '%d.%m.%Y %H:%M:%S')
self.assertContains(response, '%Y-%m-%d %H:%M:%S')
finally:
deac... |
'Regressions test for ticket 15103 - filtering on fields defined in a
ForeignKey \'limit_choices_to\' should be allowed, otherwise raw_id_fields
can break.'
| def test_allowed_filtering_15103(self):
| try:
self.client.get('/test_admin/admin/admin_views/inquisition/?leader__name=Palin&leader__age=27')
except SuspiciousOperation:
self.fail('Filters should be allowed if they are defined on a ForeignKey pointing to this model')
|
'JavaScript-assisted auto-focus on first field.'
| def testSingleWidgetFirsFieldFocus(self):
| response = self.client.get(('/test_admin/%s/admin_views/picture/add/' % self.urlbit))
self.assertContains(response, '<script type="text/javascript">document.getElementById("id_name").focus();</script>')
|
'JavaScript-assisted auto-focus should work if a model/ModelAdmin setup
is such that the first form field has a MultiWidget.'
| def testMultiWidgetFirsFieldFocus(self):
| response = self.client.get(('/test_admin/%s/admin_views/reservation/add/' % self.urlbit))
self.assertContains(response, '<script type="text/javascript">document.getElementById("id_start_date_0").focus();</script>')
|
'Ensure save as actually creates a new person'
| def test_save_as_duplication(self):
| post_data = {'_saveasnew': '', 'name': 'John M', 'gender': 1, 'age': 42}
response = self.client.post('/test_admin/admin/admin_views/person/1/', post_data)
self.assertEqual(len(Person.objects.filter(name='John M')), 1)
self.assertEqual(len(Person.objects.filter(id=1)), 1)
|
'Ensure that \'save as\' is displayed when activated and after submitting
invalid data aside save_as_new will not show us a form to overwrite the
initial model.'
| def test_save_as_display(self):
| response = self.client.get('/test_admin/admin/admin_views/person/1/')
self.assert_(response.context['save_as'])
post_data = {'_saveasnew': '', 'name': 'John M', 'gender': 3, 'alive': 'checked'}
response = self.client.post('/test_admin/admin/admin_views/person/1/', post_data)
self.assertEqual(resp... |
'Test setup.'
| def setUp(self):
| opts = Article._meta
add_user = User.objects.get(username='adduser')
add_user.user_permissions.add(get_perm(Article, opts.get_add_permission()))
change_user = User.objects.get(username='changeuser')
change_user.user_permissions.add(get_perm(Article, opts.get_change_permission()))
delete_user = U... |
'Make sure only staff members can log in.
Successful posts to the login page will redirect to the orignal url.
Unsuccessfull attempts will continue to render the login page with
a 200 status code.'
| def testLogin(self):
| request = self.client.get('/test_admin/admin/')
self.assertEqual(request.status_code, 200)
login = self.client.post('/test_admin/admin/', self.super_login)
self.assertRedirects(login, '/test_admin/admin/')
self.assertFalse(login.context)
self.client.get('/test_admin/admin/logout/')
request =... |
'Test add view restricts access and actually adds items.'
| def testAddView(self):
| add_dict = {'title': 'D\xc3\xb8m ikke', 'content': '<p>great article</p>', 'date_0': '2008-03-18', 'date_1': '10:54:39', 'section': 1}
self.client.get('/test_admin/admin/')
self.client.post('/test_admin/admin/', self.changeuser_login)
self.assertEqual(self.client.session.test_cookie_worked(), Fals... |
'Change view should restrict access and allow users to edit items.'
| def testChangeView(self):
| change_dict = {'title': 'Ikke ford\xc3\xb8mt', 'content': '<p>edited article</p>', 'date_0': '2008-03-18', 'date_1': '10:54:39', 'section': 1}
self.client.get('/test_admin/admin/')
self.client.post('/test_admin/admin/', self.adduser_login)
request = self.client.get('/test_admin/admin/admin_views/a... |
'Delete view should restrict access and actually delete items.'
| def testDeleteView(self):
| delete_dict = {'post': 'yes'}
self.client.get('/test_admin/admin/')
self.client.post('/test_admin/admin/', self.adduser_login)
request = self.client.get('/test_admin/admin/admin_views/article/1/delete/')
self.assertEqual(request.status_code, 403)
post = self.client.post('/test_admin/admin/admin_... |
'Objects should be nested to display the relationships that
cause them to be scheduled for deletion.'
| def test_nesting(self):
| pattern = re.compile('<li>Plot: <a href=".+/admin_views/plot/1/">World Domination</a>\\s*<ul>\\s*<li>Plot details: <a href=".+/admin_views/plotdetails/1/">almost finished</a>')
response = self.client.get(('/test_admin/admin/admin_views/villain/%s/delete/' % quote(1)))
self.assertTrue(pa... |
'Cyclic relationships should still cause each object to only be
listed once.'
| def test_cyclic(self):
| one = '<li>Cyclic one: <a href="/test_admin/admin/admin_views/cyclicone/1/">I am recursive</a>'
two = '<li>Cyclic two: <a href="/test_admin/admin/admin_views/cyclictwo/1/">I am recursive too</a>'
response = self.client.get(('/test_admin/admin/admin_views/cyclicone/%s/delete/... |
'If a deleted object has two relationships from another model,
both of those should be followed in looking for related
objects to delete.'
| def test_multiple_fkeys_to_same_model(self):
| should_contain = '<li>Plot: <a href="/test_admin/admin/admin_views/plot/1/">World Domination</a>'
response = self.client.get(('/test_admin/admin/admin_views/villain/%s/delete/' % quote(1)))
self.assertContains(response, should_contain)
response = self.client.get(('/test_admin/admin/admin_views/... |
'If a deleted object has two relationships pointing to it from
another object, the other object should still only be listed
once.'
| def test_multiple_fkeys_to_same_instance(self):
| should_contain = '<li>Plot: <a href="/test_admin/admin/admin_views/plot/2/">World Peace</a></li>'
response = self.client.get(('/test_admin/admin/admin_views/villain/%s/delete/' % quote(2)))
self.assertContains(response, should_contain, 1)
|
'In the case of an inherited model, if either the child or
parent-model instance is deleted, both instances are listed
for deletion, as well as any relationships they have.'
| def test_inheritance(self):
| should_contain = ['<li>Villain: <a href="/test_admin/admin/admin_views/villain/3/">Bob</a>', '<li>Super villain: <a href="/test_admin/admin/admin_views/supervillain/3/">Bob</a>', '<li>Secret hideout: floating castle', '<li>Super secret hideout: super floating castle!']
res... |
'If a deleted object has GenericForeignKeys pointing to it,
those objects should be listed for deletion.'
| def test_generic_relations(self):
| plot = Plot.objects.get(pk=3)
tag = FunkyTag.objects.create(content_object=plot, name='hott')
should_contain = '<li>Funky tag: hott'
response = self.client.get(('/test_admin/admin/admin_views/plot/%s/delete/' % quote(3)))
self.assertContains(response, should_contain)
|
'Retrieving the history for the object using urlencoded form of primary key should work'
| def test_get_history_view(self):
| response = self.client.get(('/test_admin/admin/admin_views/modelwithstringprimarykey/%s/history/' % quote(self.pk)))
self.assertContains(response, escape(self.pk))
self.assertEqual(response.status_code, 200)
|
'Retrieving the object using urlencoded form of primary key should work'
| def test_get_change_view(self):
| response = self.client.get(('/test_admin/admin/admin_views/modelwithstringprimarykey/%s/' % quote(self.pk)))
self.assertContains(response, escape(self.pk))
self.assertEqual(response.status_code, 200)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.