desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Returns Contact name if available, username otherwise'
| def __unicode__(self):
| contact = self.get_contact()
if contact:
return unicode(contact)
return unicode(self.name)
|
'Override to automatically set User.name from attached Django User'
| def save(self, *args, **kwargs):
| if ((not self.name) and self.user):
self.name = self.user.username
if (not self.default_group):
try:
self.default_group = Group.objects.all()[0]
except Exception:
pass
super(User, self).save(*args, **kwargs)
if (not self.id):
user_limit = getattr(s... |
'Returns absolute URL of the User'
| def get_absolute_url(self, module='identities'):
| if ((not module) or (module == 'identities')):
try:
return reverse('identities_user_view', args=[self.id])
except Exception:
return ''
else:
try:
return reverse('core_administration_user_view', args=[self.id])
except Exception:
retu... |
'Generates a new password and sets it to the user'
| def generate_new_password(self, size=8):
| password = ''.join([random.choice((string.letters + string.digits)) for i in range(size)])
self.user.set_password(password)
self.user.save()
return password
|
'Returns the list of all groups the user belongs to'
| def get_groups(self):
| groups = list(self.other_groups.all())
groups.append(self.default_group)
return groups
|
'Helper for User.has_permissions(), accepts only one character for mode'
| def _check_permission(self, obj, mode='r'):
| query = models.Q(pk=self.id)
for group in self.get_groups():
if group:
query = (query | models.Q(pk=group.id))
if obj.full_access.filter(query).exists():
return True
if ((mode == 'r') or (mode == 'x')):
if obj.read_access.filter(query).exists():
return Tru... |
'Checks permissions on a given object for a given mode'
| def has_permission(self, obj, mode='r'):
| if (self.is_admin() or (not obj)):
return True
for imode in mode:
if (not self._check_permission(obj, imode)):
return False
return True
|
'True if the user has write permissions on the given module'
| def is_admin(self, module_name=''):
| access = False
if (not module_name):
module_name = 'treeio.core'
try:
module = Module.objects.get(name=module_name)
access = self._check_permission(module, mode='w')
except Module.DoesNotExist:
pass
if (access or (module_name == 'treeio.core')):
return access
... |
'String username, picked up from attached Django User or self.name string otherwise'
| def get_username(self):
| if self.user:
return self.user.username
return self.name
|
'Returns currently set Perspective for the User'
| def get_perspective(self):
| ids = []
try:
for setting in ModuleSetting.get_for_module('treeio.core', name='default_perspective', user=self):
ids.append(long(setting.value))
perspective_id = ids[0]
perspective = get_object_or_404(Perspective, pk=perspective_id)
except:
try:
perspe... |
'Sets the Perspective for the User'
| def set_perspective(self, perspective):
| ModuleSetting.set_for_module('default_perspective', perspective.id, 'treeio.core', user=self)
modules = (perspective.modules.all() or Module.objects.all())
for module in modules:
if (not self.has_permission(module)):
module.read_access.add(self)
|
'Returns first available Contact'
| def get_contact(self):
| try:
return self.contact_set.all()[0]
except Exception:
return None
|
'Returns true if any Contacts exist for this User'
| def has_contact(self):
| try:
return self.contact_set.exists()
except Exception:
return False
|
'Create a hash automatically'
| def __init__(self, *args, **kwargs):
| super(Invitation, self).__init__(*args, **kwargs)
if (self.email and (not self.key)):
hasher = hashlib.sha256()
hasher.update((str(random.random()) + str(self.email)))
self.key = hasher.hexdigest()
|
'Helper for filter_permitted(), accepts one character per mode'
| def _get_query_filter_permitted(user, mode='r', filter_trash=True):
| query = models.Q()
if (not user.is_admin()):
query = (models.Q(full_access=user) | models.Q(full_access__isnull=True))
query = ((query | models.Q(full_access=user.default_group)) | models.Q(full_access__in=user.other_groups.all()))
if ((mode == 'r') or (mode == 'x')):
query =... |
'Returns Objects the given user is allowed to access, depending on mode - read(r), write(w) or execute(x)'
| def filter_permitted(user, manager, mode='r', filter_trash=True):
| if (not user):
return []
query = models.Q()
for imode in mode:
query = (query & Object._get_query_filter_permitted(user, imode, filter_trash))
objects = manager.filter(query).distinct()
return objects
|
'Returns Objects the current user is allowed to access, depending on mode - read(r), write(w) or execute(x)'
| def filter_by_request(request, manager, mode='r', filter_trash=True):
| user = None
if request.user.username:
try:
user = request.user.profile
except MultipleObjectsReturned:
user = User.objects.filter(user__id=request.user.id)[0]
if user:
return Object.filter_permitted(user, manager, mode, filter_trash)
return []
|
'String representation'
| def __unicode__(self):
| try:
return unicode(self.get_related_object())
except Exception:
return (((unicode(self.object_type) + ' [') + unicode(self.id)) + ']')
|
'Override to auto-detect object type and set default user if unset'
| def save(self, *args, **kwargs):
| try:
name = self.__unicode__()
if (not (name == self.object_name)):
self.object_name = name[0:510]
except:
pass
types = re.findall("'(.+)'", str(self.__class__))
if types:
self.object_type = types[0]
return super(Object, self).save(*args, **kwargs)
|
'Returns the module for this object, e.g. \'projects\''
| def get_object_module(self):
| return getattr(self._meta, 'app_label', None)
|
'Returns a list of items generated from self.nuvius_resource
The convention used is:
Each item is specified as \'#id.key#\' separated by commas
Returns items as tuples (id, key) from self.nuvius_resource'
| def get_nuvius_resources(self):
| resources = []
if self.nuvius_resource:
text = unicode(self.nuvius_resource)
splits = text.split(',')
for bit in splits:
res = bit.strip('#').split('.', 1)
resources.append(res)
return resources
|
'Add a Nuvius resource to self.nuvius_resource'
| def add_nuvius_resource(self, resource_id, key=None):
| existing = [res[0] for res in self.get_nuvius_resources()]
if (not (unicode(resource_id) in existing)):
new = ('#' + unicode(resource_id))
if key:
new += ('.' + unicode(key))
new += '#'
if self.nuvius_resource:
self.nuvius_resource += (',' + new)
e... |
'Get the root element, for objects implementing a tree-like structure via .parent'
| def get_root(self):
| root = self
stack = [self]
while getattr(root, 'parent', None):
root = getattr(root, 'parent')
if (root in stack):
break
stack.append(root)
return root
|
'Get tree path as a list() starting with root element,
for objects implementing a tree-like structure via .parent'
| def get_tree_path(self, skipself=False):
| if skipself:
path = []
else:
path = [self]
current = self
while getattr(current, 'parent', None):
parent = getattr(current, 'parent')
if (parent in path):
break
else:
path.insert(0, parent)
current = parent
return path
|
'Returns a child object which inherits from self, if exists'
| def get_related_object(self):
| try:
obj_name = re.match('.*\\.(?P<name>\\w+)$', self.object_type).group('name')
return getattr(self, obj_name.lower())
except Exception:
return None
|
'Returns prettified name of the object type'
| def get_human_type(self, translate=True):
| try:
obj_name = re.match('.*\\.(?P<name>\\w+)$', self.object_type).group('name')
pattern = re.compile('([A-Z][A-Z][a-z])|([a-z][A-Z])')
human_type = pattern.sub((lambda m: ((m.group()[:1] + ' ') + m.group()[1:])), obj_name)
if translate:
human_type = _(human_type)
... |
'Returns a URL to the child object, if available'
| def get_absolute_url(self):
| try:
return self.get_related_object().get_absolute_url()
except Exception:
return ''
|
'Returns True if the item should be included in Search index'
| def is_searchable(self):
| return getattr(self, 'searchable', True)
|
'Returns True if item is attached to some other Object and serves as a part of it'
| def is_attached(self):
| return getattr(self, 'attached', False)
|
'Constructs a search item as a dictionary with title, content and URL'
| def get_search_item(self):
| obj = self.get_related_object()
if (not obj):
obj = self
item = {'id': u'', 'name': u'', 'type': unicode(obj.get_human_type()), 'content': u'', 'url': unicode(obj.get_absolute_url())}
if obj.id:
item['id'] = unicode(obj.id)
if hasattr(obj, 'title'):
item['name'] = unicode(obj... |
'Creates an UpdateRecord to be submitted to all subscribers of an Object'
| def create_notification(self, action='update', author=None, *args, **kwargs):
| if (not (self.subscribers.all().count() or author)):
return None
notification = UpdateRecord()
updated = False
if (action == 'delete'):
notification.format_message = '%s "%s" deleted.'
notification.set_format_strings([unicode(self.get_human_type(translate=False)), unicode(s... |
'Sets owner of the Object to the given user
:param User:'
| def set_user(self, user):
| if (user is None):
return self
if isinstance(user, django_auth.User):
user = user.profile
elif (not isinstance(user, User)):
raise ValueError(('user argument should be either a django_auth.User or treeio.core.User object got %s' % type(user)))
try... |
'Sets the user defined in settings.HARDTREE_DEFAULT_USER_ID and default mode'
| def set_default_user(self):
| try:
user = User.objects.get(pk=settings.HARDTREE_DEFAULT_USER_ID)
except:
try:
user = User.objects.all()[0]
except IndexError:
user = None
self.set_user(user)
return self
|
'Sets the user to the current in request and default mode for the user'
| def set_user_from_request(self, request, mode=None):
| user = request.user.profile
self.set_user(user)
return self
|
'Copies all permissions from object. Existing permissions will NOT be removed or dropped'
| def copy_permissions(self, object):
| read_access = object.read_access.all()
for entity in read_access:
self.read_access.add(entity)
full_access = object.full_access.all()
for entity in full_access:
self.full_access.add(entity)
return self
|
'Returns list of fields for given object'
| def get_fields(self):
| return filter((lambda f: (f.name not in settings.HARDTREE_OBJECT_BLACKLIST)), self._meta.fields)
|
'Returns list of field names for given object'
| def get_field_names(self):
| x = []
for f in self._meta.fields:
if (f.name not in settings.HARDTREE_OBJECT_BLACKLIST):
x.append(f.name)
for f in self._meta.many_to_many:
if (f.name not in settings.HARDTREE_OBJECT_BLACKLIST):
x.append(f.name)
return x
|
'Returns the value of a given field'
| def get_field_value(self, field_name, default=None):
| value = getattr(self, field_name, default)
if hasattr(value, 'all'):
value = value.all()
if hasattr(self, ('get_%s_display' % field_name)):
try:
value = getattr(self, ('get_%s_display' % field_name))()
except:
pass
return value
|
'Sets the value of a given field'
| def set_field_value(self, field_name, value):
| return setattr(self, field_name)
|
'Sets .author to current user and .sender to user\'s Contact (if available)'
| def set_user_from_request(self, request):
| user = request.user.profile
self.author = user
self.recipients.add(user)
contact = user.get_contact()
if contact:
self.sender = contact
self.save()
|
'Sets format_strings to the list of strings'
| def set_format_strings(self, strings):
| self.format_strings = base64.b64encode(pickle.dumps(strings, pickle.HIGHEST_PROTOCOL))
return self
|
'Extends existing format strings'
| def extend_format_strings(self, strings):
| existing = self.get_format_strings()
if existing:
existing.extend(strings)
else:
existing = strings
self.set_format_strings(existing)
return self
|
'Gets format_strings as a list of strings'
| def get_format_strings(self):
| result = None
if self.format_strings:
try:
result = pickle.loads(base64.b64decode(self.format_strings))
except pickle.PickleError:
pass
return result
|
'Returns translatable message in the current language with all attributes applied'
| def get_format_message(self):
| strings = self.get_format_strings()
result = ''
if self.format_message:
result = self.format_message
if (result and strings):
try:
translated = []
for item in strings:
if item:
translated.append(_(item))
else:
... |
'Return full message'
| def get_full_message(self):
| result = ''
format_message = self.get_format_message()
if format_message:
result += format_message
if self.body:
result += (('<p>' + self.body) + '</p>')
if result.endswith('<br />'):
result = result[:(len(result) - 6)]
return result
|
'Returns absolute URL'
| def get_absolute_url(self):
| try:
return reverse('core_admin_module_view', args=[self.id])
except Exception:
pass
|
'Returns absolute URL'
| def get_absolute_url(self):
| try:
return reverse('core_admin_perspective_view', args=[self.id])
except Exception:
pass
|
'Get Modules'
| def get_modules(self):
| modules = self.modules.all()
if (not modules):
modules = Module.objects.all()
return modules
|
'Unpickle a ModuleSetting value'
| def loads(self):
| result = None
if self.value:
try:
result = pickle.loads(base64.b64decode(self.value))
except pickle.PickleError:
pass
return result
|
'Pickle a ModuleSetting value'
| def dumps(self, value):
| self.value = base64.b64encode(pickle.dumps(value, pickle.HIGHEST_PROTOCOL))
return self
|
'Setting getter'
| def get(name='', strict=False, **kwargs):
| if name:
settings_qs = ModuleSetting.objects.filter(name=name)
else:
settings_qs = ModuleSetting.objects.all()
if strict:
settings_qs = settings_qs.filter(**kwargs)
elif settings_qs:
new_settings = settings_qs
for arg in kwargs:
new_settings = new_sett... |
'Get a setting per module'
| def get_for_module(module_name, name='', strict=False, **kwargs):
| try:
module = Module.objects.get(name=module_name)
return ModuleSetting.get(name=name, module=module, strict=strict, **kwargs)
except Exception:
return None
|
'Define a ModuleSetting'
| def set(name, value, **kwargs):
| existing = ModuleSetting.objects.filter(name=name, **kwargs)
if existing:
for setting in existing:
setting.value = value
setting.save()
else:
setting = ModuleSetting(name=name, value=value, **kwargs)
setting.save()
return setting
|
'Add a ModuleSetting'
| def add(name, value, **kwargs):
| setting = ModuleSetting(name=name, value=value, **kwargs)
setting.save()
return setting
|
'Define a ModuleSetting per module'
| def set_for_module(name, value, module_name, **kwargs):
| try:
module = Module.objects.get(name=module_name)
return ModuleSetting.set(name=name, value=value, module=module, **kwargs)
except Exception:
return None
|
'Add a ModuleSetting per module'
| def add_for_module(name, value, module_name, **kwargs):
| try:
module = Module.objects.get(name=module_name)
return ModuleSetting.add(name=name, value=value, module=module, **kwargs)
except Exception:
return None
|
'Override to set label from name if undefined'
| def save(self, *args, **kwargs):
| if (not self.label):
self.label = self.name
super(ModuleSetting, self).save(*args, **kwargs)
|
'Unpickle a ModuleSetting value'
| def loads(self):
| result = None
try:
result = pickle.loads(base64.b64decode(self.value))
except:
result = self.value
return result
|
'Pickle a ModuleSetting value'
| def dumps(self, value):
| self.value = base64.b64encode(pickle.dumps(value, pickle.HIGHEST_PROTOCOL))
return self
|
'Initialize an Integration Resource'
| def __init__(self, nuvius_id, resource_id, resource_name, services='', role='slave'):
| self.nuvius_id = nuvius_id
self.resource_id = resource_id
self.resource_name = resource_name
self.services = services
if (not self.service):
self.service = getattr(settings, 'NUVIUS_SERVICES', '')
self.role = role
|
'Returns absolute URL'
| def get_absolute_url(self):
| try:
return reverse('identities_location_view', args=[self.id])
except Exception:
pass
|
'Returns absolute URL'
| def get_absolute_url(self):
| try:
return reverse('core_admin_pagefolder_view', args=[self.id])
except Exception:
pass
|
'Returns absolute URL'
| def get_absolute_url(self):
| try:
return reverse('core_admin_page_view', args=[self.id])
except Exception:
pass
|
'Migrate the Users and Groups so they extend AccessEntity'
| def forwards(self, orm):
| for user in orm['core.User'].objects.all():
entity = orm['core.AccessEntity'].objects.create()
entity.id = user.id
entity.save()
user.accessentity_ptr = entity
user.save()
for group in orm['core.Group'].objects.all():
group.accessentity_ptr = orm['core.AccessEntit... |
'Initial Setup'
| def setUp(self):
| if (not self.prepared):
Object.objects.all().delete()
(self.group, created) = Group.objects.get_or_create(name='test')
(duser, created) = DjangoUser.objects.get_or_create(username=self.username)
duser.set_password(self.password)
duser.save()
(self.user, created) = Use... |
'Test index page at /admin/api/users'
| def test_unauthenticated_access(self):
| response = self.client.get('/admin/api/users')
self.assertEquals(response.status_code, 404)
|
'Test index page api /admin/api/groups'
| def test_get_ticket_groups_list(self):
| response = self.client.get(path=reverse('api_admin_groups'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
|
'Test index page api /admin/api/users'
| def test_get_ticket_users_list(self):
| response = self.client.get(path=reverse('api_admin_users'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
|
'Test index page api /admin/api/modules'
| def test_get_ticket_modules_list(self):
| response = self.client.get(path=reverse('api_admin_modules'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
|
'Test index page api /admin/api/perspectives'
| def test_get_ticket_perspectives_list(self):
| response = self.client.get(path=reverse('api_admin_perspectives'), **self.authentication_headers)
self.assertEquals(response.status_code, 200)
|
'Sets choices and initial value'
| def __init__(self, user, *args, **kwargs):
| super(SettingsForm, self).__init__(*args, **kwargs)
self.fields['default_perspective'].queryset = Perspective.objects.all()
try:
conf = ModuleSetting.get_for_module('treeio.core', 'default_perspective')[0]
default_perspective = Perspective.objects.get(pk=long(conf.value))
self.fields... |
'Returns an upload_to path to a new file'
| def _get_upload_name(self, filename):
| while True:
hasher = hashlib.md5()
hasher.update(str(random.random()))
filepath = (((u'core/' + hasher.hexdigest()) + u'__') + filename)
fullpath = (settings.MEDIA_ROOT + filepath)
if (not default_storage.exists(fullpath)):
return filepath
|
'Process an uploaded file'
| def _handle_uploaded_file(self, field_name):
| try:
file = self.files[field_name]
filepath = self._get_upload_name(file.name)
except KeyError:
return ''
destination = open((settings.MEDIA_ROOT + filepath), 'wb+')
for chunk in file.chunks():
destination.write(chunk)
destination.close()
return filepath
|
'Form processor'
| def save(self):
| try:
ModuleSetting.set_for_module('default_perspective', self.cleaned_data['default_perspective'].id, 'treeio.core')
ModuleSetting.set_for_module('default_permissions', self.cleaned_data['default_permissions'], 'treeio.core')
ModuleSetting.set_for_module('default_timezone', self.cleaned_data... |
'Clean Name'
| def clean_name(self):
| data = self.cleaned_data['name']
query = Q(name=data)
if (self.instance and self.instance.id):
query = (query & (~ Q(id=self.instance.id)))
existing = User.objects.filter(query)
if existing:
raise forms.ValidationError((_('User with username %s already exists.') % data... |
'Clean password again'
| def clean_password_again(self):
| password1 = self.cleaned_data['password']
password2 = self.cleaned_data['password_again']
if (not (password1 == password2)):
raise forms.ValidationError(_('Passwords do not match'))
return password2
|
'Ensure the admin does not go over subscription limit by re-enabling users'
| def clean_disabled(self):
| enable = (not self.cleaned_data['disabled'])
if (self.instance and self.instance.id and enable and self.instance.disabled):
user_limit = getattr(settings, 'HARDTREE_SUBSCRIPTION_USER_LIMIT', 0)
if (user_limit > 0):
user_number = User.objects.filter(disabled=False).count()
... |
'Form processor'
| def save(self, *args, **kwargs):
| if self.instance.id:
self.instance.user.username = self.instance.name
self.instance.user.save()
super(UserForm, self).save(*args, **kwargs)
else:
new_user = django_auth.User(username=self.cleaned_data['name'], password='')
new_user.set_password(self.cleaned_data['password... |
'Clean New Password Again'
| def clean_new_password_again(self):
| password1 = self.cleaned_data['new_password']
password2 = self.cleaned_data['new_password_again']
if (not (password1 == password2)):
raise forms.ValidationError(_('Passwords do not match'))
return password2
|
'Save'
| def save(self):
| password1 = self.cleaned_data['new_password']
self.user.set_password(password1)
return self.user.save()
|
'Populates form with fields from given ContactType'
| def __init__(self, contact_type, instance=None, *args, **kwargs):
| if instance:
self.instance = instance
values = instance.contactvalue_set.all()
super(ContactForm, self).__init__(*args, **kwargs)
self.fields['name'].label = _('Name')
if ('files' in kwargs):
self.files = kwargs['files']
for field in contact_type.fields.all():
if self... |
'Test Group model'
| def test_model_Group_basic(self):
| name = 'testgroup'
obj = Group(name=name)
obj.save()
self.assertIsNone(obj.parent)
self.assertIsNone(obj.details)
self.assertQuerysetEqual(obj.child_set.all(), [])
self.assertEqual(obj.get_absolute_url(), '/contacts/group/view/{}'.format(obj.id))
self.assertEqual(obj.get_root(), obj)
... |
'Test User model'
| def test_model_User_profile(self):
| username = 'testusername'
password = 'password'
user = DjangoUser(username=username)
user.set_password(password)
user.save()
self.assertEquals(user.username, username)
self.assertIsNotNone(user.id)
profile = user.profile
self.assertEquals(profile.name, username)
self.assertEquals... |
'Test Module model with minimum parameters'
| def test_model_Module_basic(self):
| name = 'test module'
title = 'Test title'
url = '/test_url/'
obj = Module(name=name, title=title, url=url)
obj.save()
self.assertIsNotNone(obj.id)
obj = Module.objects.get(id=obj.id)
self.assertEquals(obj.name, name)
self.assertEquals(obj.title, title)
self.assertEquals(obj... |
'Test Perspective model with minimum parameters'
| def test_model_Perspective_basic(self):
| name = 'test'
obj = Perspective(name=name)
obj.save()
self.assertIsNotNone(obj.id)
obj = Perspective.objects.get(id=obj.id)
self.assertEqual(obj.name, name)
self.assertEqual(obj.details, '')
self.assertQuerysetEqual(obj.modules.all(), [])
self.assertQuerysetEqual(obj.get_modules(), m... |
'Test Perspective model with all parameters'
| def test_model_Perspective_full(self):
| name = 'test'
details = 'perspective details'
obj = Perspective(name='test', details=details)
obj.save()
self.assertIsNotNone(obj.id)
obj = Perspective.objects.get(id=obj.id)
self.assertEqual(obj.name, name)
self.assertEqual(obj.details, details)
module = Module.objects.all()[0]
... |
'Test logout page at /logout'
| def test_user_logout(self):
| response = self.client.get(reverse('user_logout'))
self.assertRedirects(response, reverse('user_login'))
self.assertNotIn('_auth_user_id', self.client.session)
|
'Test login page at /login'
| def test_user_login(self):
| response = self.client.post(reverse('user_login'), {'username': self.username, 'password': self.password})
self.assertRedirects(response, reverse('user_denied'))
|
'Test home page with login at /'
| def test_home_login(self):
| response = self.client.get('/')
self.assertEquals(response.status_code, 200)
self.assertEqual(self.client.session['_auth_user_id'], self.user.pk)
|
'Test page with login at /admin/perspectives/'
| def test_index_perspectives_login(self):
| response = self.client.get(reverse('core_admin_index_perspectives'))
self.assertEquals(response.status_code, 200)
|
'Test index page with login at /admin/perspective/add'
| def test_perspective_add(self):
| response = self.client.get(reverse('core_admin_perspective_add'))
self.assertEquals(response.status_code, 200)
|
'Test index page with login at /admin/perspective/view/<perspective_id>'
| def test_perspective_view(self):
| response = self.client.get(reverse('core_admin_perspective_view', args=[self.perspective.id]))
self.assertEquals(response.status_code, 200)
|
'Test index page with login at /admin/perspective/edit/<perspective_id>'
| def test_perspective_edit(self):
| response = self.client.get(reverse('core_admin_perspective_edit', args=[self.perspective.id]))
self.assertEquals(response.status_code, 200)
|
'Test index page with login at /admin/perspective/delete/<perspective_id>'
| def test_perspective_delete(self):
| response = self.client.get(reverse('core_admin_perspective_delete', args=[self.perspective.id]))
self.assertEquals(response.status_code, 200)
|
'Test page with login at /admin/modules/'
| def test_index_modules_login(self):
| response = self.client.get(reverse('core_admin_index_modules'))
self.assertEquals(response.status_code, 200)
|
'Test page with login at /admin/users/'
| def test_index_users_login(self):
| response = self.client.get(reverse('core_admin_index_users'))
self.assertEquals(response.status_code, 200)
|
'Test page with login at /admin/user/add'
| def test_core_user_add(self):
| name = 'newuser'
password = 'newuserpsw'
data = {'name': name, 'password': password, 'password_again': password}
response = self.client.post(path=reverse('core_admin_user_add'), data=data)
self.assertEquals(response.status_code, 302)
profile = User.objects.get(name=name)
self.assertEquals(pr... |
'Test page with login at /admin/user/delete'
| def test_core_user_delete(self):
| name = 'newuser'
password = 'newuserpsw'
(user, created) = DjangoUser.objects.get_or_create(username=name)
if created:
user.set_password(password)
user.save()
response = self.client.post(path=reverse('core_admin_user_delete', args=[user.profile.id]), data={'delete': ''})
self.ass... |
'Test page with login at /admin/user/invite'
| def test_core_user_invite(self):
| response = self.client.get(reverse('core_admin_user_invite'))
self.assertEquals(response.status_code, 200)
|
'Test page with login at /admin/groups/'
| def test_index_groups_login(self):
| response = self.client.get(reverse('core_admin_index_groups'))
self.assertEquals(response.status_code, 200)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.