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} ) ) )