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 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_update_project(self):
# PREPARE DATA
self.client.login(
username=self.user.username, password='******')
url = reverse('api:project:project-detail', kwargs={'slug': self.sprint_automated.slug})
timezone_workshop = 'UTC'
place_id = 'ChIJgTwKgJcpQg0RaSKMYcHeNsQ'
# DO ACTION
data = {
'name': faker.word(),
'start': build_datetime(string_to_datetime('2018, 10, 10', custom_timezone='Europe/Madrid')),
'end': build_datetime(string_to_datetime('2018, 10, 12', custom_timezone='Europe/Madrid')),
'location': '{}, {}'.format(faker.city(), faker.country()),
'place_id': place_id,
'comment': faker.text(),
}
response = self.client.put(url, data=data)
data = response.json()
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.sprint_automated.refresh_from_db()
self.assertEqual(self.sprint_automated.name, data['name'])
self.assertEqual(self.sprint_automated.comment, data['comment'])
self.assertEqual(self.sprint_automated.location, data['location'])
self.assertEqual(self.sprint_automated.place_id, place_id)
self.assertEqual(self.sprint_automated.timezone.zone, timezone_workshop)
def test_edit_project(self, mock_request, mock_email):
# PREPARE DATA
self.project.refresh_from_db()
self.init_mock(mock_request)
coach_role = self.project.project_roles.get(
code=settings.EXO_ROLE_CODE_SPRINT_COACH)
user = self.get_user()
request_mock_account.add_mock(user,
is_consultant=False,
is_superuser=False)
models.UserProjectRole.objects.create(project_role=coach_role,
user=user)
self.project.set_status(self.project.created_by,
settings.PROJECT_CH_STATUS_WAITING)
mock_email.reset_mock()
url = reverse('api:project-detail', kwargs={'pk': self.project.pk})
# DO ACTION
self.setup_credentials(self.super_user)
data = {
'name': faker.word(),
'customer': faker.company(),
'location': '{}, {}'.format(faker.city(), faker.country()),
'place_id': faker.pyint(),
'start':
(self.project.start + timedelta(days=5)).strftime('%Y-%m-%d'),
}
response = self.client.put(url, data=data)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertTrue(mock_email.called)
self.assertEqual(mock_email.call_count, 2)
def test_create_participants_api(self, mock_request):
# PREPARE DATA
self.init_mock(mock_request)
self.setup_credentials(self.consultant_user)
data = {
'title':
faker.sentence(),
'sub_title':
faker.sentence(),
'description':
faker.text(),
'start':
timezone.now().date(),
'end':
timezone.now().date(),
'category':
settings.EXO_ROLE_CATEGORY_OTHER,
'follow_type':
'P',
'location':
'{}, {}'.format(faker.city(), faker.country()),
'url':
faker.uri(),
'languages': [faker.word()],
'show_price':
faker.boolean(),
'amount':
faker.numerify(),
'currency': [*dict(settings.EVENT_CURRENCY_CHOICES).keys()
][random.randint(0, 1)],
'organizers': [
{
'name': faker.name(),
'email': faker.email(),
'url': faker.uri()
},
],
'participants': [{
'uuid': self.consultant_user.uuid.__str__(),
'exo_role': settings.EXO_ROLE_CODE_OTHER_SPEAKER,
'order': 1,
}]
}
url = reverse('api:event:api-root')
# DO ACTION
response = self.client.post(url, data=data, format='json')
# ASSERTS
event = Event.objects.first()
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(event.participants.count(), 1)
class FakeOpportunityFactory(factory.django.DjangoModelFactory):
title = factory.LazyAttribute(lambda x: faker.text(max_nb_chars=20))
description = factory.LazyAttribute(lambda x: faker.text())
location = factory.LazyAttribute(
lambda x: '{}, {}'.format(faker.city(), faker.country()))
exo_role = factory.LazyAttribute(lambda o: ExORole.objects.get(
code=settings.EXO_ROLE_CODE_SPRINT_COACH))
certification_required = factory.LazyAttribute(
lambda o: CertificationRole.objects.get(
code=settings.EXO_ROLE_CODE_CERTIFICATION_SPRINT_COACH))
start_date = factory.fuzzy.FuzzyDate(datetime.date.today())
deadline_date = factory.fuzzy.FuzzyDate(datetime.date.today())
duration_unity = factory.fuzzy.FuzzyChoice(
dict(settings.OPPORTUNITIES_DURATION_UNITY_CHOICES).keys(), )
duration_value = faker.random_digit_not_null()
entity = factory.LazyAttribute(lambda x: faker.company())
keywords = []
languages = []
budget = factory.LazyAttribute(lambda x: faker.pyint())
budget_currency = settings.OPPORTUNITIES_CH_CURRENCY_DOLLAR
virtual_budget = factory.LazyAttribute(lambda x: faker.pyint())
virtual_budget_currency = settings.OPPORTUNITIES_CH_CURRENCY_EXOS
class Meta:
model = Opportunity
@classmethod
def _create(cls, model_class, *args, **kwargs):
"""Override the default ``_create`` with our custom call."""
manager = cls._get_manager(model_class)
if not kwargs.get('user_from'):
raise Exception('User is required')
# The default would use ``manager.create(*args, **kwargs)``
budgets = []
if kwargs.get('budget'):
budgets.append({
'budget': kwargs.get('budget'),
'currency': kwargs.get('budget_currency')
})
if kwargs.get('virtual_budget'):
budgets.append({
'budget': kwargs.get('virtual_budget').__str__(),
'currency': kwargs.get('virtual_budget_currency')
})
kwargs['budgets'] = budgets
return manager.create_opportunity(*args, **kwargs)
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 test_workshop_reminder_email(self, mock_notify_manager_task, mock_task,
mock_request):
# PREPARE DATA
self.init_mock(mock_request)
data = {
'title':
faker.sentence(),
'sub_title':
faker.sentence(),
'description':
faker.text(),
'start':
timezone.now().date(),
'end':
timezone.now().date(),
'category':
Category.objects.get(code=settings.EXO_ROLE_CATEGORY_WORKSHOP),
'follow_type':
settings.EVENT_CH_FOLLOW_MODE_DEFAULT,
'location':
'{}, {}'.format(faker.city(), faker.country()),
'url':
faker.uri(),
'languages': [faker.word()],
'show_price':
faker.boolean(),
'amount':
faker.numerify(),
'currency':
settings.EVENT_CH_CURRENCY_EUR,
'organizers': [
{
'name': faker.name(),
'email': faker.email(),
'url': faker.uri()
},
],
'participants': [],
'user_from':
self.super_user,
}
# DO ACTION
Event.objects.create_event(force_retrieve_user_data=True, **data)
# ASSERTS
self.assertTrue(mock_task.called)
def get_api_data(self, users=[]):
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=settings.EXO_ROLE_CODE_OTHER_OTHER).code,
'other_category_name': faker.word(),
'other_role_name': faker.word(),
'certification_required': None,
'due_date': timezone.now().date(),
'deadline_date': (timezone.now() + timedelta(days=10)).date(),
'duration_unity': settings.OPPORTUNITIES_DURATION_UNITY_DAY,
'duration_value': 2,
'num_positions': 2,
'keywords': keywords,
'entity': faker.company(),
'files': [{
'filestack_status': 'Stored',
'url': 'https://cdn.filestackcontent.com/Lr59QG8oQRWliC6x70cx',
'filename': 'gato.jpg',
'mimetype': 'image/jpeg'}],
'budgets': [
{
'currency': settings.OPPORTUNITIES_CH_CURRENCY_EUR,
'budget': '{}.0'.format(int(faker.numerify()))
},
{
'currency': settings.OPPORTUNITIES_CH_CURRENCY_EXOS,
'budget': '{}.0'.format(int(faker.numerify()))
},
]
}
if users:
data['target'] = settings.OPPORTUNITIES_CH_TARGET_FIXED
data['users_tagged'] = [
{'user': user.uuid.__str__()} for user in users
]
return data
class FakeProjectFactory(django.DjangoModelFactory):
class Meta:
model = Project
name = factory.LazyAttribute(lambda x: faker.word() + faker.numerify())
customer = factory.SubFactory(
'customer.faker_factories.FakeCustomerFactory')
start = factory.LazyAttribute(
lambda x: faker.date_time(tzinfo=string_to_timezone('utc')), )
duration = 3
lapse = settings.PROJECT_LAPSE_WEEK
agenda = factory.LazyAttribute(lambda x: faker.url())
created_by = factory.SubFactory(FakeUserFactory)
location = factory.LazyAttribute(
lambda x: '{}, {}'.format(faker.city(), faker.country()))
timezone = factory.LazyAttribute(lambda x: faker.timezone())
@factory.post_generation
def consultants(self, created, extracted, **kwargs):
if not created:
return None
if extracted:
for consultant in extracted:
new_consultant = FakeConsultantProjectRoleFactory(
project=self,
consultant=consultant,
)
new_consultant.save()
@factory.post_generation
def partners(self, created, extracted, **kwargs):
if not created:
return None
if extracted:
for partner in extracted:
new_partner = FakePartnerProjectRoleFactory(
project=self,
partner=partner,
)
new_partner.save()
def get_sow_data(self):
return {
'title': faker.text(),
'description': faker.text(),
'mode': settings.OPPORTUNITIES_CH_MODE_DEFAULT,
'location': faker.city(),
'start_date': datetime.date.today(),
'end_date': datetime.date.today() + datetime.timedelta(days=20),
'duration_unity': settings.OPPORTUNITIES_DURATION_UNITY_DAY,
'duration_value': 2,
'start_time': faker.time(),
'timezone': faker.timezone(),
'entity': faker.name(),
'budgets': [
{
'budget': '222',
'currency': settings.OPPORTUNITIES_CH_CURRENCY_DOLLAR
}
],
}
def test_edit_service_sprint_from_django_form(self, mock):
# PREPARE DATA
sprint = FakeSprintAutomatedFactory()
new_date = '2013-01-01 10:00:00'
sprint_form = SprintSimpleForm(instance=sprint)
data = sprint_form.initial
data['start'] = new_date
data['agenda'] = ''
data['location'] = faker.city()
data['timezone'] = faker.timezone()
data['place_id'] = faker.pyint()
url = reverse('project:project:dashboard',
kwargs={'project_id': sprint.id})
self.client.login(username=self.super_user.username, password='******')
# DO ACTION
response = self.client.post(url, data=data, format='json')
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
class FakeProjectFactory(django.DjangoModelFactory):
class Meta:
model = Project
uuid = factory.LazyAttribute(lambda x: faker.uuid4())
name = factory.LazyAttribute(lambda x: faker.word())
description = factory.LazyAttribute(lambda x: faker.text())
start = factory.LazyAttribute(
lambda x: faker.date_time(tzinfo=string_to_timezone('utc')))
location = factory.LazyAttribute(
lambda x: '{}, {}'.format(faker.city(), faker.country()))
status = settings.PROJECT_CH_STATUS_DRAFT
content_template = settings.PROJECT_CH_PROJECT_TEMPLATE_DEFAULT
customer = factory.LazyAttribute(lambda x: faker.company())
@classmethod
def _create(cls, model_class, *args, **kwargs):
"""Override the default ``_create`` with our custom call."""
manager = cls._get_manager(model_class)
if not kwargs.get('created_by'):
raise Exception('User is required')
return manager.create_project(*args, **kwargs)
