class RegistrationFormTestCaseMixin(SpeedyCoreAccountsModelsMixin,
SpeedyCoreAccountsLanguageMixin):
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 set_up_required_fields(self):
self.required_fields = self.data.keys() - {
to_attribute(name="last_name",
language_code=self.language_code)
}
self.assert_registration_form_required_fields(
required_fields=self.required_fields)
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 test_visitor_can_register(self):
form = RegistrationForm(language_code=self.language_code,
data=self.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,
)
self.assertEqual(
first=Entity.objects.filter(username=self.username).count(),
second=1)
self.assertEqual(
first=User.objects.filter(username=self.username).count(),
second=1)
entity = Entity.objects.get(username=self.username)
user = User.objects.get(username=self.username)
self.assertEqual(first=user, second=entity.user)
self.assertEqual(first=entity.id, second=user.id)
self.assertEqual(first=entity.username, second=user.username)
self.assertEqual(first=entity.slug, second=user.slug)
self.assertEqual(first=len(entity.id), second=15)
self.assertTrue(expr=user.check_password(
raw_password=self.password))
self.assertFalse(expr=user.check_password(
raw_password=tests_settings.USER_PASSWORD))
self.assertEqual(first=user.first_name, second=self.first_name)
self.assertEqual(first=user.first_name_en, second=self.first_name)
self.assertEqual(first=user.first_name_he, second=self.first_name)
self.assertEqual(first=user.last_name, second=self.last_name)
self.assertEqual(first=user.last_name_en, second=self.last_name)
self.assertEqual(first=user.last_name_he, second=self.last_name)
self.assertEqual(first=user.username, second=self.username)
self.assertEqual(first=user.username, second='user22')
self.assertEqual(first=user.slug, second=self.slug)
self.assertEqual(first=user.slug, second='user-22')
self.assert_user_email_addresses_count(
user=user,
user_email_addresses_count=1,
user_primary_email_addresses_count=1,
user_confirmed_email_addresses_count=0,
user_unconfirmed_email_addresses_count=1,
)
self.assertEqual(first=user.email_addresses.first().email,
second='*****@*****.**')
self.assertFalse(expr=user.email_addresses.first().is_confirmed)
self.assertTrue(expr=user.email_addresses.first().is_primary)
for (key, value) in self.data.items():
if (not (key in ['new_password1', 'date_of_birth'])):
self.assertEqual(first=getattr(user, key), second=value)
self.assertEqual(first=user.date_of_birth,
second=date(year=1980, month=1, day=1))
def test_slug_gets_converted_to_username(self):
data = self.data.copy()
data['slug'] = 'this-is-a-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.assertEqual(first=user.slug, second='this-is-a-slug')
self.assertEqual(first=user.username, second='thisisaslug')
def test_slug_dots_and_underscores_gets_converted_to_dashes(self):
data = self.data.copy()
data['slug'] = 'this.is__a.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.assertEqual(first=user.slug, second='this-is-a-slug')
self.assertEqual(first=user.username, second='thisisaslug')
def test_slug_dashes_are_trimmed_and_double_dashes_are_converted_to_single_dashes(
self):
data = self.data.copy()
data['slug'] = '--this--is---a--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.assertEqual(first=user.slug, second='this-is-a-slug')
self.assertEqual(first=user.username, second='thisisaslug')
def test_slug_gets_converted_to_lowercase(self):
data = self.data.copy()
data['slug'] = 'THIS-IS-A-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.assertEqual(first=user.slug, second='this-is-a-slug')
self.assertEqual(first=user.username, second='thisisaslug')
def test_email_gets_converted_to_lowercase(self):
data = self.data.copy()
data['email'] = '*****@*****.**'
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()
email_addresses = UserEmailAddress.objects.filter(user=user)
email_addresses_set = {e.email for e in email_addresses}
self.assertSetEqual(set1=email_addresses_set,
set2={'*****@*****.**'})
def run_test_required_fields(self, data):
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.
_registration_form_all_the_required_fields_are_required_errors_dict(
))
def test_required_fields_1(self):
data = {}
self.run_test_required_fields(data=data)
def test_required_fields_2(self):
data = {field_name: '' for field_name in self.required_fields}
self.run_test_required_fields(data=data)
def test_non_unique_confirmed_email_address(self):
existing_user_email = UserEmailAddressFactory(
email=self.data['email'], is_confirmed=True)
existing_user = existing_user_email.user
self.assert_models_count(
entity_count=1,
user_count=1,
user_email_address_count=1,
confirmed_email_address_count=1,
unconfirmed_email_address_count=0,
)
self.assert_user_email_addresses_count(
user=existing_user,
user_email_addresses_count=1,
user_primary_email_addresses_count=1,
user_confirmed_email_addresses_count=1,
user_unconfirmed_email_addresses_count=0,
)
form = RegistrationForm(language_code=self.language_code,
data=self.data)
form.full_clean()
self.assertFalse(expr=form.is_valid())
self.assertDictEqual(
d1=form.errors,
d2=self._this_email_is_already_in_use_errors_dict())
self.assert_models_count(
entity_count=1,
user_count=1,
user_email_address_count=1,
confirmed_email_address_count=1,
unconfirmed_email_address_count=0,
)
self.assert_user_email_addresses_count(
user=existing_user,
user_email_addresses_count=1,
user_primary_email_addresses_count=1,
user_confirmed_email_addresses_count=1,
user_unconfirmed_email_addresses_count=0,
)
existing_user = User.objects.get(pk=existing_user.pk)
self.assert_user_email_addresses_count(
user=existing_user,
user_email_addresses_count=1,
user_primary_email_addresses_count=1,
user_confirmed_email_addresses_count=1,
user_unconfirmed_email_addresses_count=0,
)
def test_non_unique_unconfirmed_email_address(self):
# Unconfirmed email address is deleted if another user adds it again.
existing_user_email = UserEmailAddressFactory(
email=self.data['email'], is_confirmed=False)
existing_user = existing_user_email.user
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,
)
self.assert_user_email_addresses_count(
user=existing_user,
user_email_addresses_count=1,
user_primary_email_addresses_count=1,
user_confirmed_email_addresses_count=0,
user_unconfirmed_email_addresses_count=1,
)
form = RegistrationForm(language_code=self.language_code,
data=self.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=2,
user_count=2,
user_email_address_count=1,
confirmed_email_address_count=0,
unconfirmed_email_address_count=1,
)
self.assert_user_email_addresses_count(
user=existing_user,
user_email_addresses_count=0,
user_primary_email_addresses_count=0,
user_confirmed_email_addresses_count=0,
user_unconfirmed_email_addresses_count=0,
)
existing_user = User.objects.get(pk=existing_user.pk)
self.assert_user_email_addresses_count(
user=existing_user,
user_email_addresses_count=0,
user_primary_email_addresses_count=0,
user_confirmed_email_addresses_count=0,
user_unconfirmed_email_addresses_count=0,
)
def test_slug_validation_fails_with_reserved_username(self):
data = self.data.copy()
data['slug'] = 'webmaster'
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._this_username_is_already_taken_errors_dict(
slug_fail=True))
def test_slug_validation_fails_with_reserved_and_too_short_username(
self):
data = self.data.copy()
data['slug'] = 'mail'
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=4))
def test_slug_validation_fails_with_username_already_taken(self):
ActiveUserFactory(slug='validslug')
data = self.data.copy()
data['slug'] = 'valid-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._this_username_is_already_taken_errors_dict(
slug_fail=True))
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_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:
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_and_username_min_length_ok(self):
self.assertEqual(first=User.settings.MIN_SLUG_LENGTH, second=6)
test_settings = {
"expected_counts_tuple": (8, 0),
}
self.run_test_all_slugs_to_test_list(test_settings=test_settings)
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MIN_SLUG_LENGTH=tests_settings.OVERRIDE_USER_SETTINGS.
MIN_SLUG_LENGTH))
def test_slug_min_length_fail_username_min_length_ok(self):
self.assertEqual(first=User.settings.MIN_SLUG_LENGTH, second=60)
test_settings = {
"expected_counts_tuple": (4, 4),
}
self.run_test_all_slugs_to_test_list(test_settings=test_settings)
def test_slug_validation_fails_with_username_too_long(self):
data = self.data.copy()
data['slug'] = 'a' * 201
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_most_max_length_alphanumeric_characters_errors_dict_by_value_length(
model=User, slug_fail=True, username_value_length=201))
def test_slug_validation_fails_with_invalid_username_regex(self):
slug_list = [
'0' * 6, '0test1', '1234567890digits', 'aaa', 'aaa 9999',
'aaa-9999', 'aaa+9999'
]
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.assertFalse(expr=form.is_valid(),
msg="{} is a valid slug.".format(slug))
self.assertDictEqual(
d1=form.errors,
d2=self.
_username_must_start_with_4_or_more_letters_errors_dict(
model=User, slug_fail=True),
msg='"{}" - Unexpected error messages.'.format(slug))
def test_cannot_register_invalid_email(self):
data = self.data.copy()
data['email'] = 'email'
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._enter_a_valid_email_address_errors_dict())
def test_invalid_date_of_birth_list_fail(self):
for date_of_birth in tests_settings.INVALID_DATE_OF_BIRTH_IN_FORMS_LIST:
data = self.data.copy()
data['date_of_birth'] = date_of_birth
form = RegistrationForm(language_code=self.language_code,
data=data)
form.full_clean()
self.assertFalse(
expr=form.is_valid(),
msg="{} is a valid date of birth.".format(date_of_birth))
self.assertDictEqual(
d1=form.errors,
d2=self._date_of_birth_errors_dict_by_date_of_birth(
date_of_birth=date_of_birth),
msg='"{}" - Unexpected error messages.'.format(
date_of_birth))
class AcceptFriendshipRequestViewTestCaseMixin(
SpeedyCoreFriendsLanguageMixin):
def set_up(self):
super().set_up()
self.first_user = ActiveUserFactory()
self.second_user = ActiveUserFactory()
friendship_request = Friend.objects.add_friend(
from_user=self.first_user, to_user=self.second_user)
self.page_url = '/{}/friends/request/accept/{}/'.format(
self.second_user.slug, friendship_request.pk)
self.second_user_friends_list_url = '/{}/friends/'.format(
self.second_user.slug)
def test_visitor_cannot_accept_friendship_request(self):
self.client.logout()
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url='/login/?next={}'.format(
self.page_url),
status_code=302,
target_status_code=200)
self.assertIsNone(obj=r.context)
def test_user_cannot_accept_friendship_request_they_sent_another_user(
self):
self.client.login(username=self.first_user.slug,
password=tests_settings.USER_PASSWORD)
r = self.client.post(path=self.page_url)
self.assertEqual(first=r.status_code, second=403)
def test_user_that_has_received_request_can_accept_it(self):
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
expected_url = self.first_user.get_absolute_url()
self.assertRedirects(response=r,
expected_url=expected_url,
status_code=302,
target_status_code=200,
fetch_redirect_response=False)
self.assertTrue(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
self.assertIsNone(obj=r.context)
r = self.client.get(path=expected_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[self._friendship_request_accepted_success_message])
r = self.client.get(path=expected_url)
self.assertListEqual(list1=list(map(str, r.context['messages'])),
list2=[])
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_can_accept_it_if_not_maximum(
self):
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED - 1):
Friend.objects.add_friend(
from_user=self.second_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
expected_url = self.first_user.get_absolute_url()
self.assertRedirects(response=r,
expected_url=expected_url,
status_code=302,
target_status_code=200,
fetch_redirect_response=False)
self.assertTrue(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
self.assertIsNone(obj=r.context)
r = self.client.get(path=expected_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[self._friendship_request_accepted_success_message])
r = self.client.get(path=expected_url)
self.assertListEqual(list1=list(map(str, r.context['messages'])),
list2=[])
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_cannot_accept_it_if_maximum(
self):
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED):
Friend.objects.add_friend(
from_user=self.second_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
expected_url = self.first_user.get_absolute_url()
self.assertRedirects(response=r,
expected_url=expected_url,
status_code=302,
target_status_code=200,
fetch_redirect_response=False)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.get(path=expected_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[
self.
_you_already_have_friends_error_message_by_user_number_of_friends_and_gender(
user_number_of_friends=4,
gender=self.second_user.get_gender())
])
r = self.client.get(path=expected_url)
self.assertListEqual(list1=list(map(str, r.context['messages'])),
list2=[])
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_can_accept_it_if_other_not_maximum(
self):
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED - 1):
Friend.objects.add_friend(
from_user=self.first_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
expected_url = self.first_user.get_absolute_url()
self.assertRedirects(response=r,
expected_url=expected_url,
status_code=302,
target_status_code=200,
fetch_redirect_response=False)
self.assertTrue(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
self.assertIsNone(obj=r.context)
r = self.client.get(path=expected_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[self._friendship_request_accepted_success_message])
r = self.client.get(path=expected_url)
self.assertListEqual(list1=list(map(str, r.context['messages'])),
list2=[])
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_cannot_accept_it_if_other_maximum(
self):
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED):
Friend.objects.add_friend(
from_user=self.first_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
expected_url = self.first_user.get_absolute_url()
self.assertRedirects(response=r,
expected_url=expected_url,
status_code=302,
target_status_code=200,
fetch_redirect_response=False)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.get(path=expected_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[
self.
_this_user_already_has_friends_error_message_by_other_user_number_of_friends_and_both_genders(
other_user_number_of_friends=4,
both_genders=get_both_genders_context_from_users(
user=self.second_user, other_user=self.first_user))
])
r = self.client.get(path=expected_url)
self.assertListEqual(list1=list(map(str, r.context['messages'])),
list2=[])
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
class AcceptFriendRequestViewTestCaseMixin(SpeedyCoreFriendsLanguageMixin):
def set_up(self):
super().set_up()
self.first_user = ActiveUserFactory()
self.second_user = ActiveUserFactory()
friendship_request = Friend.objects.add_friend(
from_user=self.first_user, to_user=self.second_user)
self.page_url = '/{}/friends/request/accept/{}/'.format(
self.second_user.slug, friendship_request.pk)
self.second_user_friends_list_url = '/{}/friends/'.format(
self.second_user.slug)
def test_visitor_cannot_accept_friend_request(self):
self.client.logout()
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url='/login/?next={}'.format(
self.page_url))
self.assertIsNone(obj=r.context)
def test_user_cannot_accept_friend_request_he_sent_another_user(self):
self.client.login(username=self.first_user.slug,
password=tests_settings.USER_PASSWORD)
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url='/login/?next={}'.format(
self.page_url))
self.assertIsNone(obj=r.context)
@unittest.expectedFailure # ~~~~ TODO: fix this test!
def test_user_that_has_received_request_can_accept_it(self):
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url=self.second_user_friends_list_url)
self.assertTrue(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
self.assertIsNone(obj=r.context)
r = self.client.get(path=self.second_user_friends_list_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[self._friend_request_accepted_success_message]) ###### TODO
@unittest.expectedFailure # ~~~~ TODO: fix this test!
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_can_accept_it_if_not_maximum(self):
# ~~~~ TODO: remove all the following lines.
self._1___set_up(
django_settings=django_settings) #### ~~~~ TODO: remove this line!
# print("test_user_that_has_received_request_can_accept_it_if_not_maximum: django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED", django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# print("test_user_that_has_received_request_can_accept_it_if_not_maximum: User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED", User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# ~~~~ TODO: remove all the above lines.
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED - 1):
Friend.objects.add_friend(from_user=self.second_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url=self.second_user_friends_list_url)
self.assertTrue(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
self.assertIsNone(obj=r.context)
r = self.client.get(path=self.second_user_friends_list_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[self._friend_request_accepted_success_message]) ###### TODO
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_cannot_accept_it_if_maximum(self):
# ~~~~ TODO: remove all the following lines.
self._1___set_up(
django_settings=django_settings) #### ~~~~ TODO: remove this line!
# print("test_user_that_has_received_request_cannot_accept_it_if_maximum: django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED", django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# print("test_user_that_has_received_request_cannot_accept_it_if_maximum: User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED", User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# ~~~~ TODO: remove all the above lines.
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED):
Friend.objects.add_friend(from_user=self.second_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url=self.second_user_friends_list_url,
fetch_redirect_response=False)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.get(path=self.second_user_friends_list_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[
self.
_you_already_have_friends_error_message_by_user_number_of_friends_and_gender(
user_number_of_friends=4,
gender=self.second_user.get_gender())
]) #####-1 TODO
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
@unittest.expectedFailure # ~~~~ TODO: fix this test!
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_can_accept_it_if_other_not_maximum(
self):
# ~~~~ TODO: remove all the following lines.
self._1___set_up(
django_settings=django_settings) #### ~~~~ TODO: remove this line!
# print("test_user_that_has_received_request_can_accept_it_if_other_not_maximum: django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED", django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# print("test_user_that_has_received_request_can_accept_it_if_other_not_maximum: User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED", User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# ~~~~ TODO: remove all the above lines.
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED - 1):
Friend.objects.add_friend(from_user=self.first_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url=self.second_user_friends_list_url)
self.assertTrue(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
self.assertIsNone(obj=r.context)
r = self.client.get(path=self.second_user_friends_list_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[self._friend_request_accepted_success_message]) ###### TODO
@override_settings(
USER_SETTINGS=get_django_settings_class_with_override_settings(
django_settings_class=django_settings.USER_SETTINGS,
MAX_NUMBER_OF_FRIENDS_ALLOWED=tests_settings.
OVERRIDE_USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED))
def test_user_that_has_received_request_cannot_accept_it_if_other_maximum(
self):
# ~~~~ TODO: remove all the following lines.
self._1___set_up(
django_settings=django_settings) #### ~~~~ TODO: remove this line!
# print("test_user_that_has_received_request_cannot_accept_it_if_other_maximum: django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED", django_settings.USER_SETTINGS.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# print("test_user_that_has_received_request_cannot_accept_it_if_other_maximum: User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED", User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED)####
# ~~~~ TODO: remove all the above lines.
self.assertEqual(first=User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED,
second=4)
for i in range(User.settings.MAX_NUMBER_OF_FRIENDS_ALLOWED):
Friend.objects.add_friend(from_user=self.first_user,
to_user=ActiveUserFactory()).accept()
self.client.login(username=self.second_user.slug,
password=tests_settings.USER_PASSWORD)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.post(path=self.page_url)
self.assertRedirects(response=r,
expected_url=self.second_user_friends_list_url,
fetch_redirect_response=False)
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))
r = self.client.get(path=self.second_user_friends_list_url)
self.assertListEqual(
list1=list(map(str, r.context['messages'])),
list2=[
self.
_this_user_already_has_friends_error_message_by_other_user_number_of_friends_and_gender(
other_user_number_of_friends=4,
gender=self.first_user.get_gender())
]) #####-1 TODO
self.assertFalse(expr=Friend.objects.are_friends(
user1=self.first_user, user2=self.second_user))