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)