def test_email(self): team1 = FakeTeamFactory.create(project=self.sprint.project_ptr) team2 = FakeTeamFactory.create(project=self.sprint.project_ptr) self.client.login(username=self.super_user.username, password='******') user1 = team1.add_member( user_from=self.super_user, email=faker.email(), name=faker.name(), ) team2.add_member( user_from=self.super_user, email=faker.email(), name=faker.name(), ) url = reverse('api:project:team:send-email', kwargs={'project_id': self.sprint.project_ptr.pk}) data = { 'teams[0]id': team1.pk, 'teams[1]id': team2.pk, 'subject': faker.word(), 'message': faker.word(), } response = self.client.post(url, data=data, format='multipart') self.assertTrue(status.is_success(response.status_code)) self.assertEqual(len(mail.outbox), 2) message = mail.outbox[0] self.assertEqual(message.to, [user1.email]) self.assertEqual(message.from_email, self.super_user.email)
def test_change_profile_summary(self): consultant = FakeConsultantFactory.create( user__is_active=True, user__password='******', ) self.client.login( username=consultant.user.email, password='******', ) url = reverse( 'api:profile:about-you', kwargs={'pk': consultant.user.pk}, ) data = { 'bio_me': faker.paragraph(), 'linkedin': faker.word(), 'website': faker.url(), 'twitter': faker.word(), } response = self.client.put(url, data=data, format='json') self.assertTrue(status.is_success(response.status_code)) consultant.user.refresh_from_db() user = consultant.user self.assertEqual(user.bio_me, data['bio_me']) profile = ConsultantProfileRequirement() self.assertTrue( profile.get_consultant_requirement( ConsultantProfileRequirement.KEY_SUMMARY, consultant, ), ) self.assertEqual(user.linkedin.value, data['linkedin']) self.assertEqual(user.twitter.value, data['twitter']) self.assertEqual(user.website.value, data['website'])
def test_draft_user_application_consultant_ft_with_coupon(self): # PREPARE DATA coupon = Coupon.objects.create( code=faker.word(), certification=ExOCertification.objects.get( level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2A ), max_uses=10, discount=500, ) consultant = FakeConsultantFactory.create() user = consultant.user user.set_password('123456') user.save() payload = { 'email': user.email, 'password': '******', 'level': settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2A, 'coupon': coupon.code, 'recaptcha': faker.word(), } url = reverse('api:exo-certification:applications-existing-user') # 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')) self.assertIsNotNone(data.get('contractingData'))
def test_pending_user_non_consultant_application_consultant(self, mock_request, mock_email): # PREPARE DATA mock_request.register_uri( 'POST', get_root_payments_url() + settings.EXO_CERTIFICATION_PAYMENTS_API_URL, json=get_payment_mock() ) user = FakeUserFactory.create() cert_request = CertificationRequest.objects.create( requester_email=user.email, requester_name=user.full_name, user=user, certification=ExOCertification.objects.get( level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2 ), ) payload = { 'country': 'PT', 'recaptcha': faker.word(), 'billingName': faker.name(), 'taxId': faker.word(), 'billingAddress': faker.address(), 'companyName': faker.name(), 'cohort': self.cohort_lvl_2.pk, 'application_details': self.generate_application_details_data(), } url = reverse('api:exo-certification:applications-detail', kwargs={'pk': cert_request.pk}) # DO ACTION response = self.client.put(url, data=payload) # ASSERTS self.assertTrue(status.is_success(response.status_code)) data = response.json() self.assertIsNotNone(data.get('nextUrl'))
def test_draft_user_application_consultant_with_referrer(self): # PREPARE DATA consultant = FakeConsultantFactory.create() user = consultant.user user.set_password('123456') user.save() referrer = '{}:{}'.format(faker.word(), faker.word()) payload = { 'email': user.email, 'password': '******', 'level': settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2, 'recaptcha': faker.word(), 'referrer': referrer, } url = reverse('api:exo-certification:applications-existing-user') # 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')) self.assertIsNotNone(data.get('contractingData')) certification_request = CertificationRequest.objects.get(pk=data.get('pk')) self.assertEqual(certification_request.referrer, referrer)
def test_preview_page(self, mock_request, mock_build): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.user) url = reverse('api:landing:page-preview', kwargs={'uuid': self.uuid}) self.create_page(self.user) data = { 'theme': settings.LANDING_CH_STELLAR, 'slug': faker.slug(), 'sections': [ { 'name': faker.word(), 'content': '<p>{}</p>'.format(faker.text()), }, { 'name': faker.word(), 'content': '<p>{}</p>'.format(faker.text()), }, { 'name': faker.word(), 'content': '<p>{}</p>'.format(faker.text()), }, ] } # DO ACTION response = self.client.put(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertTrue(mock_build.called) self.assertEqual('event', self.get_mock_kwarg(mock_build, 'page_type'))
def create_application(self, consultant=None, level=None): certification_level = level or settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2 cert_request = CertificationRequest.objects.create( user=consultant.user, requester_email=consultant.user.email, requester_name=consultant.user.full_name, certification=ExOCertification.objects.get( level=certification_level), ) if certification_level == settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2: cohort = self.cohort_lvl_2.pk elif certification_level == settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_3: cohort = self.cohort_lvl_3.pk payload = { 'country': 'NO', 'recaptcha': faker.word(), 'billingName': faker.name(), 'taxId': faker.word(), 'billingAddress': faker.address(), 'companyName': faker.name(), 'cohort': cohort, 'application_details': { 'reasons': ' '.join(faker.words()), 'whereMetUs': faker.word(), } } self.client.put( reverse('api:exo-certification:applications-detail', kwargs={'pk': cert_request.pk}), data=payload, )
def test_opportunity_other_category_data_api(self, mock_request): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.super_user) keywords = [ { 'name': faker.word() + faker.numerify() }, { 'name': faker.word() + faker.numerify() }, ] data = { 'title': faker.word(), 'description': faker.text(), 'mode': settings.OPPORTUNITIES_CH_MODE_ONSITE, 'exo_role': ExORole.objects.get(code=COACH).code, 'other_category_name': faker.word(), 'certification_required': OTHER_CATEGORY, 'deadline_date': (timezone.now() + timedelta(days=10)).date(), 'num_positions': 2, 'keywords': keywords, 'target': settings.OPPORTUNITIES_CH_TARGET_OPEN, 'duration_unity': settings.OPPORTUNITIES_DURATION_UNITY_DAY, 'duration_value': 2, } url = reverse('api:opportunity-preview') # DO ACTION response = self.client.post(url, data=data) # ASSERTS self.assertTrue(status.is_client_error(response.status_code))
def test_draft_guest_application_consultant_ft_with_coupon(self): # PREPARE DATA coupon = Coupon.objects.create( code=faker.word(), certification=ExOCertification.objects.get( level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2A ), max_uses=10, discount=500, ) payload = { 'fullName': faker.name(), 'email': faker.email(), 'level': settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2A, 'coupon': coupon.code, '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'), payload.get('fullName')) self.assertEqual(data.get('email'), payload.get('email')) self.assertEqual(data.get('level'), payload.get('level'))
def create_opportunity(self, user): data = { 'title': faker.word(), 'description': faker.text(), 'location': '{}, {}'.format(faker.city(), faker.country()), 'exo_role': ExoRole.objects.get(code=COACH), 'certification_required': CertificationRole.objects.get(code=CERT_COACH), 'start_date': timezone.now() + timedelta(days=10), 'duration': '1 week', 'keywords': [], 'entity': faker.company(), 'questions': [{ 'title': faker.word() }] } opportunity = Opportunity.objects.create_opportunity(user, **data) return opportunity
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_fill_survey(self): # PREPARE DATA survey = FakeSurveyFactory.create(created_by=self.user) url = reverse('api:survey-fill', kwargs={'slug': survey.slug}) data = { 'name': faker.word(), 'organization': faker.word(), 'email': faker.email(), 'industry': Industry.objects.first().pk, 'answers': [] } for question in Question.objects.all(): option = random.choice(question.options.all()) data['answers'].append({ 'question': question.pk, 'option': option.pk }) # DO ACTION response = self.client.post(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertEqual(survey.surveys_filled.count(), 1) self.assertEqual(survey.surveys_filled.first().answers.count(), Question.objects.all().count()) self.assertIsNotNone(response.json().get('total'))
def test_create_survey(self, mock_request): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.user) url = reverse('api:survey-list') data = { 'name': faker.word(), 'slug': faker.word(), 'send_results': True, 'language': settings.SURVEY_CH_SPANISH, 'show_results': True } # DO ACTION response = self.client.post(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertEqual( Survey.objects.filter(created_by=self.user, name=data['name']).count(), 1) self.assertEqual( Survey.objects.filter(created_by=self.user, name=data['name']).first().language, settings.SURVEY_CH_SPANISH)
def test_create_multiple_survey(self, mock_request): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.user) data = { 'name': faker.word(), 'slug': faker.word(), 'send_results': True, 'show_results': True } url = reverse('api:survey-list') # DO ACTION TOTAL_SURVEYS = 20 for _ in range(TOTAL_SURVEYS): data['name'] = faker.word() + ' ' + faker.numerify() data['slug'] = data['name'].replace(' ', '-') response = self.client.post(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) response = self.client.get(url) self.assertEqual(response.json()['count'], TOTAL_SURVEYS) self.assertEqual(len(response.json()['results']), 10) self.assertEqual( Survey.objects.filter(created_by=self.user).count(), TOTAL_SURVEYS)
def build_group_user(self, user): data = { 'userFrom': user.uuid, 'groups': [ {'name': 'Group1', 'users': []}, {'name': 'Group2', 'users': []}, ], 'group_type': settings.CONVERSATIONS_CH_USER, } for group in data['groups']: group['users'].append({ 'user_uuid': str(uuid.uuid4()), 'name': faker.name(), 'profile_picture': faker.image_url(), 'profile_url': faker.uri(), 'short_title': faker.word() }) group['users'].append({ 'user_uuid': str(user.uuid), 'name': faker.name(), 'profile_picture': faker.image_url(), 'profile_url': faker.uri(), 'short_title': faker.word() }) return data
def build_groups(self, user): data = { 'userFrom': user.uuid, 'groups': [ {'name': 'Group1', 'users': []}, {'name': 'Group2', 'users': []}, ], 'group_type': settings.CONVERSATIONS_CH_PROJECT, } users_duplicated = [str(uuid.uuid4())] for group in data['groups']: for _ in range(5): group['users'].append({ 'user_uuid': str(uuid.uuid4()), 'name': faker.name(), 'profile_picture': faker.image_url(), 'profile_url': faker.uri(), 'short_title': faker.word() }) for user_duplicated in users_duplicated: group['users'].append({ 'user_uuid': user_duplicated, 'name': faker.name(), 'profile_picture': faker.image_url(), 'profile_url': faker.uri(), 'short_title': faker.word() }) return data
class FakeResourceFileFactory(django.DjangoModelFactory): class Meta: model = Resource name = factory.LazyAttribute(lambda x: faker.word()) created_by = factory.SubFactory( 'exo_accounts.test_mixins.faker_factories.FakeUserFactory') extension = factory.LazyAttribute(lambda x: faker.file_extension()) mimetype = factory.LazyAttribute(lambda x: faker.mime_type()) _filename = factory.LazyAttribute(lambda x: faker.word())
def get_mock_data(self, optional=True): mock_data = { 'name': faker.word(), 'project_name': faker.word(), 'role_name': faker.word(), 'message': faker.paragraph(), 'subject': '[Subject]', 'public_url': '/{}'.format(faker.uri_path()), } return mock_data
def test_user_set_password_send_update_password_signal(self): test_cases = [{ 'data': { 'raw_password': None, 'random_password': None }, 'result': False }, { 'data': { 'raw_password': None, 'random_password': False }, 'result': False }, { 'data': { 'raw_password': None, 'random_password': True }, 'result': False }, { 'data': { 'raw_password': faker.word(), 'random_password': None }, 'result': True }, { 'data': { 'raw_password': faker.word(), 'random_password': True }, 'result': True }, { 'data': { 'raw_password': faker.word(), 'random_password': False }, 'result': True }] for test_case in test_cases: # PREPARE DATA user = FakeUserFactory.create() with patch.object(signals_define.signal_password_updated, 'send_robust') as patch_signal_password_updated: # DO ACTIONS raw_password = test_case.get('data').get('raw_password') random_password = test_case.get('data').get('random_password') user.set_password(raw_password=raw_password, random_password=random_password) # ASSERTS self.assertEqual(patch_signal_password_updated.called, test_case.get('result'))
class FakeInformationBlockFactory(django.DjangoModelFactory): class Meta: model = InformationBlock content_object = None title = factory.LazyAttribute(lambda x: faker.word()) subtitle = factory.LazyAttribute(lambda x: faker.word()) type = fuzzy.FuzzyChoice( dict(settings.ASSIGNMENT_INFORMATION_BLOCK_CH_TYPES).keys(), ) created_by = factory.SubFactory('exo_accounts.test_mixins.faker_factories.FakeUserFactory')
def test_create_request_api(self, mock_request): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.super_user) keywords = [ {'name': faker.word() + faker.numerify()}, {'name': faker.word() + faker.numerify()}, ] data = { 'title': faker.word(), 'description': faker.text(), 'mode': settings.OPPORTUNITIES_CH_MODE_ONSITE, 'location': '{}, {}'.format(faker.city(), faker.country()), 'exo_role': ExORole.objects.get(code=COACH).code, 'certification_required': CertificationRole.objects.get(code=CERT_COACH).code, 'start_date': timezone.now().date(), 'duration_unity': settings.OPPORTUNITIES_DURATION_UNITY_DAY, 'duration_value': 2, 'keywords': keywords, 'entity': faker.company(), 'budget': 222, 'budget_currency': settings.OPPORTUNITIES_CH_CURRENCY_EUR, 'virtual_budget': 222.55, 'questions': [ { 'title': faker.text(), }, { 'title': faker.text(), } ] } url = reverse('api:opportunity-list') # DO ACTION response = self.client.post(url, data=data) response_data = response.json() # ASSERTS self.assertTrue(status.is_success(response.status_code)) opportunity = models.Opportunity.objects.get( pk=response_data['pk']) self.assertEqual( opportunity.questions.count(), 2 ) self.assertTrue( models.Question.objects.filter( type_question=settings.OPPORTUNITIES_QUESTION_CH_TYPE_DEFAULT ).exists() )
def get_mock_data(self, optional=True): project_name = faker.word() team_name = faker.word() mock_data = { 'team_name': team_name, 'project_name': project_name, 'relation_name': '[relation_name]', 'user': faker.first_name(), 'is_coach': random.randint(0, 1), 'public_url': '/{}'.format(faker.uri_path()), } return mock_data
def test_opportunity_simple_data_api(self, mock_request): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.super_user) TOTAL_USERS = 3 users = [self.get_user() for _ in range(TOTAL_USERS)] for user in users: request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) keywords = [ { 'name': faker.word() + faker.numerify() }, { 'name': faker.word() + faker.numerify() }, ] data = { 'title': faker.word(), 'description': faker.text(), 'mode': settings.OPPORTUNITIES_CH_MODE_ONSITE, 'exo_role': ExORole.objects.get(code=COACH).code, 'certification_required': CertificationRole.objects.get(code=CERT_COACH).code, 'deadline_date': (timezone.now() + timedelta(days=10)).date(), 'num_positions': 2, 'keywords': keywords, 'target': settings.OPPORTUNITIES_CH_TARGET_FIXED, 'users_tagged': [{ 'user': user.uuid.__str__() } for user in users], 'duration_unity': settings.OPPORTUNITIES_DURATION_UNITY_DAY, 'duration_value': 2, } url = reverse('api:opportunity-preview') # DO ACTION response = self.client.post(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code))
def test_update_social_network(self): # PREPARE DATA user = FakeUserFactory.create() user.create_social_network(settings.EXO_ACCOUNTS_SOCIAL_SKYPE, faker.word()) skype_name = faker.word() # DO ACTIONS user.update_social_network(settings.EXO_ACCOUNTS_SOCIAL_SKYPE, skype_name) # ASSERTS self.assertTrue( skype_name in user.social_networks.values_list('value', flat=True))
class FakeZoomRoomFactory(django.DjangoModelFactory): _zoom_settings = factory.SubFactory( 'zoom_project.faker_factories.FakeZoomSettingsFactory', ) meeting_id = factory.LazyAttribute(lambda x: faker.word()) host_meeting_id = factory.LazyAttribute(lambda x: faker.word()) object_id = factory.SelfAttribute('content_object.id') content_type = factory.LazyAttribute( lambda o: ContentType.objects.get_for_model(o.content_object), ) class Meta: exclude = ['content_object'] abstract = True
class VideoFactory(factory.DictFactory): type = settings.RESOURCE_CH_TYPE_VIDEO_VIMEO status = settings.RESOURCE_PROVIDER_STATUS_AVAILABLE name = factory.Sequence(lambda x: faker.word() + str(faker.pyint())) description = factory.Sequence(lambda x: faker.text()) link = factory.Sequence( lambda x: 'https://vimeo.com/' + str(faker.pyint())) url = factory.Sequence(lambda x: faker.url()) sections = [settings.RESOURCE_CH_SECTION_SPRINT_AUTOMATED] thumbnail = factory.Sequence(lambda x: faker.url()) duration = factory.Sequence(lambda x: faker.random_digit()) modified = factory.Sequence(lambda x: faker.date_time_this_year( before_now=True, tzinfo=pytz.timezone('utc')).isoformat()) pictures = { "sizes": [{ "link": "https://i.vimeocdn.com/video/686815740_100x75.jpg?r=pad", }, { "link": "https://i.vimeocdn.com/video/686815740_200x150.jpg?r=pad", }, { "link": "https://i.vimeocdn.com/video/686815740_295x166.jpg?r=pad", }] }
def create_opportunity( self, user=None, questions=3, num_positions=3, target=None, duration_unity=None, role=None, group=None, ): if not user: user = self.super_user data = { 'user_from': user, 'num_positions': num_positions, } if target: data['target'] = target if duration_unity: data['duration_unity'] = duration_unity if role: data['exo_role'] = role if group: data['group'] = group opportunity = FakeOpportunityFactory.create(**data) languages = [ Language.objects.create(name=faker.word() + faker.numerify()) for _ in range(2)] opportunity.languages.add(*languages) FakeQuestionFactory.create_batch(size=questions, opportunity=opportunity) return opportunity
def get_data(self): return { 'name': faker.word(), 'index': faker.pyint(), 'start': timezone.now().strftime('%Y-%m-%d'), 'end': (timedelta(days=2) + timezone.now()).strftime('%Y-%m-%d'), }
def get_mock_data(self, optional=True): mock_data = { 'name': faker.first_name(), 'email': faker.email(), 'step_name': faker.word(), } return mock_data
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)