desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Most session backends don\'t need to override this method, but we do,
because instead of generating a random string, we want to actually
generate a secure url-safe Base64-encoded string of data as our
session key.'
| def _get_session_key(self):
| session_cache = getattr(self, '_session_cache', {})
return signing.dumps(session_cache, compress=True, salt='django.contrib.sessions.backends.signed_cookies', serializer=PickleSerializer)
|
'Returns the given session dictionary pickled and encoded as a string.'
| def encode(self, session_dict):
| pickled = pickle.dumps(session_dict, pickle.HIGHEST_PROTOCOL)
hash = self._hash(pickled)
return base64.b64encode(((hash.encode() + ':') + pickled)).decode(u'ascii')
|
'Returns session key that isn\'t being used.'
| def _get_new_session_key(self):
| while True:
session_key = get_random_string(32, VALID_KEY_CHARS)
if (not self.exists(session_key)):
break
return session_key
|
'Lazily loads session from storage (unless "no_load" is True, when only
an empty dict is stored) and stores it in the current instance.'
| def _get_session(self, no_load=False):
| self.accessed = True
try:
return self._session_cache
except AttributeError:
if ((self.session_key is None) or no_load):
self._session_cache = {}
else:
self._session_cache = self.load()
return self._session_cache
|
'Get the number of seconds until the session expires.
Optionally, this function accepts `modification` and `expiry` keyword
arguments specifying the modification and expiry of the session.'
| def get_expiry_age(self, **kwargs):
| try:
modification = kwargs[u'modification']
except KeyError:
modification = timezone.now()
try:
expiry = kwargs[u'expiry']
except KeyError:
expiry = self.get(u'_session_expiry')
if (not expiry):
return settings.SESSION_COOKIE_AGE
if (not isinstance(expiry, datetime)):
return expiry
delta = (expiry - modification)
return ((delta.days * 86400) + delta.seconds)
|
'Get session the expiry date (as a datetime object).
Optionally, this function accepts `modification` and `expiry` keyword
arguments specifying the modification and expiry of the session.'
| def get_expiry_date(self, **kwargs):
| try:
modification = kwargs[u'modification']
except KeyError:
modification = timezone.now()
try:
expiry = kwargs[u'expiry']
except KeyError:
expiry = self.get(u'_session_expiry')
if isinstance(expiry, datetime):
return expiry
if (not expiry):
expiry = settings.SESSION_COOKIE_AGE
return (modification + timedelta(seconds=expiry))
|
'Sets a custom expiration for the session. ``value`` can be an integer,
a Python ``datetime`` or ``timedelta`` object or ``None``.
If ``value`` is an integer, the session will expire after that many
seconds of inactivity. If set to ``0`` then the session will expire on
browser close.
If ``value`` is a ``datetime`` or ``timedelta`` object, the session
will expire at that specific future time.
If ``value`` is ``None``, the session uses the global session expiry
policy.'
| def set_expiry(self, value):
| if (value is None):
try:
del self[u'_session_expiry']
except KeyError:
pass
return
if isinstance(value, timedelta):
value = (timezone.now() + value)
self[u'_session_expiry'] = value
|
'Returns ``True`` if the session is set to expire when the browser
closes, and ``False`` if there\'s an expiry date. Use
``get_expiry_date()`` or ``get_expiry_age()`` to find the actual expiry
date/age, if there is one.'
| def get_expire_at_browser_close(self):
| if (self.get(u'_session_expiry') is None):
return settings.SESSION_EXPIRE_AT_BROWSER_CLOSE
return (self.get(u'_session_expiry') == 0)
|
'Removes the current session data from the database and regenerates the
key.'
| def flush(self):
| self.clear()
self.delete()
self.create()
|
'Creates a new session key, whilst retaining the current session data.'
| def cycle_key(self):
| data = self._session_cache
key = self.session_key
self.create()
self._session_cache = data
self.delete(key)
|
'Returns True if the given session_key already exists.'
| def exists(self, session_key):
| raise NotImplementedError
|
'Creates a new session instance. Guaranteed to create a new object with
a unique key and will have saved the result once (with empty data)
before the method returns.'
| def create(self):
| raise NotImplementedError
|
'Saves the session data. If \'must_create\' is True, a new session object
is created (otherwise a CreateError exception is raised). Otherwise,
save() can update an existing object with the same key.'
| def save(self, must_create=False):
| raise NotImplementedError
|
'Deletes the session data under this key. If the key is None, the
current session key value is used.'
| def delete(self, session_key=None):
| raise NotImplementedError
|
'Loads the session data and returns a dictionary.'
| def load(self):
| raise NotImplementedError
|
'Remove expired sessions from the session store.
If this operation isn\'t possible on a given backend, it should raise
NotImplementedError. If it isn\'t necessary, because the backend has
a built-in expiration mechanism, it should be a no-op.'
| @classmethod
def clear_expired(cls):
| raise NotImplementedError
|
'Get the file associated with this session key.'
| def _key_to_file(self, session_key=None):
| if (session_key is None):
session_key = self._get_or_create_session_key()
if (not set(session_key).issubset(set(VALID_KEY_CHARS))):
raise SuspiciousOperation('Invalid characters in session key')
return os.path.join(self.storage_path, (self.file_prefix + session_key))
|
'Return the modification time of the file storing the session\'s content.'
| def _last_modification(self):
| modification = os.stat(self._key_to_file()).st_mtime
if settings.USE_TZ:
modification = datetime.datetime.utcfromtimestamp(modification)
modification = modification.replace(tzinfo=timezone.utc)
else:
modification = datetime.datetime.fromtimestamp(modification)
return modification
|
'Removes the current session data from the database and regenerates the
key.'
| def flush(self):
| self.clear()
self.delete(self.session_key)
self.create()
|
'Returns the given session dictionary pickled and encoded as a string.'
| def encode(self, session_dict):
| return SessionStore().encode(session_dict)
|
'Test we can use Session.get_decoded to retrieve data stored
in normal way'
| def test_session_get_decoded(self):
| self.session['x'] = 1
self.session.save()
s = Session.objects.get(session_key=self.session.session_key)
self.assertEqual(s.get_decoded(), {'x': 1})
|
'Test SessionManager.save method'
| def test_sessionmanager_save(self):
| self.session['y'] = 1
self.session.save()
s = Session.objects.get(session_key=self.session.session_key)
Session.objects.save(s.session_key, {'y': 2}, s.expire_date)
del self.session._session_cache
self.assertEqual(self.session['y'], 2)
|
'Test clearsessions command for clearing expired sessions.'
| @override_settings(SESSION_ENGINE='django.contrib.sessions.backends.db')
def test_clearsessions_command(self):
| self.assertEqual(0, Session.objects.count())
self.session['foo'] = 'bar'
self.session.set_expiry(3600)
self.session.save()
other_session = self.backend()
other_session['foo'] = 'bar'
other_session.set_expiry((-3600))
other_session.save()
self.assertEqual(2, Session.objects.count())
management.call_command('clearsessions')
self.assertEqual(1, Session.objects.count())
|
'Test clearsessions command for clearing expired sessions.'
| @override_settings(SESSION_ENGINE='django.contrib.sessions.backends.file')
def test_clearsessions_command(self):
| storage_path = self.backend._get_storage_path()
file_prefix = settings.SESSION_COOKIE_NAME
def count_sessions():
return len([session_file for session_file in os.listdir(storage_path) if session_file.startswith(file_prefix)])
self.assertEqual(0, count_sessions())
self.session['foo'] = 'bar'
self.session.set_expiry(3600)
self.session.save()
other_session = self.backend()
other_session['foo'] = 'bar'
other_session.set_expiry((-3600))
other_session.save()
self.assertEqual(2, count_sessions())
management.call_command('clearsessions')
self.assertEqual(1, count_sessions())
|
'This test tested exists() in the other session backends, but that
doesn\'t make sense for us.'
| def test_save(self):
| pass
|
'This test tested cycle_key() which would create a new session
key for the same session data. But we can\'t invalidate previously
signed cookies (other than letting them expire naturally) so
testing for this behavior is meaningless.'
| def test_cycle(self):
| pass
|
'If request.session was modified, or if the configuration is to save the
session every time, save the changes and set a session cookie.'
| def process_response(self, request, response):
| try:
accessed = request.session.accessed
modified = request.session.modified
except AttributeError:
pass
else:
if accessed:
patch_vary_headers(response, ('Cookie',))
if (modified or settings.SESSION_SAVE_EVERY_REQUEST):
if request.session.get_expire_at_browser_close():
max_age = None
expires = None
else:
max_age = request.session.get_expiry_age()
expires_time = (time.time() + max_age)
expires = cookie_date(expires_time)
if (response.status_code != 500):
request.session.save()
response.set_cookie(settings.SESSION_COOKIE_NAME, request.session.session_key, max_age=max_age, expires=expires, domain=settings.SESSION_COOKIE_DOMAIN, path=settings.SESSION_COOKIE_PATH, secure=(settings.SESSION_COOKIE_SECURE or None), httponly=(settings.SESSION_COOKIE_HTTPONLY or None))
return response
|
'Returns the current ``Site`` based on the SITE_ID in the
project\'s settings. The ``Site`` object is cached the first
time it\'s retrieved from the database.'
| def get_current(self):
| from django.conf import settings
try:
sid = settings.SITE_ID
except AttributeError:
from django.core.exceptions import ImproperlyConfigured
raise ImproperlyConfigured('You\'re using the Django "sites framework" without having set the SITE_ID setting. Create a site in your database and set the SITE_ID setting to fix this error.')
try:
current_site = SITE_CACHE[sid]
except KeyError:
current_site = self.get(pk=sid)
SITE_CACHE[sid] = current_site
return current_site
|
'Clears the ``Site`` object cache.'
| def clear_cache(self):
| global SITE_CACHE
SITE_CACHE = {}
|
'Executing the changepassword management command should change joe\'s password'
| def test_that_changepassword_command_changes_joes_password(self):
| self.assertTrue(self.user.check_password(u'qwerty'))
command = changepassword.Command()
command._get_pass = (lambda *args: u'not qwerty')
command.execute(u'joe', stdout=self.stdout)
command_output = self.stdout.getvalue().strip()
self.assertEqual(command_output, u"Changing password for user 'joe'\nPassword changed successfully for user 'joe'")
self.assertTrue(models.User.objects.get(username=u'joe').check_password(u'not qwerty'))
|
'A CommandError should be thrown by handle() if the user enters in
mismatched passwords three times.'
| def test_that_max_tries_exits_1(self):
| command = changepassword.Command()
command._get_pass = (lambda *args: (args or u'foo'))
with self.assertRaises(CommandError):
command.execute(u'joe', stdout=self.stdout, stderr=self.stderr)
|
'Check the operation of the createsuperuser management command'
| def test_createsuperuser(self):
| new_io = StringIO()
call_command(u'createsuperuser', interactive=False, username=u'joe', email=u'[email protected]', stdout=new_io)
command_output = new_io.getvalue().strip()
self.assertEqual(command_output, u'Superuser created successfully.')
u = User.objects.get(username=u'joe')
self.assertEqual(u.email, u'[email protected]')
self.assertFalse(u.has_usable_password())
|
'A superuser can be created when a custom User model is in use'
| @override_settings(AUTH_USER_MODEL=u'auth.CustomUser')
def test_swappable_user(self):
| new_io = StringIO()
call_command(u'createsuperuser', interactive=False, email=u'[email protected]', date_of_birth=u'1976-04-01', stdout=new_io, skip_validation=True)
command_output = new_io.getvalue().strip()
self.assertEqual(command_output, u'Superuser created successfully.')
u = CustomUser._default_manager.get(email=u'[email protected]')
self.assertEqual(u.date_of_birth, date(1976, 4, 1))
self.assertFalse(u.has_usable_password())
|
'A Custom superuser won\'t be created when a required field isn\'t provided'
| @override_settings(AUTH_USER_MODEL=u'auth.CustomUser')
def test_swappable_user_missing_required_field(self):
| new_io = StringIO()
with self.assertRaises(CommandError):
call_command(u'createsuperuser', interactive=False, username=u'[email protected]', stdout=new_io, stderr=new_io, skip_validation=True)
self.assertEqual(CustomUser._default_manager.count(), 0)
|
'USERNAME_FIELD should not appear in REQUIRED_FIELDS.'
| @override_settings(AUTH_USER_MODEL=u'auth.CustomUserBadRequiredFields')
def test_username_not_in_required_fields(self):
| new_io = StringIO()
get_validation_errors(new_io, get_app(u'auth'))
self.assertIn(u'The field named as the USERNAME_FIELD should not be included in REQUIRED_FIELDS on a swappable User model.', new_io.getvalue())
|
'A non-unique USERNAME_FIELD should raise a model validation error.'
| @override_settings(AUTH_USER_MODEL=u'auth.CustomUserNonUniqueUsername')
def test_username_non_unique(self):
| new_io = StringIO()
get_validation_errors(new_io, get_app(u'auth'))
self.assertIn(u'The USERNAME_FIELD must be unique. Add unique=True to the field parameters.', new_io.getvalue())
|
'Test that we show proper error message if we are trying to create
duplicate permissions.'
| def test_duplicated_permissions(self):
| models.Permission._meta.permissions = [(u'change_permission', u'Can edit permission (duplicate)')]
six.assertRaisesRegex(self, CommandError, u"The permission codename 'change_permission' clashes with a builtin permission for model 'auth.Permission'.", create_permissions, models, [], verbosity=0)
models.Permission._meta.permissions = [(u'my_custom_permission', u'Some permission'), (u'other_one', u'Some other permission'), (u'my_custom_permission', u'Some permission with duplicate permission code')]
six.assertRaisesRegex(self, CommandError, u"The permission codename 'my_custom_permission' is duplicated for model 'auth.Permission'.", create_permissions, models, [], verbosity=0)
models.Permission._meta.permissions = [(u'my_custom_permission', u'Some permission'), (u'other_one', u'Some other permission')]
create_permissions(models, [], verbosity=0)
|
'Verify that check_password returns the correct values as per
http://code.google.com/p/modwsgi/wiki/AccessControlMechanisms#Apache_Authentication_Provider'
| @skipIfCustomUser
def test_check_password(self):
| User.objects.create_user(u'test', u'[email protected]', u'test')
self.assertTrue((check_password({}, u'unknown', u'') is None))
self.assertTrue(check_password({}, u'test', u'test'))
User.objects.filter(username=u'test').update(is_active=False)
self.assertFalse(check_password({}, u'test', u'test'))
self.assertFalse(check_password({}, u'test', u'incorrect'))
|
'Verify that check_password returns the correct values as per
http://code.google.com/p/modwsgi/wiki/AccessControlMechanisms#Apache_Authentication_Provider
with custom user installed'
| @override_settings(AUTH_USER_MODEL=u'auth.CustomUser')
def test_check_password_custom_user(self):
| CustomUser._default_manager.create_user(u'[email protected]', u'1990-01-01', u'test')
self.assertTrue((check_password({}, u'unknown', u'') is None))
self.assertTrue(check_password({}, u'[email protected]', u'test'))
self.assertFalse(check_password({}, u'[email protected]', u'incorrect'))
|
'Check that groups_for_user returns correct values as per
http://code.google.com/p/modwsgi/wiki/AccessControlMechanisms#Apache_Group_Authorisation'
| @skipIfCustomUser
def test_groups_for_user(self):
| user1 = User.objects.create_user(u'test', u'[email protected]', u'test')
User.objects.create_user(u'test1', u'[email protected]', u'test1')
group = Group.objects.create(name=u'test_group')
user1.groups.add(group)
self.assertEqual(groups_for_user({}, u'unknown'), [])
self.assertEqual(groups_for_user({}, u'test'), ['test_group'])
self.assertEqual(groups_for_user({}, u'test1'), [])
|
'Creates and saves a User with the given email and password.'
| def create_user(self, email, date_of_birth, password=None):
| if (not email):
raise ValueError('Users must have an email address')
user = self.model(email=CustomUserManager.normalize_email(email), date_of_birth=date_of_birth)
user.set_password(password)
user.save(using=self._db)
return user
|
'Regressiontest for #12462'
| def test_has_no_object_perm(self):
| user = self.UserModel._default_manager.get(pk=self.user.pk)
content_type = ContentType.objects.get_for_model(Group)
perm = Permission.objects.create(name=u'test', content_type=content_type, codename=u'test')
user.user_permissions.add(perm)
user.save()
self.assertEqual(user.has_perm(u'auth.test', u'object'), False)
self.assertEqual(user.get_all_permissions(u'object'), set([]))
self.assertEqual(user.has_perm(u'auth.test'), True)
self.assertEqual(user.get_all_permissions(), set([u'auth.test']))
|
'A superuser has all permissions. Refs #14795'
| def test_get_all_superuser_permissions(self):
| user = self.UserModel._default_manager.get(pk=self.superuser.pk)
self.assertEqual(len(user.get_all_permissions()), len(Permission.objects.all()))
|
'tests that the default value for is_active is provided'
| @override_settings(AUTH_USER_MODEL='auth.IsActiveTestUser1')
def test_is_active_field_default(self):
| UserModel = get_user_model()
user = UserModel(username='foo')
self.assertEqual(user.is_active, True)
user.is_active = False
user.save()
user_fetched = UserModel._default_manager.get(pk=user.pk)
self.assertEqual(user_fetched.is_active, True)
|
'Test that \'something\' in PermWrapper works as expected.'
| def test_permwrapper_in(self):
| perms = PermWrapper(MockUser())
self.assertTrue(('mockapp' in perms))
self.assertFalse(('nonexisting' in perms))
self.assertTrue(('mockapp.someperm' in perms))
self.assertFalse(('mockapp.nonexisting' in perms))
|
'No endless loops if accessed with \'in\' - refs #18979.'
| def test_permlookupdict_in(self):
| pldict = PermLookupDict(MockUser(), 'mockapp')
with self.assertRaises(TypeError):
(self.EQLimiterObject() in pldict)
|
'Tests that the session is not accessed simply by including
the auth context processor'
| @override_settings(MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES, TEMPLATE_CONTEXT_PROCESSORS=global_settings.TEMPLATE_CONTEXT_PROCESSORS)
def test_session_not_accessed(self):
| response = self.client.get('/auth_processor_no_attr_access/')
self.assertContains(response, 'Session not accessed')
|
'Tests that the session is accessed if the auth context processor
is used and relevant attributes accessed.'
| @override_settings(MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES, TEMPLATE_CONTEXT_PROCESSORS=global_settings.TEMPLATE_CONTEXT_PROCESSORS)
def test_session_is_accessed(self):
| response = self.client.get('/auth_processor_attr_access/')
self.assertContains(response, 'Session accessed')
|
'Test that the lazy objects returned behave just like the wrapped objects.'
| def test_user_attrs(self):
| self.client.login(username='super', password='secret')
user = authenticate(username='super', password='secret')
response = self.client.get('/auth_processor_user/')
self.assertContains(response, 'unicode: super')
self.assertContains(response, 'id: 100')
self.assertContains(response, 'username: super')
self.assertContains(response, 'url: /userpage/super/')
query = (Q(user=response.context['user']) & Q(someflag=True))
self.assertEqual(response.context['user'], user)
self.assertEqual(user, response.context['user'])
|
'Check that login_required is assignable to callable objects.'
| def testCallable(self):
| class CallableView(object, ):
def __call__(self, *args, **kwargs):
pass
login_required(CallableView())
|
'Check that login_required is assignable to normal views.'
| def testView(self):
| def normal_view(request):
pass
login_required(normal_view)
|
'Check that login_required works on a simple view wrapped in a
login_required decorator.'
| def testLoginRequired(self, view_url='/login_required/', login_url='/login/'):
| response = self.client.get(view_url)
self.assertEqual(response.status_code, 302)
self.assertTrue((login_url in response['Location']))
self.login()
response = self.client.get(view_url)
self.assertEqual(response.status_code, 200)
|
'Check that login_required works on a simple view wrapped in a
login_required decorator with a login_url set.'
| def testLoginRequiredNextUrl(self):
| self.testLoginRequired(view_url='/login_required_login_url/', login_url='/somewhere/')
|
'The change form does not return the password value'
| def test_bug_19133(self):
| user = User.objects.get(username=u'testclient')
form_for_data = UserChangeForm(instance=user)
post_data = form_for_data.initial
post_data[u'password'] = u'new password'
form = UserChangeForm(instance=user, data=post_data)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data[u'password'], u'sha1$6efc0$f93efe9fd7542f25a7be94871ea45aa95de57161')
|
'creates a user and returns a tuple
(user_object, username, email)'
| def create_dummy_user(self):
| username = u'jsmith'
email = u'[email protected]'
user = User.objects.create_user(username, email, u'test123')
return (user, username, email)
|
'Tests requests where no remote user is specified and insures that no
users get created.'
| def test_no_remote_user(self):
| num_users = User.objects.count()
response = self.client.get('/remote_user/')
self.assertTrue(response.context['user'].is_anonymous())
self.assertEqual(User.objects.count(), num_users)
response = self.client.get('/remote_user/', REMOTE_USER=None)
self.assertTrue(response.context['user'].is_anonymous())
self.assertEqual(User.objects.count(), num_users)
response = self.client.get('/remote_user/', REMOTE_USER='')
self.assertTrue(response.context['user'].is_anonymous())
self.assertEqual(User.objects.count(), num_users)
|
'Tests the case where the username passed in the header does not exist
as a User.'
| def test_unknown_user(self):
| num_users = User.objects.count()
response = self.client.get('/remote_user/', REMOTE_USER='newuser')
self.assertEqual(response.context['user'].username, 'newuser')
self.assertEqual(User.objects.count(), (num_users + 1))
User.objects.get(username='newuser')
response = self.client.get('/remote_user/', REMOTE_USER='newuser')
self.assertEqual(User.objects.count(), (num_users + 1))
|
'Tests the case where the username passed in the header is a valid User.'
| def test_known_user(self):
| User.objects.create(username='knownuser')
User.objects.create(username='knownuser2')
num_users = User.objects.count()
response = self.client.get('/remote_user/', REMOTE_USER=self.known_user)
self.assertEqual(response.context['user'].username, 'knownuser')
self.assertEqual(User.objects.count(), num_users)
response = self.client.get('/remote_user/', REMOTE_USER=self.known_user2)
self.assertEqual(response.context['user'].username, 'knownuser2')
self.assertEqual(User.objects.count(), num_users)
|
'Tests that a user\'s last_login is set the first time they make a
request but not updated in subsequent requests with the same session.'
| def test_last_login(self):
| user = User.objects.create(username='knownuser')
default_login = datetime(2000, 1, 1)
if settings.USE_TZ:
default_login = default_login.replace(tzinfo=timezone.utc)
user.last_login = default_login
user.save()
response = self.client.get('/remote_user/', REMOTE_USER=self.known_user)
self.assertNotEqual(default_login, response.context['user'].last_login)
user = User.objects.get(username='knownuser')
user.last_login = default_login
user.save()
response = self.client.get('/remote_user/', REMOTE_USER=self.known_user)
self.assertEqual(default_login, response.context['user'].last_login)
|
'Tests that a logged in user is logged out automatically when
the REMOTE_USER header disappears during the same browser session.'
| def test_header_disappears(self):
| User.objects.create(username='knownuser')
response = self.client.get('/remote_user/', REMOTE_USER=self.known_user)
self.assertEqual(response.context['user'].username, 'knownuser')
response = self.client.get('/remote_user/')
self.assertEqual(response.context['user'].is_anonymous(), True)
User.objects.create_user(username='modeluser', password='foo')
self.client.login(username='modeluser', password='foo')
authenticate(username='modeluser', password='foo')
response = self.client.get('/remote_user/')
self.assertEqual(response.context['user'].username, 'modeluser')
|
'Restores settings to avoid breaking other tests.'
| def tearDown(self):
| settings.MIDDLEWARE_CLASSES = self.curr_middleware
settings.AUTHENTICATION_BACKENDS = self.curr_auth
|
'Grabs username before the @ character.'
| def clean_username(self, username):
| return username.split('@')[0]
|
'Sets user\'s email address.'
| def configure_user(self, user):
| user.email = '[email protected]'
user.save()
return user
|
'The strings passed in REMOTE_USER should be cleaned and the known users
should not have been configured with an email address.'
| def test_known_user(self):
| super(RemoteUserCustomTest, self).test_known_user()
self.assertEqual(User.objects.get(username='knownuser').email, '')
self.assertEqual(User.objects.get(username='knownuser2').email, '')
|
'The unknown user created should be configured with an email address.'
| def test_unknown_user(self):
| super(RemoteUserCustomTest, self).test_unknown_user()
newuser = User.objects.get(username='newuser')
self.assertEqual(newuser.email, '[email protected]')
|
'Ensure that we can make a token and that it is valid'
| def test_make_token(self):
| user = User.objects.create_user('tokentestuser', '[email protected]', 'testpw')
p0 = PasswordResetTokenGenerator()
tk1 = p0.make_token(user)
self.assertTrue(p0.check_token(user, tk1))
|
'Ensure that the token generated for a user created in the same request
will work correctly.'
| def test_10265(self):
| user = User.objects.create_user('comebackkid', '[email protected]', 'testpw')
p0 = PasswordResetTokenGenerator()
tk1 = p0.make_token(user)
reload = User.objects.get(username='comebackkid')
tk2 = p0.make_token(reload)
self.assertEqual(tk1, tk2)
|
'Ensure we can use the token after n days, but no greater.'
| def test_timeout(self):
| class Mocked(PasswordResetTokenGenerator, ):
def __init__(self, today):
self._today_val = today
def _today(self):
return self._today_val
user = User.objects.create_user('tokentestuser', '[email protected]', 'testpw')
p0 = PasswordResetTokenGenerator()
tk1 = p0.make_token(user)
p1 = Mocked((date.today() + timedelta(settings.PASSWORD_RESET_TIMEOUT_DAYS)))
self.assertTrue(p1.check_token(user, tk1))
p2 = Mocked((date.today() + timedelta((settings.PASSWORD_RESET_TIMEOUT_DAYS + 1))))
self.assertFalse(p2.check_token(user, tk1))
|
'Make sure we don\'t allow overly long dates, causing a potential DoS.'
| @unittest.skipIf((sys.version_info[:2] >= (3, 0)), 'Unnecessary test with Python 3')
def test_date_length(self):
| user = User.objects.create_user('ima1337h4x0r', '[email protected]', 'p4ssw0rd')
p0 = PasswordResetTokenGenerator()
self.assertRaises(ValueError, p0._make_token_with_timestamp, user, 175455491841851871349L)
|
'Named URLs should be reversible'
| def test_named_urls(self):
| expected_named_urls = [('login', [], {}), ('logout', [], {}), ('password_change', [], {}), ('password_change_done', [], {}), ('password_reset', [], {}), ('password_reset_done', [], {}), ('password_reset_confirm', [], {'uidb36': 'aaaaaaa', 'token': '1111-aaaaa'}), ('password_reset_complete', [], {})]
for (name, args, kwargs) in expected_named_urls:
try:
reverse(name, args=args, kwargs=kwargs)
except NoReverseMatch:
self.fail(("Reversal of url named '%s' failed with NoReverseMatch" % name))
|
'Error is raised if the provided email address isn\'t currently registered'
| def test_email_not_found(self):
| response = self.client.get('/password_reset/')
self.assertEqual(response.status_code, 200)
response = self.client.post('/password_reset/', {'email': '[email protected]'})
self.assertContainsEscaped(response, PasswordResetForm.error_messages['unknown'])
self.assertEqual(len(mail.outbox), 0)
|
'Email is sent if a valid email address is provided for password reset'
| def test_email_found(self):
| response = self.client.post('/password_reset/', {'email': '[email protected]'})
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(('http://' in mail.outbox[0].body))
self.assertEqual(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email)
|
'Email is sent if a valid email address is provided for password reset when a custom from_email is provided.'
| def test_email_found_custom_from(self):
| response = self.client.post('/password_reset_from_email/', {'email': '[email protected]'})
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual('[email protected]', mail.outbox[0].from_email)
|
'If the reset view is marked as being for admin, the HTTP_HOST header is used for a domain override.'
| @override_settings(ALLOWED_HOSTS=['adminsite.com'])
def test_admin_reset(self):
| response = self.client.post('/admin_password_reset/', {'email': '[email protected]'}, HTTP_HOST='adminsite.com')
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(('http://adminsite.com' in mail.outbox[0].body))
self.assertEqual(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email)
|
'Poisoned HTTP_HOST headers can\'t be used for reset emails'
| @override_settings(DEBUG_PROPAGATE_EXCEPTIONS=True)
def test_poisoned_http_host(self):
| with self.assertRaises(SuspiciousOperation):
self.client.post('/password_reset/', {'email': '[email protected]'}, HTTP_HOST='www.example:[email protected]')
self.assertEqual(len(mail.outbox), 0)
|
'Poisoned HTTP_HOST headers can\'t be used for reset emails on admin views'
| @override_settings(DEBUG_PROPAGATE_EXCEPTIONS=True)
def test_poisoned_http_host_admin_site(self):
| with self.assertRaises(SuspiciousOperation):
self.client.post('/admin_password_reset/', {'email': '[email protected]'}, HTTP_HOST='www.example:[email protected]')
self.assertEqual(len(mail.outbox), 0)
|
'Logout without next_page option renders the default template'
| def test_logout_default(self):
| self.login()
response = self.client.get('/logout/')
self.assertContains(response, 'Logged out')
self.confirm_logged_out()
|
'Logout with next_page option given redirects to specified resource'
| def test_logout_with_next_page_specified(self):
| self.login()
response = self.client.get('/logout/next_page/')
self.assertEqual(response.status_code, 302)
self.assertTrue(response['Location'].endswith('/somewhere/'))
self.confirm_logged_out()
|
'Logout with query string redirects to specified resource'
| def test_logout_with_redirect_argument(self):
| self.login()
response = self.client.get('/logout/?next=/login/')
self.assertEqual(response.status_code, 302)
self.assertTrue(response['Location'].endswith('/login/'))
self.confirm_logged_out()
|
'Logout with custom query string redirects to specified resource'
| def test_logout_with_custom_redirect_argument(self):
| self.login()
response = self.client.get('/logout/custom_query/?follow=/somewhere/')
self.assertEqual(response.status_code, 302)
self.assertTrue(response['Location'].endswith('/somewhere/'))
self.confirm_logged_out()
|
'Set up the listeners and reset the logged in/logged out counters'
| def setUp(self):
| self.logged_in = []
self.logged_out = []
self.login_failed = []
signals.user_logged_in.connect(self.listener_login)
signals.user_logged_out.connect(self.listener_logout)
signals.user_login_failed.connect(self.listener_login_failed)
|
'Disconnect the listeners'
| def tearDown(self):
| signals.user_logged_in.disconnect(self.listener_login)
signals.user_logged_out.disconnect(self.listener_logout)
signals.user_login_failed.disconnect(self.listener_login_failed)
|
'Ensure that only `last_login` is updated in `update_last_login`'
| def test_update_last_login(self):
| user = User.objects.get(pk=3)
old_last_login = user.last_login
user.username = "This username shouldn't get saved"
request = RequestFactory().get('/login')
signals.user_logged_in.send(sender=user.__class__, request=request, user=user)
user = User.objects.get(pk=3)
self.assertEqual(user.username, 'staff')
self.assertNotEqual(user.last_login, old_last_login)
|
'Check that users can be created and can set their password'
| def test_user(self):
| u = User.objects.create_user(u'testuser', u'[email protected]', u'testpw')
self.assertTrue(u.has_usable_password())
self.assertFalse(u.check_password(u'bad'))
self.assertTrue(u.check_password(u'testpw'))
u.set_unusable_password()
u.save()
self.assertFalse(u.check_password(u'testpw'))
self.assertFalse(u.has_usable_password())
u.set_password(u'testpw')
self.assertTrue(u.check_password(u'testpw'))
u.set_password(None)
self.assertFalse(u.has_usable_password())
self.assertTrue(u.is_authenticated())
self.assertFalse(u.is_staff)
self.assertTrue(u.is_active)
self.assertFalse(u.is_superuser)
u2 = User.objects.create_user(u'testuser2', u'[email protected]')
self.assertFalse(u2.has_usable_password())
|
'Check that users can be created without an email'
| def test_user_no_email(self):
| u = User.objects.create_user(u'testuser1')
self.assertEqual(u.email, u'')
u2 = User.objects.create_user(u'testuser2', email=u'')
self.assertEqual(u2.email, u'')
u3 = User.objects.create_user(u'testuser3', email=None)
self.assertEqual(u3.email, u'')
|
'Check the properties of the anonymous user'
| def test_anonymous_user(self):
| a = AnonymousUser()
self.assertEqual(a.pk, None)
self.assertFalse(a.is_authenticated())
self.assertFalse(a.is_staff)
self.assertFalse(a.is_active)
self.assertFalse(a.is_superuser)
self.assertEqual(a.groups.all().count(), 0)
self.assertEqual(a.user_permissions.all().count(), 0)
|
'Check the creation and properties of a superuser'
| def test_superuser(self):
| super = User.objects.create_superuser(u'super', u'[email protected]', u'super')
self.assertTrue(super.is_superuser)
self.assertTrue(super.is_active)
self.assertTrue(super.is_staff)
|
'Check the operation of the createsuperuser management command'
| def test_createsuperuser_management_command(self):
| new_io = StringIO()
call_command(u'createsuperuser', interactive=False, username=u'joe', email=u'[email protected]', stdout=new_io)
command_output = new_io.getvalue().strip()
self.assertEqual(command_output, u'Superuser created successfully.')
u = User.objects.get(username=u'joe')
self.assertEqual(u.email, u'[email protected]')
self.assertFalse(u.has_usable_password())
new_io = StringIO()
call_command(u'createsuperuser', interactive=False, username=u'joe2', email=u'[email protected]', verbosity=0, stdout=new_io)
command_output = new_io.getvalue().strip()
self.assertEqual(command_output, u'')
u = User.objects.get(username=u'joe2')
self.assertEqual(u.email, u'[email protected]')
self.assertFalse(u.has_usable_password())
call_command(u'createsuperuser', interactive=False, username=u'[email protected]', email=u'[email protected]', verbosity=0)
u = User.objects.get(username=u'[email protected]')
self.assertEqual(u.email, u'[email protected]')
self.assertFalse(u.has_usable_password())
|
'Check that createsuperuser does not break when no locale is set. See
ticket #16017.'
| @mock_inputs({u'password': u'nopasswd'})
def test_createsuperuser_nolocale(self):
| old_getdefaultlocale = locale.getdefaultlocale
try:
locale.getdefaultlocale = (lambda : (None, None))
call_command(u'createsuperuser', interactive=True, username=u'[email protected]', email=u'[email protected]', verbosity=0)
except TypeError:
self.fail(u'createsuperuser fails if the OS provides no information about the current locale')
finally:
locale.getdefaultlocale = old_getdefaultlocale
u = User.objects.get(username=u'[email protected]')
self.assertEqual(u.email, u'[email protected]')
|
'The current user model can be retrieved'
| def test_get_user_model(self):
| self.assertEqual(get_user_model(), User)
|
'The current user model can be swapped out for another'
| @override_settings(AUTH_USER_MODEL=u'auth.CustomUser')
def test_swappable_user(self):
| self.assertEqual(get_user_model(), CustomUser)
with self.assertRaises(AttributeError):
User.objects.all()
|
'The alternate user setting must point to something in the format app.model'
| @override_settings(AUTH_USER_MODEL=u'badsetting')
def test_swappable_user_bad_setting(self):
| with self.assertRaises(ImproperlyConfigured):
get_user_model()
|
'The current user model must point to an installed model'
| @override_settings(AUTH_USER_MODEL=u'thismodel.doesntexist')
def test_swappable_user_nonexistent_model(self):
| with self.assertRaises(ImproperlyConfigured):
get_user_model()
|
'Normalize the address by lowercasing the domain part of the email
address.'
| @classmethod
def normalize_email(cls, email):
| email = (email or u'')
try:
(email_name, domain_part) = email.strip().rsplit(u'@', 1)
except ValueError:
pass
else:
email = u'@'.join([email_name, domain_part.lower()])
return email
|
'Generates a random password with the given length and given
allowed_chars. Note that the default value of allowed_chars does not
have "I" or "O" or letters and digits that look similar -- just to
avoid confusion.'
| def make_random_password(self, length=10, allowed_chars=u'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'):
| return get_random_string(length, allowed_chars)
|
'Creates and saves a User with the given username, email and password.'
| def create_user(self, username, email=None, password=None, **extra_fields):
| now = timezone.now()
if (not username):
raise ValueError(u'The given username must be set')
email = UserManager.normalize_email(email)
user = self.model(username=username, email=email, is_staff=False, is_active=True, is_superuser=False, last_login=now, date_joined=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
|
'Return the identifying username for this User'
| def get_username(self):
| return getattr(self, self.USERNAME_FIELD)
|
'Always returns False. This is a way of comparing User objects to
anonymous users.'
| def is_anonymous(self):
| return False
|
'Always return True. This is a way to tell if the user has been
authenticated in templates.'
| def is_authenticated(self):
| return True
|
'Returns a boolean of whether the raw_password was correct. Handles
hashing formats behind the scenes.'
| def check_password(self, raw_password):
| def setter(raw_password):
self.set_password(raw_password)
self.save(update_fields=[u'password'])
return check_password(raw_password, self.password, setter)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.