def test_create_answer_with_mentions(self): # PREPARE DATA self.circle = Circle.objects.first() self.user.hubs.create(hub=self.circle.hub) post = Post.objects.create_circle_post(user_from=self.user, circle=self.circle, title=' '.join(faker.words()), description=faker.text()) post_id = post.pk self.post = Post.objects.get(pk=post_id) user = FakeUserFactory.create(is_active=True, password='******') self.circle.add_user(user) user_mentioned = FakeUserFactory.create(is_active=True) reply_comment = 'Hi \ <a {}="{}" {}="{}">{}</a> \ '.format( DEFAULT_TYPE_PATTERN, user_mentioned.__class__.__name__, DEFAULT_UUID_PATTERN, user_mentioned.pk, user_mentioned.short_name, ) # DO ACTIONS self.answer = self.post.reply(user, reply_comment) # ASSERTS self.assertTrue(user.actor_actions.all().filter( verb=settings.MENTION_VERB).exists())
def test_filter_by_user_or_organization(self): # PREPARE DATA name = settings.BRAND_NAME users = FakeUserFactory.create_batch(size=2, is_active=True) customer = FakeCustomerFactory.create() organization = InternalOrganization.objects.get(name=name) for user in users: user.user_permissions.add( Permission.objects.get( codename=settings.PROJECT_PERMS_ADD_PROJECT)) user.user_permissions.add( Permission.objects.get( codename=settings.SPRINT_AUTOMATED_ADD_SPRINT)) organization.users_roles.get_or_create(user=user) FakeSprintAutomatedFactory.create_batch( size=3, created_by=users[0], internal_organization=organization) customer.create_sprint_automated( user_from=users[1], name=faker.name(), description=faker.text(), duration=settings.SPRINT_AUTOMATED_STEPS_COUNT, ) # DO ACTION and ASSERTS for user in users: projects = Project.objects.filter_by_user_or_organization( user).count() self.assertEqual(projects, 4) self.assertEqual( Project.objects.filter_by_user_or_organization( FakeUserFactory.create(is_active=True)).count(), 0)
def prepare_data(self): self.sprint_automated = FakeSprintAutomatedFactory.create() self.team = FakeTeamFactory.create( project=self.sprint_automated.project_ptr) self.step = FakeStepFactory.create(project=self.team.project) self.populate_assignments_version_2( self.sprint_automated, settings.PROJECT_CH_TEMPLATE_ASSIGNMENTS_SPRINT_BOOK) consultant_manager_user = FakeUserFactory.create() consultant_for_manager_role = FakeConsultantFactory.create( user=consultant_manager_user, status=settings.CONSULTANT_STATUS_CH_ACTIVE, ) team_member = FakeUserFactory.create() self.team.team_members.add(self.user) self.team.team_members.add(team_member) self.manager_role, _ = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, project=self.sprint_automated.project_ptr, consultant=consultant_for_manager_role, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_HEAD_COACH), ) self.sprint_automated.launch(self.super_user)
def test_api_call_user_no_circle_permission(self): # PREPARE DATA # PREPARE DATA circle = Circle.objects.first() user1 = FakeUserFactory() user2 = FakeUserFactory() circle.add_user(user1) url = reverse('api:circles:followers', kwargs={'slug': circle.slug}) test_cases = [ { 'user': user1, 'status': status.HTTP_200_OK }, { 'user': user2, 'status': status.HTTP_403_FORBIDDEN }, ] # DO ACTION for test_case in test_cases: self.client.login(username=test_case.get('user').username, password='******') response = self.client.get(url) # ASSERTS self.assertTrue(response.status_code, test_case.get('status'))
def test_discard_email(self, mock): user = FakeUserFactory() new_email = faker.email() email = EmailAddress.objects.create( user=user, email=new_email, ) url = reverse('api:accounts:discard-email') data = { 'verif_key': email.verif_key, 'email': email.pk, } # ## # User not logged # ## response = self.client.post(url, data=data, format='json') self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code) # ## # Logged user # ## self.client.login(username=user.email, password=user.short_name) response = self.client.post(url, data=data, format='json') self.assertTrue(status.is_success(response.status_code)) # ## # Check an Email already verified # ## new_email_1 = faker.email() new_email_1_address = user.add_email_address(new_email_1, True) data = { 'verif_key': new_email_1_address.verif_key, 'email': new_email_1_address.pk, } response = self.client.post(url, data=data, format='json') self.assertTrue(status.is_client_error(response.status_code)) # ## # Use an invalid key # ## data_fail = { 'verif_key': faker.name(), 'email': new_email_1_address.pk, } response = self.client.post(url, data=data_fail, format='json') self.assertTrue(status.is_client_error(response.status_code))
def setUp(self): super().setUp() self.customer = FakeCustomerFactory.create() self.user1 = FakeUserFactory.create(is_active=True) self.user2 = FakeUserFactory.create(is_active=True) self.user3 = FakeUserFactory.create(is_active=True) self.role1 = FakeCustomerUserRoleFactory.create( customer=self.customer, user=self.user1, ) self.role2 = FakeCustomerUserRoleFactory.create( customer=self.customer, user=self.user2, )
def test_validate_email(self): user = FakeUserFactory.create() email_address = user.add_email_address(faker.email().upper()) url = reverse( MM.EMAIL_VERIFICATION_URL_VIEW_NAME, kwargs={ 'email_pk': email_address.pk, 'verif_key': email_address.verif_key, }, ) self.client.get(url) email_address.refresh_from_db() user = get_user(self.client) self.assertTrue(email_address.is_verified) self.assertTrue(user.is_authenticated) self.assertEqual( Message.objects.filter_by_user(user).filter( variables__pk=email_address.pk).count(), 1) self.assertEqual( Message.objects.filter_by_user(user).filter_by_code( settings.EXO_MESSAGES_CH_CODE_PENDING_EMAIL).count(), 0) self.assertEqual( Message.objects.filter_by_user(user).filter_by_code( settings.EXO_MESSAGES_CH_CODE_VALIDATED_EMAIL).count(), 1) self.assertEqual( Message.objects.filter_by_user(user).filter_by_code( settings.EXO_MESSAGES_CH_CODE_VALIDATED_EMAIL).already_read(). count(), 1)
def test_create_post_with_one_mention(self): # PREPARE DATA self.circle = Circle.objects.first() self.user.hubs.create(hub=self.circle.hub) user_mentioned = FakeUserFactory.create(is_active=True) description = '<a {}="{}" {}="{}">{}</a>'.format( DEFAULT_TYPE_PATTERN, user_mentioned.__class__.__name__, DEFAULT_UUID_PATTERN, user_mentioned.pk, user_mentioned.short_name, ) post = Post.objects.create_circle_post(user_from=self.user, circle=self.circle, title=' '.join(faker.words()), description=description) post_id = post.pk # DO ACTIONS self.post = Post.objects.get(pk=post_id) # ASSERTS self.assertTrue(self.user.actor_actions.all().filter( verb=settings.MENTION_VERB).exists()) self.assertEqual( self.user.actor_actions.all().filter( verb=settings.MENTION_VERB).count(), 1)
def test_managers_added_as_participant_removed(self): # PREPARE DATA super_user = FakeUserFactory(is_superuser=True) self.sprint.launch(super_user) project = self.sprint.project_ptr consultant = FakeConsultantFactory( status=settings.CONSULTANT_STATUS_CH_ACTIVE, ) FakeConsultantProjectRoleFactory( consultant=consultant, project=project, status=settings.RELATION_ROLE_CH_ACTIVE, exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_HEAD_COACH), ) new_team = FakeTeamFactory.create(project=project) new_team.add_member( user_from=super_user, email=consultant.user.email, name=consultant.user.short_name, ) # DO ACTION new_team.remove_member(super_user, consultant.user) # ASSERTS self.assertTrue( consultant.user.has_perm( settings.PROJECT_PERMS_VIEW_PROJECT, new_team.project, )) self.assertTrue( consultant.user.has_perm( settings.EXO_ACCOUNTS_PERMS_USER_EDIT, consultant.user, ))
def setUp(self): self.create_user() self.create_superuser() sprint = FakeSprintAutomatedFactory.create( status=settings.PROJECT_CH_PROJECT_STATUS_WAITING) new_team = FakeTeamFactory.create(project=sprint.project_ptr) new_team.add_member( user_from=self.super_user, email=self.user.email, name=self.user.short_name, ) consultant_manager_user = FakeUserFactory.create() consultant_for_manager_role = FakeConsultantFactory.create( user=consultant_manager_user, status=settings.CONSULTANT_STATUS_CH_ACTIVE, ) self.manager_role = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, project=sprint.project_ptr, consultant=consultant_for_manager_role, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_HEAD_COACH), ) self.team = new_team self.sprint = sprint self.step = sprint.project_ptr.steps.first() ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, project=self.sprint.project_ptr, consultant=FakeConsultantFactory.create( status=settings.CONSULTANT_STATUS_CH_ACTIVE), exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_HEAD_COACH), )
def test_user_agreement_can_be_accepted(self): # INPUTS status_inputs = [ settings.AGREEMENT_STATUS_INACTIVE, settings.AGREEMENT_STATUS_CANCELLED, settings.AGREEMENT_STATUS_ACTIVE, ] # OUTPUTS can_be_accepted_output = [False, False, True] for index, status in enumerate(status_inputs): # PREPARE DATA agreement = FakeAgreementFactory(status=status) user = FakeUserFactory() # ACTION user_agreement = FakeUserAgreementFactory.create( agreement=agreement, user=user, ) # ASSERTS self.assertEqual( user_agreement.can_be_accepted(), can_be_accepted_output[index], )
def prepare_data(self): self.sprint_automated = FakeSprintAutomatedFactory.create() self.team = FakeTeamFactory.create( project=self.sprint_automated.project_ptr) self.step = FakeStepFactory.create(project=self.team.project) user = FakeUserFactory.create(is_active=True) self.add_user_to_team(user, self.team)
def test_remove_user_to_team(self): new_team = FakeTeamFactory.create(project__status=settings.PROJECT_CH_PROJECT_STATUS_STARTED) user = FakeUserFactory.create(is_active=True) new_user_email = user.email new_user_name = user.short_name new_team.add_member( user_from=self.super_user, email=new_user_email, name=new_user_name, ) self.assertTrue(user.has_perm( settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team, )) self.assertTrue(user.has_perm( settings.PROJECT_PERMS_VIEW_PROJECT, new_team.project, )) user2 = new_team.get_member(new_user_email) self.assertEqual(user2, user) new_team.remove_member(self.super_user, user) user2 = new_team.get_member(new_user_email) self.assertIsNone(user2) self.assertFalse(user.has_perm( settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team, )) self.assertFalse(user.has_perm( settings.PROJECT_PERMS_VIEW_PROJECT, new_team.project, ))
def test_assignment_step_mark_task_undone(self): # PREPARE DATA new_user = FakeUserFactory.create(is_active=True) team_member = self.team.team_members.first() task_item, url = self.get_task_item_and_detail_route_url(done=False) data = {'pk_list': [task_item.pk]} new_team = FakeTeamFactory.create() self.add_user_to_team(new_user, new_team) inputs = ( (self.super_user, True, '123456'), (self.team.coach.user, True, '123456'), (team_member, True, team_member.short_name), (new_user, False, new_user.short_name), (new_team.coach.user, False, '123456'), ) # DO ACTION for user_do_action, allowed_do_action, password_login in inputs: self.client.login(username=user_do_action.username, password=password_login) response = self.client.post(url, data=data, format='json') # ASSERTS if allowed_do_action: self.assertTrue(status.is_success(response.status_code)) self.assertEqual(response.json()[0].get('status'), settings.ASSIGNMENT_TASK_TEAM_CH_STATUS_TO_DO) self.assertEqual( AssignmentTaskTeam.objects.get( assignment_step_team__team=self.team, assignment_task_item=AssignmentTaskItem.objects.first( )).status, settings.ASSIGNMENT_TASK_TEAM_CH_STATUS_TO_DO) else: self.assertTrue(status.is_client_error(response.status_code))
def create_user(self, **kwargs): user = FakeUserFactory.create(**kwargs) if user.is_superuser: for circle in Circle.objects.all(): circle.add_user(user) return user
def create_superuser(self, password=None): password = password or '123456' self.super_user = FakeUserFactory.create( is_superuser=True, is_active=True, is_staff=True, password=password, )
def test_last_answer_seen_after_visit_post(self): # PREPARE DATA user_to_reply = FakeUserFactory.create(is_active=True) self.circle.add_user(user_to_reply) user = FakeUserFactory.create(is_active=True) self.circle.add_user(user) answer = self.post.reply( user_to_reply, faker.text(), ) # DO ACTION answer.see(user) # ASSERTS self.assertEqual(self.post.answers.count(), 1) self.assertIsNotNone(self.post.last_answer_seen(user))
def test_add_email(self): user = FakeUserFactory.create() email_address = user.add_email_address(faker.email().upper()) self.assertEqual( Message.objects.filter_by_user(user).filter_by_code( settings.EXO_MESSAGES_CH_CODE_PENDING_EMAIL).count(), 1) self.assertEqual( Message.objects.filter_by_user(user).filter( variables__pk=email_address.pk).count(), 1)
def test_circle_api(self): # PREPARE DATA circle = Circle.objects.first() user1 = FakeUserFactory.create(password='******', is_active=True) user2 = FakeUserFactory.create(password='******', is_active=True) circle.add_user(user1) circle.add_user(user2) url = reverse('api:circles:followers', kwargs={'slug': circle.slug}) # DO ACTION self.client.login(username=user1.username, password='******') response = self.client.get(url) # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertEqual(len(response.data['results']), 2)
def test_get_questions_from_participants(self): # PREPARE DATA consultant = FakeConsultantFactory( user__is_active=True, user__password='******', activities=[settings.EXO_ACTIVITY_CH_ACTIVITY_CONSULTING]) team_a = FakeTeamFactory.create() team_b = FakeTeamFactory.create() participant_a = FakeUserFactory.create(password='******', is_active=True) participant_b = FakeUserFactory.create(password='******', is_active=True) self.add_user_to_team(participant_a, team_a) self.add_user_to_team(participant_b, team_b) for i in range(7): post = Post.objects.create_project_team_post( user_from=participant_a, team=team_a, title=' '.join(faker.words()), description=faker.text()) for i in range(12): Post.objects.create_project_team_post(user_from=participant_b, team=team_b, title=' '.join( faker.words()), description=faker.text()) url = reverse('api:forum:questions-participants-list') search = 'tosearch' post.title = '{} {}'.format(post.title, search) post.save() # DO ACTION self.client.login(username=consultant.user.username, password='******') response = self.client.get(url) response_search = self.client.get(url, data={'search': search}) # ASSERTS self.assertTrue(status.is_success(response.status_code)) data = response.json() self.assertEqual(data.get('count'), 19) self.assertTrue(status.is_success(response_search.status_code)) data = response_search.json() self.assertEqual(data.get('count'), 1)
def test_get_posts_from_team(self): # PREPARE DATA team_1 = FakeTeamFactory.create() team_2 = FakeTeamFactory.create() user_team_1 = self.user user_team_2 = FakeUserFactory.create(password='******', is_active=True) self.add_user_to_team(user_team_1, team_1) self.add_user_to_team(user_team_2, team_2) search = 'tosearch' post_A_team_1 = Post.objects.create_project_team_post( title='{} {}'.format(' '.join(faker.words()), search), user_from=user_team_1, team=team_1) Post.objects.create_project_team_post(title=' '.join(faker.words()), user_from=user_team_1, team=team_1) post_team_2 = Post.objects.create_project_team_post( title=' '.join(faker.words()), user_from=user_team_2, team=team_2) url_team_1 = reverse('api:forum:questions-team-list', kwargs={ 'project_pk': team_1.project.pk, 'team_pk': team_1.pk }) url_team_2 = reverse('api:forum:questions-team-list', kwargs={ 'project_pk': team_2.project.pk, 'team_pk': team_2.pk }) # DO ACTION self.client.login(username=user_team_1.username, password='******') response = self.client.get(url_team_1) response_search = self.client.get(url_team_1, data={'search': search}) # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertEqual(response.data.get('count'), 2) self.assertTrue(status.is_success(response_search.status_code)) self.assertEqual(response_search.data.get('count'), 1) self.assertEqual(post_A_team_1.pk, response_search.data.get('results')[0].get('pk')) self.assertEqual(post_A_team_1.title, response_search.data.get('results')[0].get('title')) self.assertEqual(post_A_team_1.description, response.data.get('results')[0].get('description')) # DO ACTION self.client.login(username=user_team_2.username, password='******') response = self.client.get(url_team_2) # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertEqual(response.data.get('count'), 1) self.assertEqual(post_team_2.pk, response.data.get('results')[0].get('pk'))
def test_update_contact_email_at_hubspot(self, hubspot_sync_patch): # PREPARE DATA user = FakeUserFactory.create() email_address = user.add_email_address(faker.email().upper()) # DO ACTION email_address._set_primary_flags() # ASSERTIONS self.assertTrue(hubspot_sync_patch.called)
def test_post_unseen_answers(self): # PREPARE DATA user_to_reply = FakeUserFactory.create(is_active=True) self.circle.add_user(user_to_reply) user = FakeUserFactory.create(is_active=True) self.circle.add_user(user) self.post.reply(user_to_reply, faker.text()) self.post.reply(user_to_reply, faker.text()) # PRE ASSERTS self.assertEqual(self.post.answers_unseen(user), 2) # DO ACTION for answer in self.post.answers.all(): answer.see(user) # ASSERTS self.assertEqual(self.post.answers_unseen(user), 0)
def create_user(self, password=None): """ Creates an user and add to the class context """ password = password or '123456' self.user = FakeUserFactory.create( is_superuser=False, is_active=True, password=password, )
def test_post_new_answers(self): # PREPARE DATA user_to_reply = FakeUserFactory.create(is_active=True) self.circle.add_user(user_to_reply) user = FakeUserFactory.create(is_active=True) self.circle.add_user(user) self.post.reply(user_to_reply, faker.text()) self.post.reply(user_to_reply, faker.text()) # PRE ASSERTS self.assertEqual( list(self.post.new_answers(user)), list(self.post.answers.all().values_list('pk', flat=True))) # DO ACTION self.post.see(user) # ASSERTS self.assertEqual(len(self.post.new_answers(user)), 2)
def setUp(self): self.circle = Circle.objects.first() self.user = FakeUserFactory.create(is_active=True) self.user.hubs.create(hub=self.circle.hub) post = Post.objects.create_circle_post( user_from=self.user, circle=self.circle, title=' '.join(faker.words()), description=faker.text()) post_id = post.pk self.post = Post.objects.get(pk=post_id)
def test_see_stats(self): # PREPARE DATA user = FakeUserFactory.create(is_active=True) self.circle.add_user(user) # DO ACTION self.post.see(user) # ASSERTS self.assertEqual(self.post.count_views, 2) self.assertTrue(self.post.has_seen(user))
def create_team(self): self.consultant_for_coach_role = FakeConsultantFactory.create( user=self.user, status=settings.CONSULTANT_STATUS_CH_ACTIVE, ) self.coach_role = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, project=self.project, consultant=self.consultant_for_coach_role, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) consultant_manager_user = FakeUserFactory.create(password='******', is_active=True) self.consultant_for_manager_role = FakeConsultantFactory.create( user=consultant_manager_user, status=settings.CONSULTANT_STATUS_CH_ACTIVE, ) self.manager_role = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, project=self.project, consultant=self.consultant_for_manager_role, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_HEAD_COACH), ) self.team = FakeTeamFactory.create( coach=self.consultant_for_coach_role, project=self.project, ) delivery_manager_user = FakeUserFactory.create(password='******', is_active=True) self.delivery_manager = self.project.add_user_project_delivery_manager( self.super_user, delivery_manager_user.short_name, delivery_manager_user.email, )
def test_last_answer_seen_after_several_visit_post(self): # PREPARE DATA user_to_reply = FakeUserFactory.create(is_active=True) self.circle.add_user(user_to_reply) user = FakeUserFactory.create(is_active=True) self.circle.add_user(user) answer = self.post.reply(user_to_reply, faker.text()) answer.see(user) first_user_action_post_visit = self.post.last_answer_seen(user) answer = self.post.reply(user_to_reply, faker.text()) answer.see(user) # DO ACTION self.post.see(user) # ASSERTS last_action_answer_seen = self.post.last_answer_seen(user) self.assertIsNotNone(first_user_action_post_visit) self.assertNotEqual(first_user_action_post_visit, last_action_answer_seen)
def test_validate_email_not_valid_email_pk(self): user = FakeUserFactory.create() email_address = user.add_email_address(faker.email().upper()) url = reverse( MM.EMAIL_VERIFICATION_URL_VIEW_NAME, kwargs={ 'email_pk': 999999999, 'verif_key': email_address.verif_key, }, ) response = self.client.get(url) self.assertTrue(response.status_code, 404)