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)
