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_draft_user_as_guest_application_consultant(self):
# PREPARE DATA
consultant_1 = FakeConsultantFactory.create()
FakeCertificationRequestFactory.create(
status=settings.EXO_CERTIFICATION_REQUEST_STATUS_CH_APPROVED,
user=consultant_1.user,
)
consultant = FakeConsultantFactory.create()
user = consultant.user
user.set_password('123456')
user.save()
payload = {
'email': user.email,
'fullName': user.full_name,
'level': settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2,
'recaptcha': faker.word(),
}
url = reverse('api:exo-certification:applications-list')
# DO ACTION
response = self.client.post(url, data=payload)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
data = response.json()
self.assertIsNotNone(data.get('pk'))
self.assertEqual(data.get('fullName'), user.full_name)
self.assertEqual(data.get('email'), user.email)
self.assertEqual(data.get('level'), payload.get('level'))
def test_coach_and_head_coach(self):
# PREPARE DATA
sprint = FakeSprintAutomatedFactory.create(
category=settings.PROJECT_CH_CATEGORY_TRANSFORMATION,
created_by=self.super_user)
consultant_manager = FakeConsultantFactory.create(
user__is_active=True, )
consultant_coaches = FakeConsultantFactory.create_batch(
size=3,
user__is_active=True,
)
ConsultantProjectRole.objects.get_or_create_consultant(
user_from=self.super_user,
consultant=consultant_manager,
project=sprint.project_ptr,
exo_role=ExORole.objects.get(
code=settings.EXO_ROLE_CODE_SPRINT_HEAD_COACH))
for coach in consultant_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))
self.assertEqual(self.hub.users.count(), 0, 'No users yet')
# DO ACTION
add_coaches_and_head_coach_as_alumni()
# ASSERTS
self.assertEqual(self.hub.users.count(), 4,
'No coaches/head coach added yet')
def setUp(self):
self.create_superuser()
self.consultant_1 = FakeConsultantFactory.create(
user__is_active=True,
activities=[
settings.EXO_ACTIVITY_CH_ACTIVITY_CONSULTING,
settings.EXO_ACTIVITY_CH_ACTIVITY_COACHING,
])
self.consultant_1.user.set_password('123456')
self.consultant_1.user.save()
self.certificate_consultant(
email=self.consultant_1.user.email,
_type='consultantrole-foundations',
user_from=self.super_user,
)
for c in ['ecosystem', 'ambassadors', 'trainers']:
circle = Circle.objects.get(slug=c)
circle.add_user(self.consultant_1.user)
self.consultant_2 = FakeConsultantFactory.create(
user__is_active=True,
activities=[settings.EXO_ACTIVITY_CH_ACTIVITY_CONSULTING])
self.consultant_2.user.set_password('123456')
self.consultant_2.user.save()
def initialize_consultants(self):
self.crete_certification_groups()
consultants = [(4, 'Sevilla,CONSULTANT Spain', [CONSULTANT, COACH]),
(2, 'London, United Kingdom', [CONSULTANT]),
(6, 'Barcelona, Spain', [CONSULTANT]),
(18, 'Rostock, Germany', [CONSULTANT, COACH]),
(7, 'Berlin, Germany', [CONSULTANT, COACH]),
(14, 'Tokyo, Japan', [CONSULTANT]),
(8, 'Buenos Aires, Argentina', []),
(3, 'Munich, Germany', [CONSULTANT])]
for num_project, location, certified_roles in consultants:
user = FakeUserFactory.create(password='******',
is_active=True,
location=location)
consultant = FakeConsultantFactory(
user=user, status=settings.CONSULTANT_STATUS_CH_ACTIVE)
self.add_certifications_to_consultant(consultant, certified_roles)
member = consultant.user.ecosystem_member
member.num_projects = num_project
member.save()
self.user = user
FakeConsultantFactory.create_batch(
size=4,
user__location='Jaen, Spain',
status=settings.CONSULTANT_STATUS_CH_DISABLED)
FakeConsultantFactory.create_batch(
size=16,
user__location='Granada, Spain',
status=settings.CONSULTANT_STATUS_CH_ACTIVE)
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()
FakeConsultantFactory.create(
user=self.user,
)
self.sprint_automated = FakeSprintAutomatedFactory.create(
status=settings.PROJECT_CH_PROJECT_STATUS_DRAFT,
start=decrease_date(days=1),
created_by=self.user)
def test_user_title(self):
# PREPARE DATA
role_foundations = CertificationRole.objects.get(
code=settings.EXO_ROLE_CODE_CERTIFICATION_FOUNDATIONS)
role_consultant = CertificationRole.objects.get(
code=settings.EXO_ROLE_CODE_CERTIFICATION_CONSULTANT)
role_coach = CertificationRole.objects.get(
code=settings.EXO_ROLE_CODE_CERTIFICATION_SPRINT_COACH)
regular_user = FakeUserFactory(is_active=True)
consultant1 = FakeConsultantFactory.create(user__is_active=True)
consultant2 = FakeConsultantFactory.create(user__is_active=True)
organization = FakeInternalOrganizationFactory()
position = ' '.join(faker.words())
# DO ACTION
organization.users_roles.create(
user=consultant1.user,
position=position,
status=settings.RELATION_ROLE_CH_ACTIVE)
ConsultantRole.objects.create(
consultant=consultant1,
certification_role=role_foundations,
)
ConsultantRole.objects.create(
consultant=consultant1,
certification_role=role_consultant,
)
ConsultantRole.objects.create(
consultant=consultant1,
certification_role=role_coach,
)
ConsultantRole.objects.create(
consultant=consultant2,
certification_role=role_foundations,
)
consultant1.refresh_from_db()
consultant2.refresh_from_db()
# ASSERTS
self.assertIsNone(regular_user.user_title)
self.assertTrue(organization.name in consultant1.user.user_title)
self.assertTrue(position in consultant1.user.user_title)
self.assertTrue(role_foundations.name in consultant1.user.user_title)
self.assertTrue(role_consultant.name in consultant1.user.user_title)
self.assertTrue(role_coach.name in consultant1.user.user_title)
self.assertTrue(role_foundations.name in consultant2.user.user_title)
def test_actives_filter(self):
project = FakeProjectFactory()
consultant_1 = FakeConsultantFactory(user__is_active=True)
consultant_2 = FakeConsultantFactory(user__is_active=True)
self.assertTrue(consultant_1.user.is_active)
self.assertTrue(consultant_2.user.is_active)
# Create another project to check filter
relation_p_1 = FakeConsultantProjectRoleFactory(
consultant=consultant_1,
project=project,
status=settings.RELATION_ROLE_CH_ACTIVE,
)
self.assertIsNotNone(relation_p_1)
relation_p_2 = FakeConsultantProjectRoleFactory(
consultant=consultant_2,
project=project,
status=settings.RELATION_ROLE_CH_INACTIVE,
)
self.assertIsNotNone(relation_p_2)
# ##
# Work with self.project
# ##
relation_1 = FakeConsultantProjectRoleFactory(
consultant=consultant_1,
project=self.project,
status=settings.RELATION_ROLE_CH_ACTIVE,
)
self.assertIsNotNone(relation_1)
relation_2 = FakeConsultantProjectRoleFactory(
consultant=consultant_2,
project=self.project,
status=settings.RELATION_ROLE_CH_INACTIVE,
)
self.assertIsNotNone(relation_2)
self.assertEqual(self.project.consultants_roles.actives().count(), 1)
self.assertEqual(ConsultantProjectRole.objects.actives().count(), 2)
relation_2.activate(consultant_2.user)
self.assertEqual(self.project.consultants_roles.count(), 2)
self.assertEqual(self.project.consultants_roles.actives().count(), 2)
self.assertEqual(ConsultantProjectRole.objects.actives().count(), 3)
self.assertEqual(ConsultantProjectRole.objects.count(), 4)
def test_coach_consultant_change(self):
sprint = FakeSprintAutomatedFactory(status=settings.PROJECT_CH_PROJECT_STATUS_STARTED)
consultant = FakeConsultantFactory(user__is_active=True)
consultant2 = FakeConsultantFactory(user__is_active=True)
ConsultantProjectRole.objects.get_or_create_consultant(
user_from=self.super_user,
consultant=consultant2,
project=sprint.project_ptr,
exo_role=ExORole.objects.get(code=settings.EXO_ROLE_CODE_SPRINT_COACH),
)
new_team = Team.objects.create(
project=sprint.project_ptr,
user_from=self.super_user,
created_by=self.super_user,
name=faker.name(),
coach=consultant,
stream=settings.PROJECT_STREAM_CH_STRATEGY,
)
member = consultant.user
self.assertTrue(member.has_perm(
settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team,
))
self.assertTrue(member.has_perm(
settings.TEAM_PERMS_COACH_TEAM, new_team,
))
new_team.update_coach(
self.super_user,
consultant2,
)
member2 = consultant2.user
self.assertFalse(member.has_perm(
settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team,
))
self.assertFalse(member.has_perm(
settings.TEAM_PERMS_COACH_TEAM, new_team,
))
self.assertTrue(member2.has_perm(
settings.TEAM_PERMS_FULL_VIEW_TEAM, new_team,
))
self.assertTrue(member2.has_perm(
settings.TEAM_PERMS_COACH_TEAM, new_team,
))
self.assertTrue(member.has_perm(
settings.PROJECT_PERMS_VIEW_PROJECT, new_team.project,
))
def setUp(self):
self.create_superuser()
self.create_user()
self.consultant = FakeConsultantFactory.create(
user=self.user,
status=settings.CONSULTANT_STATUS_CH_ACTIVE)
self.client.login(username=self.super_user.username, password='******')
def test_cohorts_level_3_with_coupon(self):
# PREPARE DATA
certification = ExOCertification.objects.get(
level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_3)
coupon = Coupon.objects.create(
code=faker.word(),
certification=certification,
max_uses=10,
uses=0,
discount=500,
)
consultant = FakeConsultantFactory.create()
user = consultant.user
user.set_password('123456')
user.save()
url = reverse('api:exo-certification:cohorts')
# DO ACTION
self.client.login(username=user.username, password='******')
response = self.client.get(url,
data={
'level': 'L3',
'coupon': coupon.code
})
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
data = response.json()
self.assertEquals(len(data), 4)
self.assertEquals(data[0].get('price'), 2500)
self.assertEquals(data[0].get('finalPrice'), 2000)
self.assertEquals(data[0].get('discount'), 500)
def test_registration_step(self):
# ##
# Test for regular Invitation
###
role = FakeCustomerUserRoleFactory.create(user__is_active=True)
user_to = role.user
invitation = Invitation.objects.create_role_invitation(
self.super_user,
user_to,
role,
)
self.assertIsNone(invitation.registration_step)
# ##
# Test for Registration invitation
# ##
consultant = FakeConsultantFactory.create()
process = RegistrationProcess._create_process(
self.super_user,
consultant.user,
)
step = process.current_step
invitation = step.invitation
self.assertEqual(
invitation.registration_step,
step,
)
self.assertEqual(
invitation.registration_step.content_object,
step.content_object,
)
def setUp(self):
self.consultant = FakeConsultantFactory()
self.agreement = FakeAgreementFactory(
status=settings.AGREEMENT_STATUS_ACTIVE,
recipient=settings.AGREEMENT_RECIPIENT_CONSULTANT,
domain=settings.AGREEMENT_DOMAIN_CH_TOS,
)
def test_create_team_invitations_with_members(self):
member_list = [{
'email': faker.email(),
'short_name': faker.name()
} for _ in range(2)]
sprint = FakeSprintAutomatedFactory(
status=settings.PROJECT_CH_PROJECT_STATUS_WAITING)
project = sprint.project_ptr
coach = FakeConsultantFactory(user__is_active=True)
ConsultantProjectRole.objects.get_or_create_consultant(
user_from=self.super_user,
consultant=coach,
project=project,
exo_role=ExORole.objects.get(
code=settings.EXO_ROLE_CODE_SPRINT_COACH),
)
team = Team.objects.create(
user_from=self.super_user,
created_by=self.super_user,
project=project,
name=faker.name(),
coach=coach,
stream=settings.PROJECT_STREAM_CH_STARTUP,
team_members=member_list,
)
self.assertIsNotNone(team)
self.assertEqual(
Invitation.objects.filter(
type=settings.INVITATION_TYPE_TEAM).count(),
3,
)
def test_edit_contracting_data(self):
# PREPARE DATA
consultant = FakeConsultantFactory.create(
status=settings.CONSULTANT_STATUS_CH_ACTIVE)
contracting_data = ContractingData.objects.create(
profile=consultant.exo_profile,
name=faker.name(),
address=faker.address(),
company_name=faker.company(),
)
url = reverse(
'api:accounts:user-contracting-data',
kwargs={'uuid': consultant.user.uuid.__str__()})
new_data = {
'name': faker.name(),
'address': faker.address(),
'company_name': faker.company(),
'tax_id': '2522',
}
# DO ACTION
response = self.client.put(
url,
format='json',
data=new_data, HTTP_USERNAME=settings.AUTH_SECRET_KEY)
# ASSERTS
contracting_data.refresh_from_db()
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(contracting_data.name, new_data['name'])
def test_change_profile_summary_optional(self):
# PREPARE DATA
consultant = FakeConsultantFactory.create(
user__is_active=True,
user__password='******',
)
self.client.login(
username=consultant.user.email,
password='******',
)
url = reverse(
'api:profile:change-profile-summary',
kwargs={'pk': consultant.user.pk},
)
user = consultant.user
user.about_me = ','.join(faker.paragraphs())
user.bio_me = faker.paragraph()
user.save()
data = {
'about_me': '',
'bio_me': '',
}
# DO ACTION
response = self.client.put(url, data=data, format='json')
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
user.refresh_from_db()
self.assertEqual(user.bio_me, '')
self.assertEqual(user.about_me, '')
def test_ecosystem_filters(self):
# PREPARE DATA
consultant = FakeConsultantFactory(user=self.user)
url = reverse('api:ecosystem:filters')
outputs = [
filters.get_industries_filter_data(),
filters.get_attributes_filter_data(),
filters.get_roles_filter_data(),
filters.get_activities_filter_data(),
filters.get_technologies_filter_data(),
filters.get_languages_filter_data(),
filters.get_location_filter_data(),
filters.get_certifications_filter_data(),
]
# DO ACTION
self.client.login(username=consultant.user.username, password='******')
response = self.client.get(url)
# ASSERTS
index = 0
self.assertTrue(status.is_success(response.status_code))
for data in response.json():
self.assertEqual(data.get('title'), outputs[index].get('title'))
self.assertEqual(data.get('queryparam'),
outputs[index].get('queryparam'))
self.assertEqual(data.get('multiselect'),
outputs[index].get('multiselect'))
self.assertEqual(len(data.get('items')),
len(outputs[index].get('items')))
index += 1
def test_filter_queryset_by_content_object(self):
# DO ACTION
consultant = FakeConsultantFactory.create()
RegistrationProcess._create_process(
self.super_user,
consultant.user,
process_template=self.template,
)
process = RegistrationProcess._create_process(
self.super_user,
self.consultant.user,
)
step = process.steps.first()
validation = step.content_object
object_id = validation.id
content_type_id = ContentType.objects.get_for_model(validation).id
p1 = RegistrationProcess.objects.filter_by_content_object_pending(
object_id,
content_type_id,
)
self.assertEqual(p1.count(), 1)
process.execute_step(self.consultant.user, step.code)
p1 = RegistrationProcess.objects.filter_by_content_object_pending(
object_id,
content_type_id,
)
self.assertEqual(p1.count(), 0)
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_not_create_achievement_reward(self):
consultant = FakeConsultantFactory.create()
Achievement.objects.create_reward_for_consultant(
consultant=consultant, )
user_reward = UserReward.objects.filter(user=consultant.user).first()
self.assertIsNone(user_reward)
def setUp(self):
self.create_superuser()
group = Group.objects.get(name=settings.REGISTRATION_GROUP_NAME)
group.user_set.add(self.super_user)
self.template = RegistrationProcessTemplate.objects.filter(
version=2).last()
self.consultant = FakeConsultantFactory.create()
def test_cancel_step(self):
# DO ACTION
consultant = FakeConsultantFactory.create()
process = RegistrationProcess._create_process(
self.super_user,
consultant.user,
process_template=self.template,
)
# ASSERTS
invitation = process.current_step.invitation
self.assertTrue(invitation.can_be_accepted(consultant.user))
self.assertTrue(invitation.can_be_accepted(self.super_user))
invitation.cancel(consultant.user)
self.assertIsNotNone(process.current_step)
self.assertEqual(process.steps.first().code, process.current_step.code)
current_step = process.steps.first()
invitation = current_step.invitation
self.assertTrue(current_step.is_current)
self.assertTrue(current_step.invitation.is_pending)
self.assertTrue(invitation.can_be_accepted(consultant.user))
self.assertTrue(invitation.can_be_accepted(self.super_user))
def test_get_next_step_public_url(self):
# DO ACTION
consultant = FakeConsultantFactory.create()
process = RegistrationProcess._create_process(
self.super_user,
consultant.user,
process_template=self.template,
)
# ASSERTS
first_step_url = process.get_next_step_public_url()
self.assertEqual(
process.get_next_step_public_url(),
process.steps.first().public_url,
)
invitation = process.current_step.invitation
invitation.accept(consultant.user)
self.assertNotEqual(
first_step_url,
process.get_next_step_public_url(),
)
self.assertEqual(
process.get_next_step_public_url(),
process.steps.all()[1].public_url,
)
def test_unlock_achievement_reward(self):
consultant = FakeConsultantFactory.create()
user_achievement = Achievement.objects.create_reward_for_consultant(
consultant=consultant,
number_of_coins=10,
)
user_reward = UserReward.objects.filter(user=consultant.user).first()
user = consultant.user
user.profile_picture_origin = settings.EXO_ACCOUNTS_PROFILE_PICTURE_CH_USER
user.location = faker.city() + ', ' + faker.country()
user.about_me = faker.paragraph()
user.save()
user_achievement.refresh_from_db()
user_reward.refresh_from_db()
self.assertTrue(user_achievement.is_pending)
self.assertTrue(user_reward.is_pending)
for language in Language.objects.all():
consultant.languages.add(language)
for consultant_exo_attribute in ConsultantExOAttribute.objects.filter(
consultant=consultant):
consultant_exo_attribute.level = 3
consultant_exo_attribute.save()
for industry in Industry.objects.all()[:5]:
consultant.industries.create(
industry=industry,
level=3,
)
user_achievement.refresh_from_db()
user_reward.refresh_from_db()
self.assertTrue(user_achievement.is_completed)
self.assertTrue(user_reward.is_completed)
def test_api_create_no_members(self, task_handler):
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=self.sprint.project_ptr,
exo_role=ExORole.objects.get(
code=settings.EXO_ROLE_CODE_SPRINT_COACH),
)
self.client.login(username=self.super_user.username, password='******')
url = reverse('api:project:team:create',
kwargs={'project_id': self.sprint.project_ptr.pk})
data = {
'name': faker.first_name(),
'stream': 'S',
'zoom_id': faker.word(),
'coach': coaches[0].pk,
'team_members': [],
}
response = self.client.post(url, data=data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(
Team.objects.filter(project=self.sprint.project_ptr).count(), 1)
def test_answer_like_unlike_success(self):
# PREPARE DATA
consultant = FakeConsultantFactory.create(
user__is_active=True,
user__password='******')
self.circle.add_user(consultant.user)
answer = self.post.reply(consultant.user, faker.text())
url = reverse('api:forum:answer-like', kwargs={'pk': answer.pk})
url_unlike = reverse('api:forum:answer-unlike', kwargs={'pk': answer.pk})
# DO ACTION
self.client.login(username=self.user.username, password='******')
self.client.put(url)
response_self_like = self.client.put(url)
self.client.login(username=consultant.user.username, password='******')
response_other_like = self.client.put(url)
self.client.put(url_unlike)
response_unlike = self.client.put(url_unlike)
# ASSERTS
self.assertTrue(status.is_success(response_self_like.status_code))
data = response_self_like.json()
self.assertTrue(data.get('liked'))
self.assertEqual(data.get('numLikes'), 1)
self.assertTrue(status.is_success(response_other_like.status_code))
data = response_other_like.json()
self.assertTrue(data.get('liked'))
self.assertEqual(data.get('numLikes'), 2)
self.assertTrue(status.is_success(response_unlike.status_code))
data = response_unlike.json()
self.assertFalse(data.get('liked'))
self.assertEqual(data.get('numLikes'), 1)
def create_team_api(self):
coaches = FakeConsultantFactory.create_batch(
size=4,
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=self.sprint.project_ptr,
exo_role=ExORole.objects.get(
code=settings.EXO_ROLE_CODE_SPRINT_COACH),
)
self.client.login(username=self.super_user.username, password='******')
url = reverse('api:project:team:create',
kwargs={'project_id': self.sprint.project_ptr.pk})
members = []
for k in range(5):
name = faker.word()
email = faker.email()
members.append({'short_name': name, 'email': email})
data = {
'name': faker.first_name(),
'stream': 'S',
'zoom_id': faker.word(),
'coach': coaches[0].pk,
'team_members': members,
}
response = self.client.post(url, data=data, format='json')
return response, coaches
def test_accept_new_agreement_user(self):
# PREPARE DATA
consultant = FakeConsultantFactory.create(user=self.user)
previous_agreement = FakeAgreementFactory(
status=settings.AGREEMENT_STATUS_ACTIVE, )
user_agreement = UserAgreement.objects.create(
agreement=previous_agreement,
user=consultant.user,
)
invitation = Invitation.objects.create_user_agreement(
self.super_user,
consultant.user,
user_agreement,
)
url = reverse(
'api:invitation:invitation-accept',
kwargs={'hash': invitation.hash},
)
# DO ACTION
self.client.login(
username=consultant.user.email,
password='******',
)
data = {}
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
invitation.refresh_from_db()
self.assertTrue(invitation.is_active)
url, zone = UserRedirectController.redirect_url(consultant.user)
self.assertEqual(url, settings.FRONTEND_CIRCLES_PAGE)
self.assertFalse(zone)
def test_change_contracting(self):
consultant = FakeConsultantFactory.create()
ContractingData.objects.create(
profile=consultant.exo_profile,
name=faker.name(),
address=faker.address(),
company_name=faker.company(),
)
self.client.login(
username=self.super_user.username,
password='******',
)
url = reverse(
'api:profile:change-contracting',
kwargs={'pk': consultant.user.pk},
)
data = {
'name': faker.name(),
'address': faker.address(),
'company_name': faker.company(),
}
response = self.client.put(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
self.assertTrue(
consultant.exo_profile.contracting_data.name,
data['name'],
)
self.assertEqual(ContractingData.objects.count(), 1)
