def test_change_email(self, mock_send_verification): user_email = faker.email() user_pwd = faker.text() user = get_user_model().objects.create_user( email=user_email, password=user_pwd, short_name=faker.first_name()) response = models.EmailAddress.objects.check_email(user, user_email) self.assertTrue(response[0]) user_email2 = faker.email() email_address = models.EmailAddress.objects.add_email( user, user_email2) response = models.EmailAddress.objects.check_email(user, user_email2) self.assertFalse(response[0]) self.assertEqual(response[1], settings.EXO_ACCOUNTS_VALIDATION_CHOICES_NOT_VERIFIED) email_address.verified_at = timezone.now() email_address.save() user.refresh_from_db() self.assertEqual(user.email, user_email) response = models.EmailAddress.objects.check_email(user, user_email2) self.assertTrue(response[0]) self.assertEqual(response[1], settings.EXO_ACCOUNTS_VALIDATION_CHOICES_VERIFIED) other_email = faker.email() get_user_model().objects.create_user(email=other_email, password=user_pwd, short_name=faker.first_name()) response = models.EmailAddress.objects.check_email(user, other_email) self.assertFalse(response[0]) self.assertEqual(response[1], settings.EXO_ACCOUNTS_VALIDATION_CHOICES_OTHER_USER) response = models.EmailAddress.objects.check_email(user, faker.email()) self.assertTrue(response[0]) self.assertEqual(response[1], settings.EXO_ACCOUNTS_VALIDATION_CHOICES_PENDING)
def test_get_or_create(self): name = faker.first_name() email = faker.email() user, created = User.objects.get_or_create( email=email, defaults={'short_name': name}) self.assertTrue(created) self.assertIsNotNone(user) self.assertEqual(user.email, email) self.assertEqual(user.short_name, name) self.assertTrue(user.has_usable_password()) user2 = User.objects.get_or_create( email=faker.email(), defaults={'short_name': faker.first_name()}) self.assertIsNotNone(user2) user3, created = User.objects.get_or_create(email=faker.email(), defaults={ 'short_name': name, 'full_name': '{} {}'.format( faker.first_name(), faker.last_name()), 'is_active': True, 'password': name }) self.assertIsNotNone(user3) self.assertTrue(created) self.assertNotEqual(user3.full_name, '') self.assertTrue(user3.has_usable_password()) self.assertTrue(user3.is_active) self.assertTrue(user3.check_password(name)) user4, created = User.objects.get_or_create(email=email) self.assertFalse(created) self.assertEqual(user4.id, user.id)
def test_filter_by_name(self): first_name1 = faker.first_name() + faker.numerify() last_name1 = faker.last_name() + faker.numerify() first_name2 = faker.first_name() + faker.numerify() last_name2 = faker.last_name() + faker.numerify() FakeConsultantFactory.create( user__short_name=first_name1, user__full_name=last_name1, ) FakeConsultantFactory.create( user__short_name=first_name2, user__full_name=last_name2, ) FakeConsultantFactory.create( user__short_name=first_name1, user__full_name=last_name2, ) FakeConsultantFactory.create( user__short_name=first_name2, user__full_name=last_name1, ) queryset = Consultant.all_objects.all() filter = {'name': first_name1} self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 2) filter = {'name': last_name2} self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 2) filter = {'name': first_name1 + ' ' + last_name2} self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 3) filter = {'name': first_name1 + ' ' + first_name2} self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 4)
def test_change_summary_not_required(self): # PREPARE DATA consultant = FakeConsultantFactory.create( user__is_active=True, user__bio_me=None, user__password='******', ) self.client.login( username=consultant.user.email, password='******', ) url = reverse( 'api:profile:summary', kwargs={'pk': consultant.user.pk}, ) data = { 'short_name': faker.first_name(), 'full_name': '', 'timezone': 'Canada/Eastern', } # DO ACTION response = self.client.put(url, data=data, format='json') # ASSERTS self.assertTrue(status.is_success(response.status_code)) consultant.user.refresh_from_db() consultant.refresh_from_db() user = consultant.user self.assertEqual(user.short_name, data['short_name']) self.assertEqual(consultant.languages.count(), 0) self.assertEqual(user.timezone.zone, 'Canada/Eastern')
def test_sprint_launch(self): sprint = self.customer.create_sprint_automated( self.super_user, faker.first_name(), start=timezone.now(), description='', ) project = sprint.project_ptr new_user_email = faker.email() new_user_name = faker.name() team = FakeTeamFactory.create( project=sprint.project_ptr, user_from=self.super_user, coach__user__is_active=True, ) member = team.add_member( user_from=self.super_user, email=new_user_email, name=new_user_name, ) project_setting = project.settings fixed_pass = faker.password() project_setting.launch['send_welcome_participant'] = False project_setting.launch['send_welcome_consultant'] = True project_setting.launch['fix_password'] = fixed_pass project_setting.save() mail.outbox = [] project.launch(self.super_user, start_date=timezone.now()) member.refresh_from_db() self.assertEqual(len(mail.outbox), 1) self.assertTrue(member.check_password(fixed_pass))
def test_filter_simple(self): first_name = faker.first_name() wrong_name = faker.numerify() language_esp = Language.objects.get(name='Spanish') language_eng = Language.objects.get(name='English') FakeConsultantFactory.create( user__short_name=first_name, languages=[language_esp], ) FakeConsultantFactory.create( user__short_name=wrong_name, user__full_name=wrong_name, languages=[language_esp], ) FakeConsultantFactory.create( user__short_name=wrong_name, user__full_name=wrong_name, languages=[language_eng], ) filter = {'name': first_name} self.assertEqual( Consultant.all_objects.filter_complex(*filter, **filter).count(), 1) filter = {'language': language_esp} self.assertEqual( Consultant.all_objects.filter_complex(*filter, **filter).count(), 2)
def test_api_create_no_members(self, task_handler): coaches = FakeConsultantFactory.create_batch( size=3, user__is_active=True, status=settings.CONSULTANT_STATUS_CH_ACTIVE, ) for coach in coaches: ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, consultant=coach, project=self.sprint.project_ptr, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) self.client.login(username=self.super_user.username, password='******') url = reverse('api:project:team:create', kwargs={'project_id': self.sprint.project_ptr.pk}) data = { 'name': faker.first_name(), 'stream': 'S', 'zoom_id': faker.word(), 'coach': coaches[0].pk, 'team_members': [], } response = self.client.post(url, data=data, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual( Team.objects.filter(project=self.sprint.project_ptr).count(), 1)
def test_delete_team(self): new_team = FakeTeamFactory( user_from=self.super_user, coach__user__is_active=True, ) member = new_team.add_member( user_from=self.super_user, email=faker.email(), name=faker.first_name(), ) coach = new_team.coach new_team.delete() self.assertFalse( member.has_perm( settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team, )) self.assertFalse( coach.user.has_perm( settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team, )) self.assertFalse( coach.user.has_perm( settings.TEAM_PERMS_COACH_TEAM, new_team, ))
def create_team_api(self): coaches = FakeConsultantFactory.create_batch( size=4, user__is_active=True, status=settings.CONSULTANT_STATUS_CH_ACTIVE, ) for coach in coaches: ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, consultant=coach, project=self.sprint.project_ptr, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) self.client.login(username=self.super_user.username, password='******') url = reverse('api:project:team:create', kwargs={'project_id': self.sprint.project_ptr.pk}) members = [] for k in range(5): name = faker.word() email = faker.email() members.append({'short_name': name, 'email': email}) data = { 'name': faker.first_name(), 'stream': 'S', 'zoom_id': faker.word(), 'coach': coaches[0].pk, 'team_members': members, } response = self.client.post(url, data=data, format='json') return response, coaches
def test_change_previous_used_email(self, mock_send_verification): admin_user = FakeUserFactory.create(is_superuser=True, is_active=True) user_email = faker.email() user_pwd = faker.text() user = get_user_model().objects.create_user( email=user_email, password=user_pwd, short_name=faker.first_name()) unused_email = faker.email() email = models.EmailAddress.objects.create(user=user, email=unused_email) self.assertFalse(email.is_verified) self.assertEqual(user.email, user_email) # own user status, _ = models.EmailAddress.objects.change_user_email( user, user, unused_email) self.assertFalse(status) user.refresh_from_db() self.assertEqual(user.email, user_email) self.assertTrue(mock_send_verification.called) mock_send_verification.reset_mock() # admin user status, _ = models.EmailAddress.objects.change_user_email( admin_user, user, unused_email) self.assertTrue(status) user.refresh_from_db() self.assertEqual(user.email, unused_email) self.assertFalse(mock_send_verification.called) # Return a previous email already verified status, _ = models.EmailAddress.objects.change_user_email( user, user, user_email) self.assertTrue(status) user.refresh_from_db() self.assertEqual(user.email, user_email) self.assertFalse(mock_send_verification.called)
def test_accept_profile_user_optionals(self): # PREPARE DATA consultant, invitation = self.create_validation_agreement( settings.CONSULTANT_VALIDATION_BASIC_PROFILE, ) self.client.login( username=consultant.user.email, password='******', ) url = reverse( 'api:invitation:invitation-accept', kwargs={'hash': invitation.hash}, ) location_granada = 'Granada, Spain' place_id_granada = 'ChIJfcIyLeb8cQ0Rcg1g0533WJI' data = { 'profilePicture': '', 'shortName': faker.first_name(), 'fullName': faker.name(), 'location': location_granada, 'placeId': place_id_granada, } # DO ACTION response = self.client.post(url, data=data, format='json') # ASSERTS self.assertTrue(status.is_success(response.status_code)) invitation.refresh_from_db() self.assertTrue(invitation.is_active) consultant.refresh_from_db() user = consultant.user user.refresh_from_db() self.assertIsNotNone(user.profile_picture) self.assertIsNotNone(user.timezone)
def test_create_step2_executed(self): # DO ACTION self.consultant = Consultant.objects.create_consultant( short_name=faker.first_name(), email=faker.email(), invite_user=self.super_user, registration_process=True, version=3, ) mail.outbox = [] process = self.consultant.registration_process step = process.steps.first() invitation = step.invitation invitation.accept(invitation.user) # ASSETS self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, [self.super_user.email]) # DO ACTION current_step = process.current_step invitation = current_step.invitation mail.outbox = [] self.assertTrue(self.consultant.agreement.is_pending) invitation.accept(self.consultant.user) # ASSETS self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, [self.super_user.email]) self.assertIsNotNone(self.consultant.agreement) self.assertTrue(self.consultant.agreement.is_accepted) circle = Circle.objects.filter(name__icontains='Community').get() self.assertFalse(self.consultant.user in circle.followers)
def get_mock_data(self, optional=True): mock_data = { 'name': faker.first_name(), 'email': faker.email(), 'step_name': faker.word(), } return mock_data
def test_create_step1_executed(self): # DO ACTION mail.outbox = [] self.consultant = Consultant.objects.create_consultant( short_name=faker.first_name(), email=faker.email(), invite_user=self.super_user, registration_process=True, version=3, ) # ASSERTS process = self.consultant.registration_process self.assertTrue(self.consultant.user.has_usable_password()) self.assertEqual(len(mail.outbox), 1) # DO ACTION step = process.steps.first() invitation = step.invitation new_password = faker.word() invitation.accept(invitation.user, password=new_password) step.refresh_from_db() # ASSETS self.consultant = Consultant.all_objects.get(pk=self.consultant.pk) self.assertEqual(self.consultant.user.email, invitation.user.email) self.assertTrue(self.consultant.user.check_password(new_password)) self.assertTrue(step.is_executed) self.assertTrue(invitation.is_active) circle = Circle.objects.filter(name__icontains='Community').get() self.assertFalse(self.consultant.user in circle.followers)
def test_create_step1_executed_change_email(self): # DO ACTION mail.outbox = [] original_email = faker.email() self.consultant = Consultant.objects.create_consultant( short_name=faker.first_name(), email=original_email, invite_user=self.super_user, registration_process=True, version=3, ) # ASSETS process = self.consultant.registration_process step = process.steps.first() invitation = step.invitation new_password = faker.word() new_email = faker.email() mail.outbox = [] invitation.accept(invitation.user, email=new_email, password=new_password) self.consultant = Consultant.all_objects.get(pk=self.consultant.pk) self.assertEqual(self.consultant.user.email, original_email) self.assertTrue(self.consultant.user.emailaddress_set.get(email=original_email).is_verified) self.assertFalse(self.consultant.user.emailaddress_set.get(email=new_email).is_verified) # one to network-admin and other for validation email self.assertEqual(len(mail.outbox), 2)
def test_create_step3_executed(self): # DO ACTION self.consultant = Consultant.objects.create_consultant( short_name=faker.first_name(), email=faker.email(), invite_user=self.super_user, registration_process=True, version=3, ) process = self.consultant.registration_process step = process.steps.first() invitation = step.invitation invitation.accept(invitation.user) current_step = process.current_step invitation = current_step.invitation invitation.accept(self.consultant.user) invitation = process.current_step.invitation invitation.accept(invitation.user) consultant_default_circles = Circle.objects.filter( name__in=settings.CIRCLES_FOR_CONSULTANTS) # ASSERTS self.assertTrue(process.is_registered) self.consultant.refresh_from_db() self.assertTrue(self.consultant.is_active) self.assertEqual( set(list(following(self.consultant.user, Circle))), set(list(consultant_default_circles)), )
def test_upload_members(self, mock_request): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.super_user) url = reverse( 'api:event:participant-upload', kwargs={'event_id': self.event.uuid.__str__()}, ) content = '' for k in range(10): full_name = '{} {}'.format(faker.first_name(), faker.last_name()) content += '{},{}\n'.format(full_name, faker.email()) data = { 'content': content, 'exo_role': settings.EXO_ROLE_CODE_SUMMIT_PARTICIPANT, } # DO ACTION response = self.client.post(url, data=data, format='json') # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertEqual(len(response.data), 10) self.assertEqual(self.event.participants.count(), 10)
def test_add_member_no_customer(self): # PREPARE DATA url = reverse( 'api:relation:project:userprojectrole-list', kwargs={'project_id': self.sprint.project_ptr.pk}, ) data = { 'name': '{} {}'.format(faker.first_name(), faker.last_name()), 'email': faker.email(), 'exo_role': settings.EXO_ROLE_CODE_SPRINT_PARTICIPANT, } self.client.login(username=self.user.email, password='******') # DO ACTION response = self.client.post(url, data=data, format='json') # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertEqual( self.sprint.project_ptr.users_roles.filter( user__email=data['email']).count(), 1) role = UserProjectRole.objects.filter( project=self.sprint.project_ptr, user__email=data['email']).first() self.assertEqual(Invitation.objects.filter_by_object(role).count(), 1) invitation = Invitation.objects.filter_by_object(role)[0] self.assertTrue(invitation.is_pending) self.assertTrue(role.is_inactive) self.assertEqual(role.user.short_name, data['name'].split(' ')[0]) self.assertEqual(role.user.full_name, data['name'])
def test_do_logout_step3(self): # PREPARE DATA self.consultant = Consultant.objects.create_consultant( short_name=faker.first_name(), email=faker.email(), invite_user=self.super_user, registration_process=True, version=3, ) process = self.consultant.registration_process step = process.steps.first() invitation = step.invitation invitation.accept(invitation.user) current_step = process.current_step invitation = current_step.invitation invitation.accept(self.consultant.user) mock = Mock() self.middleware = ConsultantActivationMiddleware(mock) # DO ACTION self.request.path = '/accounts/logout/' self.request.user = self.consultant.user response = self.middleware(self.request) # ASSERTS self.assertIsNotNone(response) self.assertTrue(isinstance(response, Mock))
def test_lauch_project_and_check_team_invitations(self): project = FakeProjectFactory() users = [{ 'email': faker.email(), 'name': faker.first_name() } for _ in range(2)] team = FakeTeamFactory(project=project) team.update_members(self.super_user, members=users) for team_member in team.team_members.all(): team_member_team_invitation = Invitation.objects.filter_by_object(team) \ .filter(user=team_member) self.assertEqual(team_member_team_invitation.count(), 1) self.assertTrue(team_member_team_invitation.first().is_pending) self.assertFalse(project.autoactive) project.launch(self.super_user, start_date=timezone.now()) self.assertTrue(project.autoactive) for team_member in team.team_members.all(): team_member_team_invitation = Invitation.objects.filter_by_object(team) \ .filter(user=team_member) self.assertEqual(team_member_team_invitation.count(), 1) self.assertTrue(team_member_team_invitation.first().is_active) project.set_started(self.super_user, timezone.now()) for team_member in team.team_members.all(): team_member_team_invitation = Invitation.objects.filter_by_object(team) \ .filter(user=team_member) self.assertEqual(team_member_team_invitation.count(), 1) self.assertTrue(team_member_team_invitation.first().is_active) # ## # Add a new Member and test SignUp invitaion is active # ## new_user = {'email': faker.email(), 'name': faker.first_name()} team.update_members(user_from=self.super_user, members=[new_user]) new_member = get_user_model().objects.get(email=new_user.get('email')) team_member_team_invitation = Invitation.objects.filter_by_object(team) \ .filter(user=new_member) self.assertEqual(team_member_team_invitation.count(), 1) self.assertTrue(team_member_team_invitation.first().is_active)
def test_create_user(self): user_email = faker.email().upper() user_pwd = faker.text() user = get_user_model().objects.create_user( email=user_email, password=user_pwd, short_name=faker.first_name()) self.assertTrue(user.emailaddress_set.all().count() > 0) self.assertTrue(user.emailaddress_set.all()[0].is_verified) self.assertEqual(user.email, user_email.lower())
def get_mock_data(self, optional=True): mock_data = { 'user': faker.first_name(), 'email': faker.email(), 'public_url': faker.url() } return mock_data
def test_default_create_user(self): # ## # By default set a NOT USABLE password # ## user = User.objects.create_user(email=faker.email(), short_name=faker.first_name()) self.assertTrue(user.has_usable_password()) self.assertTrue(user.can_authenticate)
def save_user(user): user.short_name = faker.first_name() user.full_name = faker.name() user.email = email(user) user.bio_me = faker.text() user.short_me = faker.text() user.about_me = faker.text() user.profile_picture.name = None user.profile_picture_origin = settings.EXO_ACCOUNTS_PROFILE_PICTURE_CH_DEFAULT user.save() return user
def generate_fake_data(self): return { 'uuid': uuid.uuid4().__str__(), 'short_name': faker.first_name(), 'full_name': faker.name(), 'email': faker.email(), 'password': faker.password(), 'is_active': True, 'is_superuser': False, 'is_staff': False, }
def test_change_email(self, mock_send_verification): user_email = faker.email() user_pwd = faker.text() user = get_user_model().objects.create_user( email=user_email, password=user_pwd, short_name=faker.first_name(), ) url = reverse('api:accounts:validate-email') # Logged user self.client.login(username=self.super_user.email, password='******') data = { 'user': user.pk, 'email': user_email, } # admin user response = self.client.post(url, data=data, format='json') self.assertTrue(status.is_success(response.status_code)) # own user self.client.login(username=user.email, password=user_pwd) response = self.client.post(url, data=data, format='json') self.assertTrue(status.is_success(response.status_code)) # ## # not valid email # ## other_email = faker.email() get_user_model().objects.create_user( email=other_email, password=user_pwd, short_name=faker.first_name(), ) data['email'] = other_email response = self.client.post(url, data=data, format='json') self.assertTrue(status.is_client_error(response.status_code))
def test_get_or_create_several_emailaddress(self): name = faker.first_name() email = faker.email() user, created = User.objects.get_or_create( email=email, defaults={'short_name': name}) self.assertTrue(created) email2 = faker.email() user.add_email_address(email2) user2, created = User.objects.get_or_create( email=email2, defaults={'short_name': name}) self.assertFalse(created) self.assertEqual(user2.pk, user.pk)
def test_create_user(self): user_email = faker.email() user_pwd = '123456789' user = User.objects.create_user(email=user_email, password=user_pwd, short_name=faker.first_name()) self.assertIsNotNone(user.profile_picture) self.assertTrue(user.profile_picture != '') for size in user._meta.get_field('profile_picture').thumbnails: self.assertIsNotNone( user.profile_picture.get_thumbnail_url(size[0], size[1]))
def get_mock_data(self, optional=True): """Returns mock data for this mail, this will use to preview the html or send mock args in the email You need to maintain this method if you want better results """ mock_data = { 'name': faker.first_name(), 'email': faker.email(), 'message': faker.sentences(nb=3), } return mock_data
def get_mock_data(self, optional=True): project_name = faker.word() team_name = faker.word() mock_data = { 'team_name': team_name, 'project_name': project_name, 'relation_name': '[relation_name]', 'user': faker.first_name(), 'is_coach': random.randint(0, 1), 'public_url': '/{}'.format(faker.uri_path()), } return mock_data