def test_filter_by_name(self):
first_name1 = faker.first_name() + faker.numerify()
last_name1 = faker.last_name() + faker.numerify()
first_name2 = faker.first_name() + faker.numerify()
last_name2 = faker.last_name() + faker.numerify()
FakeConsultantFactory.create(
user__short_name=first_name1,
user__full_name=last_name1,
)
FakeConsultantFactory.create(
user__short_name=first_name2,
user__full_name=last_name2,
)
FakeConsultantFactory.create(
user__short_name=first_name1,
user__full_name=last_name2,
)
FakeConsultantFactory.create(
user__short_name=first_name2,
user__full_name=last_name1,
)
queryset = Consultant.all_objects.all()
filter = {'name': first_name1}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 2)
filter = {'name': last_name2}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 2)
filter = {'name': first_name1 + ' ' + last_name2}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 3)
filter = {'name': first_name1 + ' ' + first_name2}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 4)
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_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_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_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 test_create_circle_post(self, post_emails_task_mock):
# PREPARE DATA
consultant = FakeConsultantFactory.create(user__is_active=True,
user__password='******')
circle = Circle.objects.first()
circle.add_user(consultant.user)
keyword = FakeKeywordFactory.create()
num_files = 4
data = {
'title':
' '.join(faker.words()),
'description':
faker.text(),
'tags': [
{
'pk': keyword.pk,
'name': keyword.name,
},
{
'name': faker.word() + faker.numerify(),
},
],
'uploaded_files':
self.get_files_example(num_files),
}
url = reverse('api:circles:circles-create',
kwargs={'slug': circle.slug})
# DO ACTION
self.client.login(username=consultant.user.username, password='******')
response = self.client.post(url, data)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(len(response.data.get('uploaded_files')), num_files)
class FakeStepFactory(django.DjangoModelFactory):
class Meta:
model = Step
project = factory.SubFactory('project.faker_factories.FakeProjectFactory')
name = factory.LazyAttribute(lambda x: faker.name() + faker.numerify())
index = factory.LazyAttribute(lambda x: random.randint(1, 20))
def test_notification_webhook_url_is_processed_by_send_mail_signal(self, mail_handler_mock):
self.create_user()
# DO ACTION
payment = Payment.objects.create(
created_by=self.user,
amount=int(faker.numerify()) * 0.01,
concept=faker.sentence(),
email=faker.email(),
full_name=faker.name(),
)
# Asserts
self.assertTrue(mail_handler_mock.called)
called_params = mail_handler_mock.call_args[1]
self.assertTrue('notify_webhook' in called_params.keys())
self.assertEqual(
called_params.get('notify_webhook'),
'{}{}'.format(
settings.DOMAIN_NAME,
reverse(
'api:email-notify',
kwargs={'hash': payment._hash_code}
)
)
)
def test_no_attached_file_for_payments_is_managed_by_email_task(self, request_mock):
self.create_user()
email_data = {
'notify_webhook': faker.uri(),
'concept': faker.sentence(),
'detail': faker.text(),
'full_name': faker.name(),
'amount': faker.numerify(),
'currency': settings.PAYMENTS_CH_EUR,
'public_url': faker.uri(),
'from_email': faker.email(),
'recipients': [faker.email()],
'attachments': [],
}
# DO ACTION
SendMailTask().s(
template=faker.word(),
params=email_data,
).apply_async()
# Asserts
self.assertTrue(request_mock.called)
params_sent = request_mock.call_args[1].get('data').fields
self.assertTrue('file' not in params_sent.keys())
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 test_filter_simple(self):
first_name = faker.first_name()
wrong_name = faker.numerify()
language_esp = Language.objects.get(name='Spanish')
language_eng = Language.objects.get(name='English')
FakeConsultantFactory.create(
user__short_name=first_name,
languages=[language_esp],
)
FakeConsultantFactory.create(
user__short_name=wrong_name,
user__full_name=wrong_name,
languages=[language_esp],
)
FakeConsultantFactory.create(
user__short_name=wrong_name,
user__full_name=wrong_name,
languages=[language_eng],
)
filter = {'name': first_name}
self.assertEqual(
Consultant.all_objects.filter_complex(*filter, **filter).count(),
1)
filter = {'language': language_esp}
self.assertEqual(
Consultant.all_objects.filter_complex(*filter, **filter).count(),
2)
def test_create_post_in_announcements_fail(self):
# PREPARE DATA
circle_slug = 'announcements'
url = reverse('api:circles:circles-create',
kwargs={'slug': circle_slug})
consultant = FakeConsultantFactory.create(user__is_active=True,
user__password='******')
keyword = FakeKeywordFactory.create()
num_files = 2
payload = {
'title':
' '.join(faker.words()),
'description':
faker.text(),
'tags': [
{
'pk': keyword.pk,
'name': keyword.name,
},
{
'name': faker.word() + faker.numerify(),
},
],
'uploaded_files':
self.get_files_example(num_files),
}
# DO ACTION
self.client.login(username=consultant.user.username, password='******')
response = self.client.post(url, data=payload)
# ASSERTS
self.assertTrue(status.is_client_error(response.status_code))
def test_filter_by_permissions(self):
language_contenttype = ContentType.objects.get_for_model(Language)
consultant_1 = FakeConsultantFactory()
consultant_2 = FakeConsultantFactory()
new_perm_1 = Permission(
name=faker.word() + faker.numerify(),
codename=faker.word() + faker.numerify(),
content_type=language_contenttype,
)
new_perm_1.save()
new_perm_2 = Permission(
name=faker.word() + faker.numerify(),
codename=faker.word() + faker.numerify(),
content_type=language_contenttype,
)
new_perm_2.save()
self.assertEqual(
Consultant.objects.filter_by_user_permissions(
[new_perm_1.codename], ).count(),
0,
)
consultant_1.user.user_permissions.add(new_perm_1)
self.assertEqual(
Consultant.objects.filter_by_user_permissions(
[new_perm_1.codename], ).count(),
1,
)
self.assertEqual(
Consultant.objects.filter_by_user_permissions(
[new_perm_1.codename, new_perm_2.codename], ).count(),
0,
)
consultant_1.user.user_permissions.add(new_perm_2)
consultant_2.user.user_permissions.add(new_perm_1)
consultant_2.user.user_permissions.add(new_perm_2)
self.assertEqual(
Consultant.objects.filter_by_user_permissions([
new_perm_1.codename,
new_perm_2.codename,
], ).count(),
2,
)
def prepare_notify_webhook(
self, status=settings.EXO_CERTIFICATION_REQUEST_STATUS_CH_APPROVED):
cipher = AESCipher(settings.PAYMENT_SECRET_KEY)
return {
'token': cipher.encrypt(faker.sentence()),
'payment_id': faker.numerify(),
'payment_status': status,
'payment_method': 'Card',
}
def test_update_post_files(self, post_emails_task_mock):
# PREPARE DATA
keyword = FakeKeywordFactory.create()
num_files = 1
files = self.get_files_example(num_files)
consultant = FakeConsultantFactory.create(user__is_active=True,
user__password='******')
circle_slug = 'consultants'
circle = Circle.objects.get(slug=circle_slug)
circle.add_user(consultant.user)
data = {
'title':
' '.join(faker.words()),
'description':
faker.text(),
'tags': [
{
'pk': keyword.pk,
'name': keyword.name,
},
{
'name': faker.word() + faker.numerify(),
},
],
'uploaded_files':
files,
}
url = reverse('api:circles:circles-create',
kwargs={'slug': circle_slug})
self.client.login(username=consultant.user.username, password='******')
# DO ACTION
response = self.client.post(url, data=data)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(len(response.data.get('uploaded_files')), num_files)
# PREPARE DATA
num_files_new = 2
new_files = self.get_files_example(num_files_new)
data_put = {
'title': data['title'],
'description': data['description'],
'tags': data['tags'],
'uploaded_files': files + new_files,
}
# DO ACTION
url = reverse('api:forum:post-detail',
kwargs={'pk': response.data.get('pk')})
response = self.client.put(url, data=data_put)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(len(response.data.get('uploaded_files')),
num_files + num_files_new)
class FakeKeywordFactory(django.DjangoModelFactory):
"""
Creates a fake keyword.
"""
class Meta:
model = Keyword
name = factory.LazyAttribute(lambda x: faker.word() + faker.numerify())
public = True
class FakeCertificationRequestFactory(django.DjangoModelFactory):
class Meta:
model = CertificationRequest
user = factory.SubFactory(FakeUserFactory)
payment_uuid = factory.LazyAttribute(lambda x: faker.uuid4())
payment_url = factory.LazyAttribute(lambda x: faker.uri())
coupon = factory.SubFactory(FakeCouponFactory)
price = factory.LazyAttribute(lambda x: faker.numerify())
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
def setUp(self, mock_email):
self.create_user()
self.payment = Payment.objects.create(
created_by=self.user,
amount=int(faker.numerify()) * 0.01,
concept=faker.sentence(),
email=faker.email(),
full_name=faker.name(),
)
self.assertTrue(mock_email.called)
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)
def test_add_tag(self):
resource = FakeResourceLinkFactory.create()
resource_id = resource.pk
self.client.login(username=self.super_user.username, password='******')
url = reverse('api:file:resource-tag-add', kwargs={'pk': resource_id})
data = {'name': faker.word() + faker.numerify()}
self.client.put(
url,
data=data,
format='json',
)
resource.refresh_from_db()
self.assertTrue(data['name'] in resource.tags.all())
def test_ask_the_ecosystem(self, post_emails_task_mock):
# PREPARE DATA
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,
)
keyword = FakeKeywordFactory.create()
num_files = 3
data = {
'title':
' '.join(faker.words()),
'description':
faker.text(),
'tags': [
{
'pk': keyword.pk,
'name': keyword.name,
},
{
'name': faker.word() + faker.numerify(),
},
],
'uploaded_files':
self.get_files_example(num_files),
}
url_params = {
'team_pk': new_team.id,
'project_pk': sprint.id,
}
url = reverse('api:forum:questions-team-list', kwargs=url_params)
self.client.login(username=self.user.username, password='******')
# DO ACTION
response = self.client.post(url, data=data)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertIsNotNone(response.data['pk'])
post = Post.objects.get(pk=response.data['pk'])
self.assertEqual(post.tags.count(), 2)
self.assertTrue(post.is_project)
self.assertTrue(post_emails_task_mock.called)
self.assertEqual(post_emails_task_mock.call_count, 1)
self.assertIsNotNone(self.get_mock_kwarg(post_emails_task_mock, 'eta'))
self.assertEqual(len(post.uploaded_files), num_files)
self.assertEqual(len(response.data.get('uploaded_files')), num_files)
def setUp(self):
super().setUp()
self.create_super_user()
request_mock_account.reset()
request_mock_account.add_mock(self.super_user,
is_consultant=False,
is_superuser=True)
self.team_uuid = uuid.uuid4().__str__()
for _ in range(3):
user = self.get_user()
request_mock_account.add_mock(
user,
is_consultant=False,
is_superuser=False,
)
self.group = FakeOpportunityGroupFactory.create(
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()))
},
],
total=3,
related_uuid=self.team_uuid)
for _ in range(3):
user = self.get_user()
request_mock_account.add_mock(
user,
is_consultant=False,
is_superuser=False,
)
self.group.managers.add(user)
self.user1 = self.group.managers.all()[0]
self.user2 = self.group.managers.all()[1]
class FakeTeamFactory(django.DjangoModelFactory):
class Meta:
model = Team
project = factory.SubFactory('project.faker_factories.FakeProjectFactory')
coach = factory.SubFactory(
'consultant.faker_factories.FakeConsultantFactory')
created_by = factory.SubFactory(
'exo_accounts.test_mixins.faker_factories.FakeUserFactory')
name = factory.LazyAttribute(lambda x: faker.word() + faker.numerify())
stream = fuzzy.FuzzyChoice([x[0]
for x in settings.PROJECT_STREAM_CH_TYPE], )
user_from = factory.SubFactory(
'exo_accounts.test_mixins.faker_factories.FakeUserFactory')
@factory.post_generation
def team_members(self, created, extracted, **kwargs):
if not created:
return None
if extracted:
members = [{
'short_name': member.short_name,
'email': member.email
} for member in extracted]
self.update_members(self.created_by, members)
@classmethod
def _create(cls, model_class, *args, **kwargs):
manager = cls._get_manager(model_class)
# The default would use ``manager.create(*args, **kwargs)``
user_from = kwargs.get('user_from')
project = kwargs.get('project')
name = kwargs.get('name')
coach = kwargs.get('coach')
stream = kwargs.get('stream')
created_by = kwargs.get('created_by')
zoom_id = kwargs.get('zoom_id', None)
return manager.create(
user_from,
project,
name,
coach,
stream=stream,
created_by=created_by,
zoom_id=zoom_id,
)
def test_no_attached_file_for_payments_is_managed_by_email_signal(self, mail_handler_mock):
self.create_user()
Payment.objects.create(
created_by=self.user,
amount=int(faker.numerify()) * 0.01,
concept=faker.sentence(),
email=faker.email(),
full_name=faker.name(),
)
# Asserts
self.assertTrue(mail_handler_mock.called)
task_called_params = mail_handler_mock.call_args[1]
self.assertTrue('attachments' in task_called_params.keys())
self.assertEqual(len(task_called_params.get('attachments')), 0)
def get_files_example(self, num=1):
files = []
for i in range(num):
file = {
'filestack_status':
'Stored',
'filename':
'{}.png'.format(faker.word()),
'mimetype':
'image/png',
'url':
'https://cdn.filestackcontent.com/{}'.format(faker.numerify()),
}
files.append(file)
return files
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)
class FakePaymentFactory(django.DjangoModelFactory):
class Meta:
model = Payment
intent_id = factory.LazyAttribute(lambda x: faker.ean())
intent_client_secret_id = factory.LazyAttribute(lambda x: faker.ean())
_type = factory.LazyAttribute(lambda x: settings.PAYMENTS_TYPE_CERTIFICATION)
status = settings.PAYMENTS_CH_PENDING
amount = factory.LazyAttribute(lambda x: faker.numerify())
concept = factory.LazyAttribute(lambda x: faker.sentence())
email = factory.LazyAttribute(lambda x: faker.email())
full_name = factory.LazyAttribute(lambda x: faker.name())
tax_id = factory.LazyAttribute(lambda x: faker.word())
address = factory.LazyAttribute(lambda x: faker.sentence())
def test_create_post_in_circle_success(self, post_emails_task_mock):
# PREPARE DATA
consultant = FakeConsultantFactory.create(user__is_active=True,
user__password='******')
circle_slug = 'consultants'
circle = Circle.objects.get(slug=circle_slug)
circle.add_user(consultant.user)
url = reverse('api:circles:circles-create',
kwargs={'slug': circle_slug})
keyword = FakeKeywordFactory.create()
num_files = 2
payload = {
'title':
' '.join(faker.words()),
'description':
faker.text(),
'tags': [
{
'pk': keyword.pk,
'name': keyword.name,
},
{
'name': faker.word() + faker.numerify(),
},
],
'uploaded_files':
self.get_files_example(num_files),
}
# DO ACTION
self.client.login(username=consultant.user.username, password='******')
response = self.client.post(url, data=payload)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
data = response.json()
self.assertIsNotNone(data.get('pk'))
post = Post.objects.get(pk=data.get('pk'))
self.assertTrue(post.is_circle)
self.assertIsNone(post.edited)
self.assertTrue(post_emails_task_mock.called)
self.assertEqual(post_emails_task_mock.call_count, 1)
self.assertIsNotNone(self.get_mock_kwarg(post_emails_task_mock, 'eta'))
self.assertEqual(len(post.uploaded_files), num_files)
self.assertEqual(len(data.get('uploadedFiles')), num_files)
def test_notification_webhook_url_is_managed_by_send_mail_task(self, request_mock):
payment_hash_code = faker.ean()
notification_url = '{}{}'.format(
settings.DOMAIN_NAME,
reverse(
'api:email-notify',
kwargs={'hash': payment_hash_code}
)
)
email_data = {
'notify_webhook': notification_url,
'concept': faker.sentence(),
'detail': faker.text(),
'full_name': faker.name(),
'amount': faker.numerify(),
'currency': settings.PAYMENTS_CH_EUR,
'public_url': faker.uri(),
'from_email': faker.email(),
'recipients': [faker.email()],
}
# DO ACTION
SendMailTask().s(
template=faker.word(),
params=email_data,
).apply_async()
# Asserts
self.assertTrue(request_mock.called)
called_url = request_mock.call_args[0][0]
called_params = json.loads(request_mock.call_args[1].get('data').fields.get('params'))
self.assertTrue(settings.EMAIL_POST_URL in called_url)
self.assertTrue('notify_webhook' in called_params.keys())
self.assertEqual(
called_params.get('notify_webhook'),
'{}{}'.format(
settings.DOMAIN_NAME,
reverse(
'api:email-notify',
kwargs={'hash': payment_hash_code}
)
)
)
