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))
