def test_search_event(self, mock_request):
# PREPARE TEST
self.init_mock(mock_request)
self.setup_credentials(self.super_user)
title_list = [
'Test title {}'.format(faker.sentence()),
'Test title {}'.format(faker.sentence()),
'Test title {}'.format(faker.sentence()),
'Faked title {}'.format(faker.sentence()),
'Faked title {}'.format(faker.sentence()),
]
for title in title_list:
event = self.create_mommy_event(
user=self.super_user,
**{
'start': timezone.now() + timedelta(days=3),
'title': title
},
)
event.publish_event(self.super_user)
self.create_mommy_participant(
event,
user=self.get_user(mock_user=True, is_consultant=True),
user_role=settings.EXO_ROLE_CODE_OTHER_SPEAKER,
)
# DO ACTION
response = self.client.get('{}?search={}'.format(
reverse('api:event:search'),
'Test',
))
# ASSERTIONS
self.assertEqual(len(response.data), 3)
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_create_request_success(self, mock_request, mock_email):
# PREPARE DATA
self.init_mock(mock_request)
token = _build_jwt(self.user)
self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + token)
data = {
'concept': faker.sentence(),
'amount': Decimal(10.2).quantize(Decimal('.01'), rounding=ROUND_DOWN),
'currency': settings.PAYMENTS_CH_USD,
'email': faker.email(),
'full_name': faker.name(),
}
secret_key = settings.PAYMENT_SECRET_KEY
dig = hmac.new(
secret_key.encode(),
msg=str(data).encode(),
digestmod=hashlib.sha256).digest()
data['token'] = base64.b64encode(dig).decode()
data['url'] = faker.uri()
url = reverse('api:do-request')
# DO ACTION
response = self.client.post(url, data=data)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertTrue(mock_email.called)
self.assertEqual(models.Payment.objects.count(), 1)
payment = models.Payment.objects.first()
self.assertEqual(
payment.url_notification, data['url'])
self.assertEqual(
payment.created_by, self.user)
def test_create(self, mock_request, mock_create):
# PREPARE TEST
self.init_mock(mock_request)
event = self.create_mommy_event(
user=self.super_user,
**{'title': 'Test title {}'.format(faker.sentence())},
)
self.create_mommy_participant(
event,
user=self.get_user(mock_user=True, is_consultant=True),
user_role=settings.EXO_ROLE_CODE_OTHER_SPEAKER,
)
# DO ACTION
event_wrapper = CertificationWorkshopWrapper(event)
create_certification_group.send(
sender=event.__class__,
**event_wrapper.get_data(event.created_by),
)
# ASSERTIONS
self.assertTrue(mock_create.called)
self.assertIsNotNone(
event_wrapper.get_data(event.created_by).get('instructor_name'))
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 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())
class FakeAgreementFactory(django.DjangoModelFactory):
class Meta:
model = Agreement
name = factory.LazyAttribute(lambda x: faker.sentence())
description = factory.LazyAttribute(lambda x: faker.sentence())
file_name = 'consultant_v3.html'
recipient = fuzzy.FuzzyChoice([x[0]
for x in settings.AGREEMENT_RECIPIENT], )
status = fuzzy.FuzzyChoice([x[0] for x in settings.AGREEMENT_STATUS], )
version = factory.LazyAttribute(
lambda x: '{}.{}.{}'.format(
faker.random_digit(),
faker.random_digit(),
faker.random_digit(),
), )
domain = settings.AGREEMENT_DOMAIN_DEFAULT
def get_payment_data(self):
return {
'amount': '2000',
'currency': settings.PAYMENTS_CH_USD,
'concept': faker.sentence(),
'detail': faker.sentence(),
'email': faker.email(),
'full_name': faker.name(),
'tax_id': faker.word(),
'address': faker.address(),
'country': faker.country(),
'country_code': 'ES',
'company_name': faker.word(),
'send_by_email': False,
'send_invoice': True,
'_type': settings.PAYMENTS_TYPE_CERTIFICATION,
'notes': faker.sentence(),
}
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 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_request_summit_creation(self, mock_request, mail_task):
# PREPARE DATA
self.init_mock(mock_request)
self.setup_credentials(self.consultant_user)
data = {'comment': faker.sentence()}
url = reverse('api:event:event-request-summit')
# DO ACTION
response = self.client.post(url, data=data, format='json')
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertTrue(mail_task.called)
def test_post_edited_serveral_times(self):
# PREPARE DATA
Post.objects.update_post(
self.post,
user_from=self.user,
title=faker.sentence(),
description=faker.text(),
tags=self.post.tags.all(),
)
time.sleep(2)
first_edit = self.post.edited
# DO ACTION
Post.objects.update_post(
self.post,
user_from=self.user,
title=faker.sentence(),
description=faker.text(),
tags=self.post.tags.all(),
)
# ASSERTS
time.sleep(2)
self.assertNotEqual(first_edit.timestamp, self.post.edited.timestamp)
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 test_post_edited(self):
# PRE ASSERTIONS
self.assertIsNone(self.post.edited)
# DO ACTION
Post.objects.update_post(
self.post,
user_from=self.user,
title=faker.sentence(),
description=faker.text(),
tags=self.post.tags.all(),
)
# ASSERTS
time.sleep(2)
self.assertIsNotNone(self.post.edited)
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}
)
)
)
def test_create_request_error(self, mock_request):
# PREPARE DATA
self.init_mock(mock_request)
token = _build_jwt(self.user)
self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + token)
data = {
'concept': faker.sentence(),
'amount': Decimal(10.2).quantize(Decimal('.01'), rounding=ROUND_DOWN),
'currency': settings.PAYMENTS_CH_USD,
'email': faker.email(),
'full_name': faker.name(),
'url': faker.uri(),
'token': 'aaaa',
}
url = reverse('api:do-request')
# DO ACTION
response = self.client.post(url, json=data)
# ASSERTS
self.assertTrue(status.is_client_error(response.status_code))
def test_create_post_circle(self, post_emails_task_mock):
# PREPARE DATA
self.circle = Circle.objects.first()
self.user.hubs.create(hub=self.circle.hub)
data = {
'title': ' '.join(faker.words()),
'description': faker.sentence(nb_words=200),
'_type': settings.FORUM_CH_CIRCLE,
'tags': [
{
'name': faker.word() + faker.numerify(),
},
]
}
url = reverse('api:circles:circles-create', kwargs={'slug': self.circle.slug})
self.client.login(username=self.user.username, password='******')
# DO ACTION
response = self.client.post(url, data=data)
# ASSERTS
self.assertTrue(status.is_client_error(response.status_code))
def test_edit_event_api(self, mock_request):
# PREPARE DATA
self.init_mock(mock_request)
event = self.create_mommy_event(user=self.consultant_user)
self.create_mommy_participant(
event,
user=self.consultant_user,
user_role=settings.EXO_ROLE_CODE_OTHER_SPEAKER,
)
self.setup_credentials(self.consultant_user)
new_title = faker.sentence()
data = {
'title': new_title,
'sub_title': event.sub_title,
'description': event.description,
'start': event.start,
'end': event.end,
'category': event.category.code,
'follow_type': event.follow_type,
'location': event.location,
'url': event.url,
'languages': event.languages,
'show_price': event.show_price,
'amount': event.amount,
'currency': event.currency,
'organizers': [],
'participants': [],
}
url = reverse('api:event:event-detail', kwargs={'uuid': event.uuid})
# DO ACTION
response = self.client.put(url, data=data, format='json')
event.refresh_from_db()
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(event.title, new_title)
