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)