def test_permissions_when_delete_consultant_as_coach_from_team(self): """ Check permissions for a Consultor that is Collaborator and Coach and is deleted as Coach """ new_consultant = FakeConsultantFactory(status=settings.CONSULTANT_STATUS_CH_ACTIVE) ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, consultant=new_consultant, project=self.sprint.project_ptr, exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) new_team = FakeTeamFactory( project=self.sprint.project_ptr, coach=self.consultant, ) new_team.update_coach( user_from=self.super_user, coach=new_consultant, ) self.assertFalse(self.consultant.user.has_perm( settings.TEAM_PERMS_COACH_TEAM, new_team, ))
def test_coach_project_several_teams(self): # PREPARE DATA project = FakeProjectFactory.create( status=settings.PROJECT_CH_PROJECT_STATUS_STARTED, start=None) FakeTeamFactory.create(project=project) team = FakeTeamFactory.create(project=project) relation, _ = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, project=project, consultant=team.coach, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) # ASSERTS url, _ = next_project_url(project, relation.consultant.user) expected_url = settings.FRONTEND_PROJECT_STEP_PAGE.format( **{ 'project_id': project.id, 'team_id': team.pk, 'step_id': project.steps.first().pk, 'section': 'learn' }) self.assertEqual(url, expected_url)
def test_permissions_for_coach_when_team_deleted(self): """ Check permissions for coach when a Team is deleted """ coach_role, created = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, consultant=self.consultant, project=self.sprint.project_ptr, exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) new_team = FakeTeamFactory( project=self.sprint.project_ptr, coach=self.consultant, ) new_team.delete() self.assertFalse(self.consultant.user.has_perm( settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team, )) self.assertFalse(self.consultant.user.has_perm( settings.TEAM_PERMS_COACH_TEAM, new_team, ))
def test_consultant_not_delete(self): consultant_role = FakeConsultantProjectRoleFactory.create( project=self.sprint.project_ptr, consultant=self.consultant, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_COACH), status=settings.RELATION_ROLE_CH_ACTIVE, ) FakeTeamFactory.create( project=self.sprint.project_ptr, coach=self.consultant, ) url = reverse( 'api:relation:project:consultantprojectrole-detail', kwargs={ 'project_id': self.sprint.project_ptr.pk, 'pk': consultant_role.pk, }, ) self.client.login(username=self.super_user.email, password='******') # DO ACTION response = self.client.delete(url, format='json') # ASSERTS self.assertTrue(status.is_client_error(response.status_code)) self.assertEqual( ConsultantProjectRole.objects.filter_by_exo_role_code( settings.EXO_ROLE_CODE_SPRINT_COACH).filter_by_project( self.sprint.project_ptr).count(), 1)
def setUp(self): super().setUp() self.create_superuser() self.consultant = FakeConsultantFactory(status=settings.CONSULTANT_STATUS_CH_ACTIVE) self.sprint = FakeSprintAutomatedFactory(status=settings.PROJECT_CH_PROJECT_STATUS_STARTED) # Sprint Teams self.team_s_a = FakeTeamFactory.create(project=self.sprint.project_ptr) self.team_s_b = FakeTeamFactory.create(project=self.sprint.project_ptr)
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_can_not_delete(self): FakeTeamFactory.create(coach=self.consultant) self.client.login( username=self.user.email, password='******', ) url = reverse('api:consultant:delete', args=[self.consultant.pk]) response = self.client.get(url) self.assertTrue(status.is_success(response.status_code)) self.assertEqual(response.data['status'], 'not-deleted') self.assertEqual( Consultant.all_objects.filter(id=self.consultant.id).count(), 1)
def create_sprint(self): self.secondary_user = FakeUserFactory.create() self.sprint = FakeSprintAutomatedFactory.create( status=settings.PROJECT_CH_PROJECT_STATUS_WAITING) self.team_A = FakeTeamFactory.create(project=self.sprint.project_ptr) self.team_B = FakeTeamFactory.create(project=self.sprint.project_ptr) self.team_A.add_member(user_from=self.super_user, email=self.user.email, name=self.user.short_name) self.team_B.add_member(user_from=self.super_user, email=self.secondary_user.email, name=self.secondary_user.short_name)
def test_sprint_shortcuts(self): sprint = self.customer.create_sprint_automated( self.super_user, faker.first_name(), start=timezone.now(), description='', ) project = sprint.project_ptr team = FakeTeamFactory.create( project=sprint.project_ptr, user_from=self.super_user, coach__user__is_active=True, ) new_user_email = faker.email() new_user_name = faker.name() member = team.add_member( user_from=self.super_user, email=new_user_email, name=new_user_name, ) FakeTeamFactory.create( project=sprint.project_ptr, user_from=self.super_user, coach__user__is_active=True, ) project.launch(self.super_user, start_date=timezone.now()) self.assertTrue( has_project_perms(project, settings.PROJECT_PERMS_PROJECT_SURVEYS, self.super_user), ) self.assertFalse( has_project_perms(project, settings.PROJECT_PERMS_PROJECT_SURVEYS, team.coach.user), ) self.assertFalse( has_project_perms(project, settings.PROJECT_PERMS_PROJECT_SURVEYS, member), ) assign_perm( settings.PROJECT_PERMS_PROJECT_SURVEYS, member, project, ) self.assertTrue( has_project_perms(project, settings.PROJECT_PERMS_PROJECT_SURVEYS, member), ) self.assertTrue( has_team_perms(team, settings.PROJECT_PERMS_PROJECT_SURVEYS, self.super_user), )
def test_create_team(self, mock_request): # PREPARE DATA self.project.refresh_from_db() self.project.sync_launch(self.super_user) project_launch_handler(self.project.__class__, self.project) TOTAL_GROUPS = 5 # DO ACTION FakeTeamFactory.create(project=self.project, created_by=self.project.created_by) # ASSERTS self.assertEqual( OpportunityTeamGroup.objects.filter( team__project=self.project).count(), TOTAL_GROUPS)
def test_permissions_when_updating_coach_for_team(self): """ Change the Coach for this Team: - Old Coach: should not have permissions - New coach: shold have permissions """ coach_role, created = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, consultant=self.consultant, project=self.sprint.project_ptr, exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) new_team = FakeTeamFactory( project=self.sprint.project_ptr, coach=self.consultant, ) new_consultant = FakeConsultantFactory(status=settings.CONSULTANT_STATUS_CH_ACTIVE) ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, consultant=new_consultant, project=self.sprint.project_ptr, exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) new_team.update_coach( user_from=self.super_user, coach=new_consultant, ) self.assertFalse(self.consultant.user.has_perm( settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team, )) self.assertFalse(self.consultant.user.has_perm( settings.TEAM_PERMS_COACH_TEAM, new_team, )) self.assertTrue(new_consultant.user.has_perm( settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team, )) self.assertTrue(new_consultant.user.has_perm( settings.TEAM_PERMS_COACH_TEAM, new_team, ))
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_settings_room(self): """ Test settings for this ZoomRoom """ sprint = FakeSprintAutomatedFactory.create() 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=sprint.project_ptr, exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) meeting_id = faker.word() team = FakeTeamFactory( project=sprint.project_ptr, coach=Consultant.objects.last(), zoom_id=meeting_id, ) self.assertEqual(team.room.meeting_object, team) self.assertEqual(team.room.meeting_id, meeting_id) self.assertEqual( team.room.zoom_settings, team.room._zoom_settings, )
def setUp(self): self.create_superuser() self.create_user() self.sprint = FakeSprintAutomatedFactory.create( status=settings.PROJECT_CH_PROJECT_STATUS_WAITING) self.team = FakeTeamFactory.create( coach=FakeConsultantFactory.create( user=self.user, status=settings.CONSULTANT_STATUS_CH_ACTIVE, ), project=self.sprint.project_ptr, ) for k in range(3): self.team.add_member(self.super_user, email=faker.email(), name=faker.name()) self.project = self.sprint.project_ptr self.head_role = FakeConsultantProjectRoleFactory.create( project=self.project, consultant=FakeConsultantFactory(user__is_active=True), exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_HEAD_COACH), status=settings.RELATION_ROLE_CH_ACTIVE, ) self.coach_role = self.project.consultants_roles.get( consultant=self.team.coach)
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_retrieve_project_post_success(self): # PREPARE DATA post = Post.objects.create_project_team_post( title=''.join(faker.words()), user_from=self.super_user, team=FakeTeamFactory.create()) consultant = FakeConsultantFactory.create() self.certificate_consultant( email=consultant.user.email, _type='consultantrole-foundations', user_from=self.super_user, ) user = consultant.user user.set_password('123456') user.save() url = reverse('api:forum:post-slug-detail', kwargs={'slug': post.slug}) # DO ACTION self.client.login(username=user.username, password='******') response = self.client.get(url) # ASSERTS self.assertTrue(status.is_success(response.status_code))
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_superuser(self): # PREPARE DATA project = FakeProjectFactory.create( status=settings.PROJECT_CH_PROJECT_STATUS_STARTED) FakeTeamFactory.create(project=project) # ASSERTS url, _ = next_project_url(project, self.super_user) expected_url = project.get_absolute_url() self.assertEqual( url, expected_url, 'Superuser', )
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 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_zoom_settings(self): """ Check that ZoomSettings for ZoomRoom and the related object settings are the same """ sprint = FakeSprintAutomatedFactory.create() 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=sprint.project_ptr, exo_role=ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_COACH), ) team = FakeTeamFactory( project=sprint.project_ptr, coach=Consultant.objects.last(), ) self.assertEqual(team.settings, team.project.zoom_settings)
def test_update_answer_team_project(self, answer_emails_task_mock): # PREPARE DATA 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, ) post = Post.objects.create_project_team_post( user_from=self.super_user, team=new_team, title=' '.join(faker.words()), description=faker.text(), ) answer = post.reply(self.user, faker.text()) url = reverse('api:forum:answer-detail', kwargs={'pk': answer.pk}) self.client.login(username=self.user.username, password='******') # DO ACTION data = {'comment': faker.text()} response = self.client.put(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) answer.refresh_from_db() self.assertEqual(answer.comment, data['comment']) self.assertTrue(answer_emails_task_mock.called) self.assertEqual(answer_emails_task_mock.call_count, 1) self.assertIsNotNone( self.get_mock_kwarg(answer_emails_task_mock, 'eta'))
def test_validation_teams(self): sprint = FakeSprintAutomatedFactory.create( status=settings.PROJECT_CH_PROJECT_STATUS_WAITING, ) team = FakeTeamFactory.create( project=sprint.project_ptr, ) validator = TeamValidator(sprint.project_ptr) validator.validate() self.assertEqual(sprint.project_ptr.validations.count(), 1) self.assertEqual( sprint.project_ptr.validations .filter_by_status_pending().count(), 0, ) self.assertEqual( sprint.project_ptr.validations .filter_by_status_fixed().count(), 1, ) team.delete() validator.validate() self.assertEqual( sprint.project_ptr.validations .filter_by_status_pending().count(), 1, ) self.assertEqual( sprint.project_ptr.validations .filter_by_status_fixed().count(), 0, )
def test_create_supervisor(self): # PREPARE DATA project = FakeProjectFactory.create(status=settings.PROJECT_CH_PROJECT_STATUS_WAITING) project_settings = project.settings project_settings.launch['fix_password'] = '******' project_settings.save() # DO ACTION member = project.add_user_project_supervisor(self.super_user, faker.name(), faker.email()) # ASSERTS self.assertTrue(member.check_password('123456')) self.assertTrue(member.has_perm(settings.PROJECT_PERMS_VIEW_PROJECT, project)) self.assertTrue(member.has_perm(settings.PROJECT_PERMS_ONLY_VIEW_PROJECT, project)) FakeTeamFactory.create_batch(size=3, project=project, user_from=self.super_user) teams = Team.objects.filter_by_project(project).filter_by_user(project, member) self.assertEqual(teams.count(), 3)
def test_circle_feed(self): # PREPARE DATA team = FakeTeamFactory.create() participant = FakeUserFactory.create(password='******', is_active=True) self.add_user_to_team(participant, team) user = self.consultant.user user.is_staff = True user.save() questions = [] for i in range(2): questions.append( Post.objects.create_project_team_post(title=' '.join( faker.words()), user_from=participant, team=team)) announcements = [] for i in range(3): announcements.append( Post.objects.create_announcement_post( user_from=self.super_user, title=' '.join(faker.words()), description=faker.text())) posts = [] for i in range(4): posts.append( Post.objects.create_circle_post( circle=Circle.objects.get(slug='ecosystem'), user_from=self.super_user, title=' '.join(faker.words()), description=faker.text())) posts.append( Post.objects.create_circle_post( circle=Circle.objects.get(slug='trainers'), user_from=self.consultant.user, title=' '.join(faker.words()), description=faker.text())) posts[0].reply(user_from=self.consultant.user, comment=faker.text()) announcements[0].reply(user_from=self.consultant.user, comment=faker.text()) questions[0].reply(user_from=self.consultant.user, comment=faker.text()) url = reverse('api:forum:feed') # DO ACTION self.client.login(username=self.consultant.user.username, password='******') response = self.client.get(url) # ASSERTS self.assertTrue(status.is_success(response.status_code)) data = response.json() self.assertEqual(data.get('count'), 10)
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_staff_user(self): # PREPARE DATA project = FakeProjectFactory.create( status=settings.PROJECT_CH_PROJECT_STATUS_STARTED) FakeTeamFactory.create(project=project) exo_staff_user = FakeUserFactory.create(is_superuser=False, is_active=True, is_staff=True) project.add_user_project_staff(self.super_user, exo_staff_user.short_name, exo_staff_user.email) # ASSERTS url, _ = next_project_url(project, exo_staff_user) expected_url = '' self.assertEqual( url, expected_url, 'Staff', )
def create_team(self, uuid, name, project, stream, coach, created_by, zoom_id): return FakeTeamFactory(project=project.project_ptr, uuid=uuid, name=name, stream=find_tuple_values( settings.PROJECT_STREAM_CH_TYPE, stream)[0], coach=coach, created_by=created_by, user_from=created_by, zoom_id=zoom_id)
def test_get_posts_from_team_without_perms(self): # PREPARE DATA team = FakeTeamFactory.create() exception = False # DO ACTION try: Post.objects.create_project_team_post(self.user, team) except Exception: exception = True # ASSERTS self.assertTrue(exception)
def test_create_reporter(self): # PREPARE DATA project = FakeProjectFactory.create(status=settings.PROJECT_CH_PROJECT_STATUS_WAITING) FakeTeamFactory.create_batch(size=3, project=project) # DO ACTION relation, _ = ConsultantProjectRole.objects.get_or_create_consultant( user_from=self.super_user, project=project, status=settings.RELATION_ROLE_CH_ACTIVE, consultant=FakeConsultantFactory.create(user__is_active=True), exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_REPORTER) ) # ASSERTS member = relation.consultant.user self.assertTrue(member.has_perm(settings.PROJECT_PERMS_VIEW_PROJECT, project)) self.assertTrue(member.has_perm(settings.PROJECT_PERMS_ONLY_VIEW_PROJECT, project)) teams = Team.objects.filter_by_project(project).filter_by_user(project, member) self.assertEqual(teams.count(), 3)