def reserved_username_validator(value): from .models import Entity # ~~~~ TODO if (normalize_username(username=value) in [ normalize_username(username=reserved) for reserved in Entity.settings.UNAVAILABLE_USERNAMES ]): raise ValidationError(_('This username is already taken.'))
def reserved_username_validator(value): from .models import Entity if (normalize_username(username=value) in [ normalize_username(username=reserved_username) for reserved_username in Entity.settings.RESERVED_USERNAMES ]): raise ValidationError(_('This username is already taken.'))
def test_slug_validation_fails_with_username_too_short(self): slug_list = [ 'a' * 5, 'aa-aa', 'a-a-a-a', '---a--a--a--a---', '---a--a--a--a--a---' ] for slug in slug_list: # print(slug) # ~~~~ TODO: remove this line! username_value_length = len(normalize_username(username=slug)) if (slug in ['a' * 5, '---a--a--a--a--a---']): self.assertEqual(first=username_value_length, second=5) else: self.assertEqual(first=username_value_length, second=4) data = self.data.copy() data['slug'] = slug form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertFalse(expr=form.is_valid()) self.assertDictEqual( d1=form.errors, d2=self. _model_slug_or_username_username_must_contain_at_least_min_length_alphanumeric_characters_errors_dict_by_value_length( model=User, slug_fail=True, username_value_length=username_value_length))
def test_slug_validation_ok(self): slug_list = ['a' * 6, '---a--a--a--a--a--a---'] for slug in slug_list: data = self.data.copy() data['slug'] = slug form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertTrue(expr=form.is_valid()) self.assertDictEqual(d1=form.errors, d2={}) user = form.save() self.assert_models_count( entity_count=1, user_count=1, user_email_address_count=1, confirmed_email_address_count=0, unconfirmed_email_address_count=1, ) user = User.objects.get(username=normalize_username( username=slug)) user.delete() self.assert_models_count( entity_count=0, user_count=0, user_email_address_count=0, confirmed_email_address_count=0, unconfirmed_email_address_count=0, )
def test_slug_validation_ok(self): slug_list = ['a' * 6, '---a--a--a--a--a--a---'] for slug in slug_list: # print(slug) # ~~~~ TODO: remove this line! data = self.data.copy() data['slug'] = slug form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertTrue(expr=form.is_valid()) self.assertDictEqual(d1=form.errors, d2={}) user = form.save() self.assert_models_count( entity_count=1, user_count=1, user_email_address_count=1, confirmed_email_address_count=0, unconfirmed_email_address_count=1, ) user = User.objects.get(username=normalize_username(username=slug)) user.delete() self.assert_models_count( entity_count=0, user_count=0, user_email_address_count=0, confirmed_email_address_count=0, unconfirmed_email_address_count=0, )
def clean_slug(self): slug = self.cleaned_data.get('slug') username = self.instance.username if (not (normalize_username(username=slug) == username)): raise ValidationError( pgettext_lazy(context=self.instance.get_gender(), message="You can't change your username.")) return slug
def run_test_all_slugs_to_test_list(self, test_settings): ok_count, model_save_failures_count = 0, 0 for slug_dict in tests_settings.SLUGS_TO_TEST_LIST: data = self.data.copy() data['slug'] = slug_dict["slug"] username = normalize_username(username=data['slug']) slug = normalize_slug(slug=data['slug']) data['email'] = "{username}@example.com".format( username=username) self.assertEqual(first=slug_dict["slug_length"], second=len(slug)) if (slug_dict["slug_length"] >= User.settings.MIN_SLUG_LENGTH): form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertTrue(expr=form.is_valid()) self.assertDictEqual(d1=form.errors, d2={}) user = form.save() self.assertEqual( first=User.objects.filter(username=username).count(), second=1) user = User.objects.get(username=username) self.assertEqual(first=user.username, second=username) self.assertEqual(first=user.slug, second=slug) ok_count += 1 else: form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertFalse(expr=form.is_valid()) self.assertDictEqual( d1=form.errors, d2=self. _model_slug_or_username_username_must_contain_at_least_min_length_characters_errors_dict_by_value_length( model=User, slug_fail=True, slug_value_length=slug_dict["slug_length"])) self.assertEqual( first=User.objects.filter(username=username).count(), second=0) model_save_failures_count += 1 counts_tuple = (ok_count, model_save_failures_count) self.assert_models_count( entity_count=ok_count, user_count=ok_count, user_email_address_count=ok_count, confirmed_email_address_count=0, unconfirmed_email_address_count=ok_count, ) self.assertEqual(first=sum(counts_tuple), second=len(tests_settings.SLUGS_TO_TEST_LIST)) self.assertTupleEqual( tuple1=counts_tuple, tuple2=test_settings["expected_counts_tuple"])
def dispatch(self, request, *args, **kwargs): if (not (request.user.is_authenticated)): return self.handle_no_permission() visited_user = self.get_user_queryset().filter( username=normalize_username(username=self.kwargs['chat_slug'])).first() if ((visited_user) and (visited_user.slug != self.kwargs['chat_slug'])): return redirect(to=reverse('im:chat', kwargs={'chat_slug': visited_user.slug})) if ((visited_user) and (visited_user != request.user) and (not (Chat.objects.chat_with(ent1=self.request.user, ent2=visited_user, create=False)))): self.user = visited_user self.chat = None return self.get(request=request, *args, **kwargs) return super().dispatch(request=request, *args, **kwargs)
def dispatch(self, request, *args, **kwargs): if (not (request.user.is_authenticated)): return self.handle_no_permission() visited_user_slug = self.kwargs['chat_slug'] visited_user = self.get_user_queryset().filter(Q(username=normalize_username(username=visited_user_slug)) | Q(id=visited_user_slug)).first() if ((visited_user) and (visited_user.slug != visited_user_slug)): return redirect(to=reverse('messages:chat', kwargs={'chat_slug': visited_user.slug})) if ((visited_user) and (visited_user != request.user) and (not (Chat.objects.chat_with(ent1=self.request.user, ent2=visited_user, create=False)))): self.permission_required = 'messages.send_message' self.user = visited_user self.chat = None if (not (self.request.user.has_perm(perm='messages.send_message', obj=visited_user))): return self.handle_no_permission() return self.get(request=request, *args, **kwargs) return super().dispatch(request=request, *args, **kwargs)
def test_slug_validation_fails_with_username_too_short(self): slug_list = ['a' * 5, 'aa-aa', 'a-a-a-a', '---a--a--a--a---', '---a--a--a--a--a---'] for slug in slug_list: # print(slug) # ~~~~ TODO: remove this line! username_value_length = len(normalize_username(username=slug)) if (slug in ['a' * 5, '---a--a--a--a--a---']): self.assertEqual(first=username_value_length, second=5) else: self.assertEqual(first=username_value_length, second=4) data = self.data.copy() data['slug'] = slug form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertFalse(expr=form.is_valid()) self.assertDictEqual(d1=form.errors, d2=self._model_slug_or_username_username_must_contain_at_least_min_length_alphanumeric_characters_errors_dict_by_value_length(model=User, slug_fail=True, username_value_length=username_value_length))
class DefaultUserFactory(factory.DjangoModelFactory): first_name_en = factory.Faker('first_name') last_name_en = factory.Faker('last_name') date_of_birth = factory.fuzzy.FuzzyDate(start_date=date(year=1900, month=1, day=1)) gender = factory.fuzzy.FuzzyChoice(choices=User.GENDER_VALID_VALUES) slug = factory.fuzzy.FuzzyText(chars=string.ascii_lowercase) username = factory.LazyAttribute(lambda o: normalize_username(username=o.slug)) password = factory.fuzzy.FuzzyText(chars=string.ascii_lowercase) _password = factory.PostGenerationMethodCall(method_name='set_password', raw_password=tests_settings.USER_PASSWORD) class Meta: model = User @factory.post_generation def validate_first_and_last_name_in_all_languages(self, created, extracted, **kwargs): _test_case_with_mixin.assert_user_first_and_last_name_in_all_languages(user=self)
def get_user(self): try: slug = self.kwargs.get(self.user_slug_kwarg) if ((self.use_request_user()) or (slug == 'me')): if (self.request.user.is_authenticated): return self.request.user else: raise PermissionDenied() user = self.get_user_queryset().get(Q(slug=slug) | Q(username=normalize_username(username=slug))) # inactive user profiles will have a link to the Speedy Net profile page # so the user has to get to the profile page and not a 404 # if (not (user.profile.is_active)): # raise Http404('This user is not active on this site.') return user except User.DoesNotExist: raise Http404()
def get_user(self): try: slug = self.kwargs.get(self.user_slug_kwarg) if ((self.use_request_user()) or (slug == 'me')): if (self.request.user.is_authenticated): return self.request.user else: raise PermissionDenied() user = self.get_user_queryset().get( Q(slug=slug) | Q(username=normalize_username(username=slug))) # inactive user profiles will have a link to the Speedy Net profile page # so the user has to get to the profile page and not a 404 # if (not (user.profile.is_active)): # raise Http404('This user is not active on this site.') return user except User.DoesNotExist: raise Http404()
def test_slugs_to_test_list(self): self.assertEqual(first=len(tests_settings.SLUGS_TO_TEST_LIST), second=8) username_set, slug_set, username_length_set, slug_length_set = set(), set(), set(), set() for slug_dict in tests_settings.SLUGS_TO_TEST_LIST: username = normalize_username(username=slug_dict["slug"]) slug = normalize_slug(slug=slug_dict["slug"]) username_set.add(username) slug_set.add(slug) username_length_set.add(len(username)) slug_length_set.add(len(slug)) self.assertEqual(first=slug_dict["slug_length"], second=len(slug)) self.assertIn(member=len(username), container={29, 30, 31, 32}) self.assertIn(member=len(slug), container={57, 59, 61, 63}) self.assertIn(member=len(slug), container={len(username) * 2, (len(username) * 2) - 1}) self.assertEqual(first=len(username_set), second=8) self.assertEqual(first=len(slug_set), second=8) self.assertEqual(first=len(username_length_set), second=4) self.assertEqual(first=len(slug_length_set), second=4) self.assertSetEqual(set1=username_length_set, set2={29, 30, 31, 32}) self.assertSetEqual(set1=slug_length_set, set2={57, 59, 61, 63})
def get_user(self): slug = self.kwargs.get(self.user_slug_kwarg) if ((self.use_request_user()) or (slug == 'me')): if (self.request.user.is_authenticated): user = self.request.user else: raise PermissionDenied() else: users = self.get_user_queryset().filter( Q(slug=slug) | Q(username=normalize_username(username=slug)) | Q(id=slug)) if (len(users) == 1): user = users[0] # Users have cached properties, so we don't want to load them to memory twice. if (self.request.user.is_authenticated): if (user == self.request.user): user = self.request.user else: raise Http404() return user
def set_up(self): super().set_up() self.password = get_random_user_password() self.data = { 'email': '*****@*****.**', 'slug': 'user-22', 'new_password1': self.password, 'gender': 1, 'date_of_birth': '1980-01-01', } self.username = normalize_username(username=self.data['slug']) self.slug = normalize_slug(slug=self.data['slug']) self.assertNotEqual(first=self.password, second=tests_settings.USER_PASSWORD) self.assertEqual(first=self.username, second='user22') self.assertEqual(first=self.slug, second='user-22') self.assertNotEqual(first=self.username, second=self.slug) self.assert_models_count( entity_count=0, user_count=0, user_email_address_count=0, confirmed_email_address_count=0, unconfirmed_email_address_count=0, )
def run_test_all_slugs_to_test_list(self, test_settings): ok_count, model_save_failures_count = 0, 0 for slug_dict in tests_settings.SLUGS_TO_TEST_LIST: data = self.data.copy() data['slug'] = slug_dict["slug"] username = normalize_username(username=data['slug']) slug = normalize_slug(slug=data['slug']) data['email'] = "{username}@example.com".format(username=username) self.assertEqual(first=slug_dict["slug_length"], second=len(slug)) if (slug_dict["slug_length"] >= User.settings.MIN_SLUG_LENGTH): form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertTrue(expr=form.is_valid()) self.assertDictEqual(d1=form.errors, d2={}) user = form.save() self.assertEqual(first=User.objects.filter(username=username).count(), second=1) user = User.objects.get(username=username) self.assertEqual(first=user.username, second=username) self.assertEqual(first=user.slug, second=slug) ok_count += 1 else: form = RegistrationForm(language_code=self.language_code, data=data) form.full_clean() self.assertFalse(expr=form.is_valid()) self.assertDictEqual(d1=form.errors, d2=self._model_slug_or_username_username_must_contain_at_least_min_length_characters_errors_dict_by_value_length(model=User, slug_fail=True, slug_value_length=slug_dict["slug_length"])) self.assertEqual(first=User.objects.filter(username=username).count(), second=0) model_save_failures_count += 1 counts_tuple = (ok_count, model_save_failures_count) self.assert_models_count( entity_count=ok_count, user_count=ok_count, user_email_address_count=ok_count, confirmed_email_address_count=0, unconfirmed_email_address_count=ok_count, ) self.assertEqual(first=sum(counts_tuple), second=len(tests_settings.SLUGS_TO_TEST_LIST)) self.assertTupleEqual(tuple1=counts_tuple, tuple2=test_settings["expected_counts_tuple"])
def set_up(self): super().set_up() self.password = get_random_user_password() self.data = { 'email': '*****@*****.**', 'slug': 'user-22', 'new_password1': self.password, 'gender': 1, 'date_of_birth': '1980-01-01', } self.username = normalize_username(username=self.data['slug']) self.slug = normalize_slug(slug=self.data['slug']) self.assertNotEqual(first=self.password, second=tests_settings.USER_PASSWORD) self.assertEqual(first=self.username, second='user22') self.assertEqual(first=self.slug, second='user-22') self.assertNotEqual(first=self.username, second=self.slug) self.assert_models_count( entity_count=0, user_count=0, user_email_address_count=0, confirmed_email_address_count=0, unconfirmed_email_address_count=0, )
def test_slugs_to_test_list(self): self.assertEqual(first=len(tests_settings.SLUGS_TO_TEST_LIST), second=8) username_set, slug_set, username_length_set, slug_length_set = set( ), set(), set(), set() for slug_dict in tests_settings.SLUGS_TO_TEST_LIST: username = normalize_username(username=slug_dict["slug"]) slug = normalize_slug(slug=slug_dict["slug"]) username_set.add(username) slug_set.add(slug) username_length_set.add(len(username)) slug_length_set.add(len(slug)) self.assertEqual(first=slug_dict["slug_length"], second=len(slug)) self.assertIn(member=len(username), container={29, 30, 31, 32}) self.assertIn(member=len(slug), container={57, 59, 61, 63}) self.assertIn( member=len(slug), container={len(username) * 2, (len(username) * 2) - 1}) self.assertEqual(first=len(username_set), second=8) self.assertEqual(first=len(slug_set), second=8) self.assertEqual(first=len(username_length_set), second=4) self.assertEqual(first=len(slug_length_set), second=4) self.assertSetEqual(set1=username_length_set, set2={29, 30, 31, 32}) self.assertSetEqual(set1=slug_length_set, set2={57, 59, 61, 63})
def test_remove_dashes_dots_and_underscores(self): self.assertEqual(first=normalize_username(username='******'), second='thisisaslug') self.assertEqual(first=normalize_username(username='******'), second='thisisaslug')
def normalize_slug_and_username(self): self.slug = normalize_slug(slug=self.slug) if (self.username): self.username = normalize_username(username=self.username) else: self.username = normalize_username(username=self.slug)
def clean_slug(self): slug = self.cleaned_data.get('slug') username = self.instance.username if (not (normalize_username(username=slug) == username)): raise ValidationError(pgettext_lazy(context=self.instance.get_gender(), message="You can't change your username.")) return slug
def get_by_username(self, username): return self.get(username=normalize_username(username=username))
def get_by_natural_key(self, username): return self.distinct().get( Q(username=normalize_username(username=username)) | Q(email_addresses__email=username))
def validate_username_for_slug(self): if (not (normalize_username(username=self.slug) == self.username)): raise ValidationError(_('Slug does not parse to username.'))
def reserved_username_validator(value): from .models import Entity # ~~~~ TODO if (normalize_username(username=value) in [normalize_username(username=reserved) for reserved in Entity.settings.UNAVAILABLE_USERNAMES]): raise ValidationError(_('This username is already taken.'))
def validate_username_for_slug(self): if (not (normalize_username(username=self.slug) == self.username)): raise ValidationError(_('Slug does not parse to username.'))
def clean(self, x): return len(normalize_username(username=x))
def normalize_slug_and_username(self): self.slug = normalize_slug(slug=self.slug) if (self.username): self.username = normalize_username(username=self.username) else: self.username = normalize_username(username=self.slug)
def test_remove_dashes_dots_and_underscores(self): self.assertEqual(first=normalize_username(username='******'), second='thisisaslug') self.assertEqual( first=normalize_username(username='******'), second='thisisaslug')
def get_by_username(self, username): return self.get(username=normalize_username(username=username))
def filter_by_username(self, username): return self.filter(username=normalize_username(username=username))
def clean(self, x): return len(normalize_username(username=x))
def get_by_natural_key(self, username): return self.distinct().get(Q(username=normalize_username(username=username)) | Q(email_addresses__email=username))