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)
