def test_remove_opportunity_tagged(self, mock_request): # PREPARE DATA self.init_mock(mock_request) TOTAL_USERS = 3 opp = self.create_opportunity( target=settings.OPPORTUNITIES_CH_TARGET_FIXED) 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) opp.users_tagged.create(user=user) models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) self.setup_credentials(self.super_user) url = reverse('api:opportunity-detail', kwargs={'pk': opp.pk}) data = {'comment': faker.text()} # DO ACTION response = self.client.delete( url, data=data, **{'QUERY_STRING': 'published_by_you=True'}) # ASSERTS opp.refresh_from_db() self.assertTrue(status.is_success(response.status_code)) self.assertTrue(opp.is_removed)
def handle(self, *args, **options): self.stdout.write('\n Creating Questions/Answers for testing: \n\n') consultants = Consultant.objects.all() exo_consulting = ExOActivity.objects.get(code=settings.EXO_ACTIVITY_CH_ACTIVITY_CONSULTING) for project in Project.objects.filter(teams__isnull=False): users = User.objects.filter(teams__project=project) if not users: continue self.stdout.write('\n Creating questions for %s' % str(project)) for i in range(random.randint(2, 10)): user = random.choices(users, k=1)[0] try: post = Post.objects.create_project_team_post( user_from=user, team=user.teams.filter(project=project).first(), title=' '.join(faker.words()), description=faker.text(), tags=random.choices( Keyword.objects.all(), k=random.randint(2, 6)), ) except Exception: continue for consultant in set(random.choices(consultants, k=random.randint(2, 10))): exo_activity, _ = consultant.exo_profile.exo_activities.get_or_create( exo_activity=exo_consulting) exo_activity.enable() post.see(consultant.user) for consultant in set(random.choices(consultants, k=random.randint(2, 10))): exo_activity, _ = consultant.exo_profile.exo_activities.get_or_create( exo_activity=exo_consulting) exo_activity.enable() post.see(consultant.user) post.reply(consultant.user, faker.text()) self.stdout.write('\n Finish!! \n\n')
def test_update_circle(self): # PREPARE DATA user_from = self.consultant_1.user circle = Circle.objects.create( name=faker.word(), description=faker.text(), created_by=user_from, ) url = reverse('api:circles:circles-detail', kwargs={'slug': circle.slug}) num_tags = 4 data = { 'name': '{} EDITED'.format(circle.name), 'description': faker.text(), 'tags': self.get_tags_example(num_tags), } # DO ACTION self.client.login(username=user_from.username, password='******') response = self.client.put(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) data = response.json() self.assertExpectedKeys(data) self.assertTrue('image' in data.keys()) self.assertTrue('description' in data.keys()) self.assertTrue('EDITED' in data.get('name'))
def test_email_when_remove_opportunity_with_several_applicants( self, mock_request, mock_email): # PREPARE DATA self.init_mock(mock_request) applicant_user = self.get_user() request_mock_account.add_mock(applicant_user, is_consultant=True, is_superuser=False) extra_applicant_user = self.get_user() request_mock_account.add_mock(extra_applicant_user, is_consultant=True, is_superuser=False) opp = self.create_opportunity() models.Applicant.objects.create_open_applicant( user_from=applicant_user, user=applicant_user, opportunity=opp, summary=faker.text()) models.Applicant.objects.create_open_applicant( user_from=extra_applicant_user, user=extra_applicant_user, opportunity=opp, summary=faker.text()) comment = faker.text() # DO ACTION task = OpportunityRemovedTask().s(pk=opp.pk, comment=comment).apply() # ASSERTS self.assertEqual(task.status, 'SUCCESS') self.assertTrue(mock_email.called) self.assertEqual(mock_email.call_count, 2)
def test_get_post_answer_seen(self): # PREPARE DATA self.circle = Circle.objects.first() self.user.hubs.create(hub=self.circle.hub) post = Post.objects.create_circle_post(circle=self.circle, user_from=self.user, title=' '.join(faker.words()), description=faker.text()) user_1 = FakeUserFactory.create() user_1.hubs.create(hub=self.circle.hub) user_2 = FakeUserFactory.create() user_2.hubs.create(hub=self.circle.hub) post.reply(user_1, faker.text()) post.reply(user_2, faker.text()) post.reply(user_1, faker.text()) url = reverse('api:forum:post-answers', kwargs={'pk': post.pk}) # DO ACTION self.client.login(username=self.user.username, password='******') unseen_response = self.client.get(url) seen_response = self.client.get(url) # ASSERTS self.assertTrue(status.is_success(unseen_response.status_code)) data = unseen_response.json() for item in data.get('results', None): self.assertFalse(item.get('seen')) self.assertTrue(status.is_success(seen_response.status_code)) data = seen_response.json() for item in data.get('results', None): self.assertTrue(item.get('seen'))
def test_answer_user_titles(self): # PREPARE DATA post = self.posts_first_A[1] participant = post.created_by advisor = self.advisors_first[0].consultant.user participant.set_password('123456') participant.save() advisor.set_password('123456') advisor.save() post.reply(user_from=advisor, comment=faker.text()) post.reply(user_from=participant, comment=faker.text()) query_params = { 'project_id': self.qa_session_first.project.pk, 'team_id': self.team_A.pk, 'swarm_id': self.qa_session_first.teams.get(team=self.team_A).pk, 'question_id': post.pk } url = reverse('api:swarms:swarms-project-answers-list', kwargs=query_params) # DO ACTION self.client.login(username=advisor.username, password='******') response = self.client.get(url) # ASSERTS self.assertTrue(status.is_success(response.status_code)) data = response.json() participant_reply = data.get('results')[0] adv_reply = data.get('results')[1] self.assertEqual( adv_reply.get('createdBy').get('userTitle'), advisor.user_title) self.assertEqual(adv_reply.get('createdBy').get('projectTitle'), '') self.assertIsNone(participant_reply.get('createdBy').get('userTitle')) self.assertTrue('Participant' in participant_reply.get( 'createdBy').get('projectTitle'))
def test_apply_opportunity_with_questions(self, mock_request): # PREPARE DATA self.init_mock(mock_request) NUM_QUESTIONS = 3 opp = self.create_opportunity(questions=NUM_QUESTIONS) user = self.get_user() request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) answers_responses = [{ 'response': str(faker.boolean()).lower(), 'question': question, } for question in opp.questions.all()] # DO ACTION Applicant.objects.create_open_applicant( user_from=user, user=user, opportunity=opp, summary=faker.text(), budget=faker.text(), questions_extra_info=faker.word(), answers=answers_responses) # ASSERTS opp.refresh_from_db() self.assertTrue(opp.is_requested) self.assertEqual(opp.applicants_info.count(), 1) self.assertIsNotNone(opp.applicants_info.first().budget) self.assertIsNotNone(opp.applicants_info.first().summary) self.assertIsNotNone(opp.applicants_info.first().questions_extra_info) self.assertEqual(opp.applicants_info.first().answers.count(), NUM_QUESTIONS)
def test_retrieve_post_answers(self): # PREPARE DATA self.circle = Circle.objects.first() self.user.hubs.create(hub=self.circle.hub) post = Post.objects.create_circle_post(circle=self.circle, user_from=self.user, title=' '.join(faker.words()), description=faker.text()) user_1 = FakeUserFactory.create() user_1.hubs.create(hub=self.circle.hub) user_2 = FakeUserFactory.create() user_2.hubs.create(hub=self.circle.hub) post.reply(user_1, faker.text()) post.reply(user_2, faker.text()) post.reply(self.user, faker.text()) post.reply(user_1, faker.text()) url = reverse('api:forum:post-answers', kwargs={'pk': post.pk}) # DO ACTION self.client.login(username=self.user.username, password='******') response = self.client.get(url) # ASSERTS self.assertTrue(status.is_success(response.status_code)) data = response.json() self.assertEqual(data.get('count'), 4)
def test_new_conversation_when_apply(self, mock_request): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity(questions=0) user = self.get_user() request_mock_account.add_mock( user, is_consultant=True, is_superuser=False) applicant = Applicant.objects.create_open_applicant( user_from=user, user=user, opportunity=opp, summary=faker.text(), budget=faker.text()) matcher = re.compile( '{}/conversations/api/{}/conversations/create-group/'.format( settings.EXOLEVER_HOST, opp.uuid.__str__())) mock_request.register_uri( 'POST', matcher, json={}) # DO ACTION data = { 'opportunity_id': opp.id, 'user_from_id': applicant.user.id, 'message': '', 'files': [], } task = CreateOportunityConversationTask().s(**data).apply() # ASSERTS self.assertEqual(task.status, 'SUCCESS')
def test_edit_sow_applicant_opportunity(self, mock_request): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity() user = self.get_user() request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) applicant = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) data = self.get_sow_data() opp.assign(self.super_user, applicant, **data) new_sow_data = { 'sow': self.get_sow_data(), 'response_message': faker.text(), } # DO ACTION self.setup_credentials(self.super_user) url = reverse('api:applicant-detail-sow', kwargs={'pk': applicant.pk}) response = self.client.put(url, data=new_sow_data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) applicant.refresh_from_db() self.assertEqual(applicant.sow.title, new_sow_data['sow']['title'])
def test_feedback_both_reminder_by_command(self, mock_request): # PREPARE DATA self.init_mock(mock_request) # Opp requested with deadline for today opp = self.create_opportunity() # SELECTED end_date 2 days ago user = self.get_user() request_mock_account.add_mock( user, is_consultant=True, is_superuser=False) app = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) sow_data = self.get_sow_data() sow_data['end_date'] = (timezone.now() - timedelta(days=2)).date() opp.assign(self.super_user, app, faker.text(), **sow_data) app.set_completed() out = StringIO() err = StringIO() # ACTION management.call_command( 'opportunity_feedback', stdout=out, stderr=err) # ASSERTS out.seek(0) applicant_pk = out.readline().replace('\n', '') self.assertEqual( applicant_pk, 'Requester reminder: {}'.format(app.pk)) applicant_pk = out.readline().replace('\n', '') self.assertEqual( applicant_pk, 'Applicant reminder: {}'.format(app.pk))
def test_add_message_when_assign(self, mock_request): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity(questions=0) user = self.get_user() request_mock_account.add_mock( user, is_consultant=True, is_superuser=False) applicant = Applicant.objects.create_open_applicant( user_from=user, user=user, opportunity=opp, summary=faker.text(), budget=faker.text()) response_message = faker.text() data = self.get_sow_data() handler = mock.Mock() send_message_to_conversation.connect( handler, sender=applicant.__class__) # DO ACTION opp.assign(self.super_user, applicant, response_message, **data) # ASSERTS self.assertTrue(handler.called) self.assertEqual( self.get_mock_kwarg(handler, 'user_from'), self.super_user) self.assertEqual( self.get_mock_kwarg(handler, 'message'), response_message) self.assertEqual( self.get_mock_kwarg(handler, 'applicant'), applicant)
def test_feedback_given(self, mock_request): # PREPARE DATA self.init_mock(mock_request) # Opp requested with deadline for today opp = self.create_opportunity() # SELECTED end_date 2 days ago user = self.get_user() request_mock_account.add_mock( user, is_consultant=True, is_superuser=False) app = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) sow_data = self.get_sow_data() sow_data['end_date'] = (timezone.now() - timedelta(days=2)).date() opp.assign(self.super_user, app, faker.text(), **sow_data) app.set_status = None, settings.OPPORTUNITIES_CH_APPLICANT_FEEDBACK_READY out = StringIO() err = StringIO() # ACTION management.call_command( 'opportunity_feedback', stdout=out, stderr=err) # ASSERTS out.seek(0) self.assertEqual(out.readline(), '')
def test_email_when_close_manually_opportunity(self, mock_request, mock_email): # PREPARE DATA self.init_mock(mock_request) user = self.get_user() request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) opp = self.create_opportunity() models.Applicant.objects.create_open_applicant(user, user, opp, faker.text()) comment = faker.text() applicant_list = opp.applicants_info.pending_applicants().users() # DO ACTION send_email_when_opportunity_is_closed( opp, applicant_list, settings.OPPORTUNITIES_CH_CLOSE_MANUALLY, comment=comment) # ASSERTS self.assertEqual(mock_email.call_count, 1) self.assertEqual(self.get_mock_kwarg(mock_email, 'comment'), comment) self.assertEqual(self.get_mock_kwarg(mock_email, 'template'), settings.OPPORTUNITIES_MAIL_VIEW_CLOSED_MANUALLY) self.assertEqual( self.get_mock_kwarg(mock_email, 'recipients'), [request_mock_account.get_request(user.uuid.__str__())['email']])
def test_email_when_edit_opportunity(self, mock_request, mock_email): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity() applicant_user = self.get_user() request_mock_account.add_mock(applicant_user, is_consultant=True, is_superuser=False) models.Applicant.objects.create_open_applicant( user_from=applicant_user, user=applicant_user, opportunity=opp, summary=faker.text()) # DO ACTION task = OpportunityEditedTask().s(pk=opp.pk, comment=faker.text()).apply() # ASSERTS applicant_user_email = request_mock_account.get_request( str(applicant_user.uuid)).get('email') self.assertEqual(task.status, 'SUCCESS') self.assertTrue(mock_email.called) self.assertEqual(mock_email.call_count, 1) recipients = self.get_mock_kwarg(mock_email, 'recipients') self.assertEqual(recipients, [applicant_user_email])
def test_reject_applicant_opportunity(self, mock_request): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity() TOTAL_APPLICANTS = 2 applicants = [] for _ in range(TOTAL_APPLICANTS): user = self.get_user() request_mock_account.add_mock( user, is_consultant=True, is_superuser=False) applicant = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) applicants.append(applicant) # DO ACTION for app in applicants: response_message = faker.text() opp.reject(self.super_user, app, response_message) # ASSERTS self.assertTrue(opp.is_requested) self.assertEqual(opp.applicants_info.count(), TOTAL_APPLICANTS) self.assertEqual( opp.applicants_info.filter_by_status_rejected().count(), TOTAL_APPLICANTS)
def test_attached_file_for_payments_is_managed_by_email_task(self, request_mock): self.create_user() attachment = ( 'test1.pdf', faker.text() ) 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': attachment, } # DO ACTION SendMailTask().s( template=faker.word(), params=email_data, ).apply_async() # Asserts self.assertTrue(request_mock.called) file_attached = request_mock.call_args[1].get('data').fields.get('file') self.assertIsNotNone(file_attached) self.assertEqual(len(file_attached), 2)
def test_assign_opportunity_after_rejected(self, mock_request): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity() user = self.get_user() request_mock_account.add_mock( user, is_consultant=True, is_superuser=False) applicant = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.reject(opp.created_by, applicant) response_message = faker.text() data = self.get_sow_data() # DO ACTION opp.assign(self.super_user, applicant, response_message, **data) # ASSERTS applicant.refresh_from_db() self.assertTrue(applicant.is_selected) self.assertEqual(applicant.response_message, response_message) self.assertTrue(opp.is_requested) self.assertEqual( opp.applicants_info.filter_by_status_selected().count(), 1) self.assertEqual(opp.selected_by, {self.super_user}) self.assertIsNotNone(applicant.sow)
class FakeResourceFactory(django.DjangoModelFactory): """ Creates a fake consultant. """ class Meta: model = Resource created_by = factory.SubFactory(FakeUserFactory) name = factory.LazyAttribute(lambda x: faker.text(max_nb_chars=20)) description = factory.LazyAttribute(lambda x: faker.text()) file = factory.django.FileField() link = factory.LazyAttribute(lambda x: faker.url()) @factory.post_generation def tags(self, create, extracted, **kwargs): if not create: # Simple build, do nothing. return if extracted: # A list of groups were passed in, use them for tag in extracted: self.tags.add(tag) else: for tag in FakeTagFactory.create_batch(size=3): self.tags.add(tag)
def test_reject_applicant_opportunity(self, mock_request): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity() self.setup_credentials(self.super_user) TOTAL_APPLICANTS = 2 applicants = [] for _ in range(TOTAL_APPLICANTS): user = self.get_user() request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) applicant = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) applicants.append(applicant.pk) # DO ACTION for app_pk in applicants: url = reverse('api:applicant-reject', kwargs={'pk': app_pk}) data = {'response_message': faker.text()} response = self.client.put(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) opp.refresh_from_db() self.assertTrue(opp.is_requested)
def handle(self, *args, **options): self.stdout.write('\n Creating Post/Answers for testing: \n\n') consultants = Consultant.objects.all() for circle in Circle.objects.all(): users = followers(circle) if len(users) < 5: for consultant in set( random.choices(consultants, k=random.randint(2, 10))): circle.add_user(consultant.user) users = followers(circle) for i in range(random.randint(2, 10)): user = random.choices(users, k=1)[0] post = Post.objects.create_circle_post( user_from=user, circle=circle, title=' '.join(faker.words()), description=faker.text(), tags=random.choices(Keyword.objects.all(), k=random.randint(2, 6)), ) for consultant in set( random.choices(consultants, k=random.randint(2, 10))): post.see(consultant.user) for consultant in set( random.choices(consultants, k=random.randint(2, 10))): post.see(consultant.user) post.reply(consultant.user, faker.text()) self.stdout.write('\n Finish!! \n\n')
def test_apply_opportunity_with_questions(self, mock_request): # PREPARE DATA self.init_mock(mock_request) NUM_QUESTIONS = 3 opp = self.create_opportunity(questions=NUM_QUESTIONS) user = self.get_user() request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) self.setup_credentials(user) self.add_marketplace_permission(user) url = reverse('api:opportunity-apply', kwargs={'pk': opp.pk}) answers_responses = [{ 'response': str(faker.boolean()).lower(), 'question': question.pk, } for question in opp.questions.all()] # DO ACTION response = self.client.post(url, data={ 'comment': faker.text(), 'questions_extra_info': faker.text(), 'budget': faker.text(), 'answers': answers_responses, }) # ASSERTS self.assertTrue(status.is_success(response.status_code))
def test_user_rate_step_several_times(self): # PREPARE DATA ratings = [1, 2, 3] new_rate = [3, 4, 5] expected_rating = sum(new_rate) / 3.0 step = self.project.steps.all().first() team_step = self.team.steps.get(step=step) for index, member in enumerate(self.team.team_members.all()): team_step.do_rating(member, ratings[index], faker.text()) # DO ACTION for index, member in enumerate(self.team.team_members.all()): team_step.do_rating(member, new_rate[index], faker.text()) # ASSERTS consultant = self.team.coach interaction = Interaction.objects.filter( user=consultant.user, object_id=self.coach_role.id, content_type=ContentType.objects.get_for_model(self.coach_role), ).first() self.assertIsNotNone(interaction) self.assertEqual(interaction.ratings.count(), 1) self.assertEqual(round(interaction.rating, 1), round(expected_rating, 1)) for index, member in enumerate(self.team.team_members.all()): self.assertEqual(team_step.get_rating_for_user(member), new_rate[index])
def test_preview_page(self, mock_request, mock_build): # PREPARE DATA self.init_mock(mock_request) self.setup_credentials(self.user) url = reverse('api:landing:page-preview', kwargs={'uuid': self.uuid}) self.create_page(self.user) data = { 'theme': settings.LANDING_CH_STELLAR, 'slug': faker.slug(), 'sections': [ { 'name': faker.word(), 'content': '<p>{}</p>'.format(faker.text()), }, { 'name': faker.word(), 'content': '<p>{}</p>'.format(faker.text()), }, { 'name': faker.word(), 'content': '<p>{}</p>'.format(faker.text()), }, ] } # DO ACTION response = self.client.put(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) self.assertTrue(mock_build.called) self.assertEqual('event', self.get_mock_kwarg(mock_build, 'page_type'))
def test_close_manually_opportunity_with_applicants(self, mock_request): # PREPARE DATA self.init_mock(mock_request) opp = self.create_opportunity() handler = mock.Mock() opportunity_post_closed.connect(handler) user = self.get_user() request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) applicant = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.assign(self.super_user, applicant) comment = faker.text() user_conversation = self.get_user() opp.start_conversation(user_conversation, faker.text(), []) # DO ACTION opp.close(self.super_user, comment) # ASSERTS self.assertTrue(opp.is_closed) self.assertEqual( opp.applicants_info.filter_by_status_selected().count(), 1) self.assertEqual(opp.closed_by.user, self.super_user) self.assertEqual(handler.call_count, 1) self.assertEqual(self.get_mock_kwarg(handler, 'comment'), comment) self.assertEqual(self.get_mock_kwarg(handler, 'origin'), settings.OPPORTUNITIES_CH_CLOSE_MANUALLY) self.assertEqual(set(self.get_mock_kwarg(handler, 'user_list')), {user_conversation}) opportunity_post_closed.disconnect(handler)
def test_signal_close_user_list(self, mock_request): # PREPARE DATA self.init_mock(mock_request) self.handler = mock.Mock() opportunity_post_closed.connect(self.handler) opp = self.create_opportunity() user = self.get_user() request_mock_account.add_mock(user, is_consultant=True, is_superuser=False) applicant = models.Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.assign(self.super_user, applicant) NUM_OTHER_CONSULTANTS = 3 for _ in range(NUM_OTHER_CONSULTANTS): other_user = self.get_user() request_mock_account.add_mock(other_user, is_consultant=True, is_superuser=False) models.Applicant.objects.create_open_applicant( other_user, other_user, opp, faker.text()) # DO ACTION opp.close(self.super_user) # ASSERTS self.assertEqual(len(self.get_mock_kwarg(self.handler, 'user_list')), NUM_OTHER_CONSULTANTS) self.assertEqual(self.handler.call_count, 1) opportunity_post_closed.disconnect(self.handler)
def test_update_answer_team_project(self, answer_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, ) post = Post.objects.create_project_team_post( user_from=self.super_user, team=new_team, title=' '.join(faker.words()), description=faker.text(), ) answer = post.reply(self.user, faker.text()) url = reverse('api:forum:answer-detail', kwargs={'pk': answer.pk}) self.client.login(username=self.user.username, password='******') # DO ACTION data = {'comment': faker.text()} response = self.client.put(url, data=data) # ASSERTS self.assertTrue(status.is_success(response.status_code)) answer.refresh_from_db() self.assertEqual(answer.comment, data['comment']) self.assertTrue(answer_emails_task_mock.called) self.assertEqual(answer_emails_task_mock.call_count, 1) self.assertIsNotNone( self.get_mock_kwarg(answer_emails_task_mock, 'eta'))
def test_filtering_applicants_for_report(self): # PREPARE DATA opp = self.create_opportunity() applicants_expected = [] user_creator = opp.created_by # applicant feedback pending user = self.get_user() applicant = Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.assign(self.super_user, applicant) applicant.set_completed() # applicant give feedback, requester not user = self.get_user() applicant = Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.assign(user_creator, applicant) applicant.set_completed() applicant.give_feedback(user, **self.get_feedback()) # applicant give feedback, requester not and expired feedback user = self.get_user() applicant = Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.assign(user_creator, applicant) applicant.set_completed() applicant.give_feedback(user, **self.get_feedback()) applicant.set_feedback_expired() applicants_expected.append(applicant) # requester give feedback, applicant not user = self.get_user() applicant = Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.assign(user_creator, applicant) applicant.set_completed() applicant.give_feedback(opp.created_by, **self.get_feedback()) applicants_expected.append(applicant) # not requester neither applicant give feedback user = self.get_user() applicant = Applicant.objects.create_open_applicant( user, user, opp, faker.text()) opp.assign(user_creator, applicant) applicant.set_completed() applicant.set_feedback_expired() applicants_expected.append(applicant) command = Command() # DO ACTION applicants = command.get_applicants_feedback_received() # DO ASSERTS self.assertEqual( set(applicants), set(applicants_expected))
def save_user(user): user.short_name = faker.first_name() user.full_name = faker.name() user.email = email(user) user.bio_me = faker.text() user.short_me = faker.text() user.about_me = faker.text() user.profile_picture.name = None user.profile_picture_origin = settings.EXO_ACCOUNTS_PROFILE_PICTURE_CH_DEFAULT user.save() return user
class FakeOpportunityFactory(factory.django.DjangoModelFactory): title = factory.LazyAttribute(lambda x: faker.text(max_nb_chars=20)) description = factory.LazyAttribute(lambda x: faker.text()) location = factory.LazyAttribute( lambda x: '{}, {}'.format(faker.city(), faker.country())) exo_role = factory.LazyAttribute(lambda o: ExORole.objects.get( code=settings.EXO_ROLE_CODE_SPRINT_COACH)) certification_required = factory.LazyAttribute( lambda o: CertificationRole.objects.get( code=settings.EXO_ROLE_CODE_CERTIFICATION_SPRINT_COACH)) start_date = factory.fuzzy.FuzzyDate(datetime.date.today()) deadline_date = factory.fuzzy.FuzzyDate(datetime.date.today()) duration_unity = factory.fuzzy.FuzzyChoice( dict(settings.OPPORTUNITIES_DURATION_UNITY_CHOICES).keys(), ) duration_value = faker.random_digit_not_null() entity = factory.LazyAttribute(lambda x: faker.company()) keywords = [] languages = [] budget = factory.LazyAttribute(lambda x: faker.pyint()) budget_currency = settings.OPPORTUNITIES_CH_CURRENCY_DOLLAR virtual_budget = factory.LazyAttribute(lambda x: faker.pyint()) virtual_budget_currency = settings.OPPORTUNITIES_CH_CURRENCY_EXOS class Meta: model = Opportunity @classmethod def _create(cls, model_class, *args, **kwargs): """Override the default ``_create`` with our custom call.""" manager = cls._get_manager(model_class) if not kwargs.get('user_from'): raise Exception('User is required') # The default would use ``manager.create(*args, **kwargs)`` budgets = [] if kwargs.get('budget'): budgets.append({ 'budget': kwargs.get('budget'), 'currency': kwargs.get('budget_currency') }) if kwargs.get('virtual_budget'): budgets.append({ 'budget': kwargs.get('virtual_budget').__str__(), 'currency': kwargs.get('virtual_budget_currency') }) kwargs['budgets'] = budgets return manager.create_opportunity(*args, **kwargs)