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