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 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
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_payment_with_api_do_not_generate_invoice(self, mock_request, mock_email):
rate_response = {
'base': 'USD',
'rates': {'EUR': 0.9},
'date': '2019-08-06'}
mock_request.register_uri(
'GET',
'https://api.ratesapi.io/api/latest?base=USD&symbols=EUR&rtype=fpy',
json=rate_response)
self.client.credentials(HTTP_USERNAME=settings.AUTH_SECRET_KEY)
data = self.get_payment_data()
data['type_payment'] = settings.PAYMENTS_TYPE_CERTIFICATION
data['notify_webhook'] = faker.uri()
data['amount'] = '2000'
url = reverse('api:create-payment')
# DO ACTION
self.client.post(url, data=data)
# ASSERTIONS
payment = Payment.objects.first()
self.assertIsNone(payment.invoice_id)
def test_invoice_id_generated_after_payment_success(self, mock_request, mock_email):
# PREPARE DATA
rate_response = {
'base': 'USD',
'rates': {'EUR': 0.9},
'date': '2019-08-06'}
mock_request.register_uri(
'GET',
'https://api.ratesapi.io/api/latest?base=USD&symbols=EUR&rtype=fpy',
json=rate_response)
fake_url = faker.uri()
mock_request.register_uri('PUT', fake_url, json={})
data = self.get_payment_data()
data['url_notification'] = fake_url
payment = models.Payment.objects.create(**data)
payment.calculate_amount()
# DO ACTION
payment.payment_intent_success(faker.word())
# ASSERTS
self.assertIsNotNone(payment.invoice_id)
self.assertEqual(payment.status, settings.PAYMENTS_CH_PAID)
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_process_payment(self, mock_request, mock_email):
# PREPARE DATA
rate_response = {
'base': 'USD',
'rates': {'EUR': 0.9},
'date': '2019-08-06'}
mock_request.register_uri(
'GET',
'https://api.ratesapi.io/api/latest?base=USD&symbols=EUR&rtype=fpy',
json=rate_response)
fake_url = faker.uri()
mock_webhook = mock_request.register_uri('PUT', fake_url, json={})
data = self.get_payment_data()
data['url_notification'] = fake_url
payment = models.Payment.objects.create(**data)
payment.calculate_amount()
# DO ACTION
payment.status = settings.PAYMENTS_CH_PAID
payment.save(update_fields=['status'])
# ASSERTS
self.assertTrue(mock_email.called)
self.assertTrue(mock_webhook.called)
def test_api_create_payment_from_service(self, mock_request, mock_email):
# PREPARE DATA
rate_response = {
'base': 'USD',
'rates': {'EUR': 0.9},
'date': '2019-08-06'}
mock_request.register_uri(
'GET',
'https://api.ratesapi.io/api/latest?base=USD&symbols=EUR&rtype=fpy',
json=rate_response)
self.client.credentials(HTTP_USERNAME=settings.AUTH_SECRET_KEY)
data = self.get_payment_data()
data['type_payment'] = settings.PAYMENTS_TYPE_CERTIFICATION
data['notify_webhook'] = faker.uri()
data['amount'] = '2000'
url = reverse('api:create-payment')
# DO ACTION
response = self.client.post(url, data=data)
# ASSERTS
payment = models.Payment.objects.first()
self.assertTrue(status.is_success(response.status_code))
self.assertFalse(mock_email.called)
self.assertEqual(models.Payment.objects.count(), 1)
self.assertEqual(payment.amount_normalized, 200000)
self.assertIsNotNone(payment.url_notification)
self.assertEqual(payment.absolute_url, response.json()['nextUrl'])
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 generate_fake_user_data(self, user):
return {
'user': user,
'name': faker.name(),
'profile_picture': faker.image_url(),
'profile_url': faker.uri(),
'short_title': faker.word()
}
class FakeResourceLinkFactory(django.DjangoModelFactory):
class Meta:
model = Resource
name = factory.LazyAttribute(lambda x: faker.word())
created_by = factory.SubFactory(
'exo_accounts.test_mixins.faker_factories.FakeUserFactory')
link = factory.LazyAttribute(lambda x: faker.uri())
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 test_update_conversation_group(self, mock_request):
# PREPARE DATA
self.init_mock(mock_request)
generic_object = self.create_object(user=self.super_user)
groups = self.build_groups(self.super_user)
conversations = self.create_conversations(self.super_user, generic_object)
conversation = conversations[0]
group = groups.get('groups')[0]
url = reverse(
'api:conversations-update',
kwargs={
'related_uuid': generic_object.uuid,
'conversation_uuid': conversation.uuid.__str__()})
users = group.get('users')[1:]
users.append({
'user_uuid': str(uuid.uuid4()),
'name': faker.name(),
'profile_picture': faker.image_url(),
'profile_url': faker.uri(),
'short_title': faker.word()
})
data = {
'name': faker.name(),
'icon': faker.uri(),
'users': users
}
# DO ACTION
self.setup_credentials(conversation.created_by)
response = self.client.put(url, data=data)
# ASSERTS for superuser
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(conversation.users.count(), len(users))
for user in users:
self.assertTrue(
conversation.users.filter(user__uuid=user.get('user_uuid')).exists())
def test_send_webhook(self, mock_request):
# PREPARE DATA
self.payment.url_notification = faker.uri()
self.payment.save()
mock_request.register_uri('PUT',
self.payment.url_notification,
json={'status': 'OK'})
# DO ACTION
self.payment.notify_webhook()
# ASSERTS
self.assertTrue(mock_request.called)
def get_job_data(self, user):
return {
'user': user.uuid.__str__(),
'related_class': 'CO',
'related_uuid': uuid.uuid4().__str__(),
'exo_role': settings.EXO_ROLE_CODE_SPRINT_COACH,
'category': settings.EXO_ROLE_CATEGORY_EXO_SPRINT,
'start': timezone.now().isoformat(),
'end': (timezone.now() + timedelta(days=5)).isoformat(),
'title': faker.text(),
'url': faker.uri(),
'status_detail': '',
'extra_data': {}
}
class FakeResourceFactory(django.DjangoModelFactory):
class Meta:
model = Resource
status = settings.RESOURCE_CH_STATUS_DRAFT
type = settings.RESOURCE_CH_TYPE_VIDEO_VIMEO
name = factory.Sequence(lambda x: faker.word())
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())
thumbnail = factory.Sequence(lambda x: faker.uri())
duration = factory.Sequence(lambda x: faker.random_digit())
sections = [settings.RESOURCE_CH_SECTION_SPRINT_AUTOMATED]
projects = ''
extra_data = ''
class FakeJobFactory(factory.django.DjangoModelFactory):
title = factory.LazyAttribute(lambda x: faker.text(max_nb_chars=20))
exo_role = factory.Iterator(ExORole.objects.all())
start = timezone.now()
end = (timezone.now() + timedelta(days=5))
status = 'UP'
url = factory.LazyAttribute(lambda x: faker.uri())
class Meta:
model = Job
@classmethod
def _create(cls, model_class, *args, **kwargs):
if 'category' not in kwargs:
kwargs['category'] = kwargs.get('exo_role').categories.first()
return super()._create(model_class, *args, **kwargs)
def test_launch_notify_webhook_for_payment_after_stripe_success_notification(
self, notification_task_patch):
client = Client()
payment = FakePaymentFactory(url_notification=faker.uri())
url = '/api/webhooks/'
request_payload = self.construct_stripe_payload_success(payment)
# DO ACTION
client.post(
url,
data=json.dumps(request_payload),
content_type='application/json',
)
# ASSERTS
self.assertIsNotNone(payment.url_notification)
self.assertTrue(notification_task_patch.called)
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))
