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)
