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_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_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 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_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_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_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 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 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 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 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_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 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_ask_the_ecosystem(self, post_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,
)
keyword = FakeKeywordFactory.create()
num_files = 3
data = {
'title':
' '.join(faker.words()),
'description':
faker.text(),
'tags': [
{
'pk': keyword.pk,
'name': keyword.name,
},
{
'name': faker.word() + faker.numerify(),
},
],
'uploaded_files':
self.get_files_example(num_files),
}
url_params = {
'team_pk': new_team.id,
'project_pk': sprint.id,
}
url = reverse('api:forum:questions-team-list', kwargs=url_params)
self.client.login(username=self.user.username, password='******')
# DO ACTION
response = self.client.post(url, data=data)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertIsNotNone(response.data['pk'])
post = Post.objects.get(pk=response.data['pk'])
self.assertEqual(post.tags.count(), 2)
self.assertTrue(post.is_project)
self.assertTrue(post_emails_task_mock.called)
self.assertEqual(post_emails_task_mock.call_count, 1)
self.assertIsNotNone(self.get_mock_kwarg(post_emails_task_mock, 'eta'))
self.assertEqual(len(post.uploaded_files), num_files)
self.assertEqual(len(response.data.get('uploaded_files')), num_files)
def test_api_steps_wrong_team(self):
# PREPARE DATA
sprint = self.sprint
another_team = FakeTeamFactory.create(project=sprint.project_ptr)
url = reverse('api:project:step:step-list',
kwargs={
'project_id': sprint.project_ptr.pk,
'team_id': another_team.id
})
# DO ACTION
self.client.login(username=self.user.username, password='******')
response = self.client.get(url)
# ASSERTS
self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)
def test_create_team(self, mock_request):
# PREPARE DATA
self.init_mock(mock_request)
TOTAL_GROUPS = 7
initialize_groups_for_project(self.project, self.project.created_by)
# DO ACTION
team = FakeTeamFactory.create(project=self.project,
created_by=self.project.created_by)
# ASSERTS
self.assertEqual(self.project.groups.count(), TOTAL_GROUPS)
self.assertEqual(self.user_hc.communication_groups.count(),
TOTAL_GROUPS)
for team in self.project.teams.all():
self.assertIsNotNone(team.group)
def add_user_to_team(self):
team = FakeTeamFactory.create(
project=self.project,
created_by=self.project.created_by,
stream=self.project.streams.first())
user_role = UserProjectRole.objects.create_participant(
project=self.project,
teams=[team],
name=faker.name(),
email=faker.email())
user_role.activate(self.project.created_by)
user_coach = self.get_user()
UserProjectRole.objects.create(
project_role=self.coach,
user=user_coach,
teams=[team])
return user_role.user, team, user_coach
def test_assignment_step_teams_creation_after_assignments_content_is_populatated(
self):
# PREPARE DATA
sprint_automated = FakeSprintAutomatedFactory.create()
self.populate_assignments_version_2(
sprint_automated,
settings.PROJECT_CH_TEMPLATE_ASSIGNMENTS_SPRINT_BOOK)
# DO ACTION
team = FakeTeamFactory.create(project=sprint_automated.project_ptr)
# ASSERTS
assignments = AssignmentStep.objects.filter_by_project(
sprint_automated.project_ptr).filter_by_stream(team.stream)
for asignment in assignments:
self.assertTrue(
AssignmentStepTeam.objects.filter(assignment_step=asignment,
team=team).exists())
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_assignments_populator_sprint_book(self):
# PREPARE DATA
sprint_automated = FakeSprintAutomatedFactory.create()
team = FakeTeamFactory.create(project=sprint_automated.project_ptr)
sprint_book_exo_data_path = settings.ASSIGNMENT_EXO_DATA_SPRINT_BOOK_PATH
sprint_book_num_assignments = len(
os.listdir(sprint_book_exo_data_path))
# DO ACTION
self.populate_assignments_version_2(
sprint_automated.project_ptr,
settings.PROJECT_CH_TEMPLATE_ASSIGNMENTS_SPRINT_BOOK)
# ASSERTS
self.assertEqual(
AssignmentStep.objects.filter_by_project(
sprint_automated.project_ptr).count(),
sprint_book_num_assignments)
for step in sprint_automated.steps.all():
self.assertTrue(step.has_team_assignments(team))
def test_question_from_project_post_list(self):
# PREPARE DATA
consultant = FakeConsultantFactory.create(user__is_active=True,
user__password='******')
for i in range(5):
Post.objects.create_project_team_post(
title=''.join(faker.words()),
user_from=self.super_user,
team=FakeTeamFactory.create())
url = reverse('api:forum:circle-post-list',
kwargs={'circle_slug': 'participant-questions'})
# DO ACTIONS
self.client.login(username=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'), 5)
