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)
Example #2
0
    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,
        ))
Example #3
0
    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,
        ))
Example #4
0
    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,
        )
Example #5
0
 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)
Example #6
0
    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,
        ))
Example #7
0
    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)
Example #8
0
    def test_permissions_at_create_team_with_coach(self):
        """
            Signal signal_team_coach_updated is lunched when creating a Team
            with a coach
        """
        team = FakeTeamFactory(
            project=self.sprint.project_ptr,
            coach=self.consultant,
        )

        self.assertTrue(self.consultant.user.has_perm(
            settings.TEAM_PERMS_FULL_VIEW_TEAM,
            team,
        ))
        self.assertTrue(self.consultant.user.has_perm(
            settings.TEAM_PERMS_COACH_TEAM,
            team,
        ))