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)
