def test_people_registered_closed_task(self):
self.task.status = 'closed'
self.task.save()
TaskMemberFactory.create(member=self.user, task=self.task)
self.assertEqual(self.project.people_registered, 0)
def test_event_is_nigh(self):
"""
Deadline in 5 days should trigger
"""
self.task.deadline = now() + timedelta(days=5)
self.task.people_needed = 3
self.task.type = 'ongoing'
self.task.status = 'open'
self.task.save()
TaskMemberFactory.create_batch(3, task=self.task, status='accepted')
self.assertEquals(len(mail.outbox), 3)
# Empty
mail.outbox = []
# Run the (scheduled) task for reminder mails
send_task_reminder_mails()
# Now the outbox should have 3 new mails
self.assertEquals(len(mail.outbox), 3)
self.assertEquals(mail.outbox[0].subject, 'The task you subscribed to is due')
self.assertTrue('days to complete your task' in mail.outbox[0].body)
# Running the task again shouldn't send the mails again
send_task_reminder_mails()
self.assertEquals(len(mail.outbox), 3)
def test_ongoing_running_after_deadline_to_apply_to_many(self):
task = TaskFactory.create(status='open',
people_needed=2,
type='ongoing')
TaskMemberFactory.create(task=task, status='applied', externals=2)
self.assertEqual(task.status, 'open')
task.deadline_to_apply = timezone.now() - timedelta(days=1)
task.deadline_to_apply_reached()
self.assertEqual(task.status, 'in progress')
self.assertEqual(task.people_needed, 2)
email = mail.outbox[-1]
self.assertEqual(
email.subject,
"The deadline to apply for your task '{}' has passed".format(
task.title))
self.assertTrue("Your task has been set to 'running'" in email.body)
self.assertTrue(
"You still have to accept your candidates" in email.body)
self.assertTrue('Accept candidates: https://testserver/tasks/{}'.
format(task.id) in email.body)
def setUp(self):
super(TaskEmailTests, self).setUp()
self.some_user = BlueBottleUserFactory.create(first_name='King')
self.another_user = BlueBottleUserFactory.create(first_name='Kong')
self.some_project = ProjectFactory.create()
self.task = TaskFactory.create(
status=TASK_MODEL.TaskStatuses.in_progress,
author=self.some_project.owner,
)
self.taskmember1 = TaskMemberFactory.create(
member=self.some_user,
status=TASKS_MEMBER_MODEL.TaskMemberStatuses.applied,
task=self.task
)
self.taskmember2 = TaskMemberFactory.create(
member=self.another_user,
status=TASKS_MEMBER_MODEL.TaskMemberStatuses.applied,
task=self.task
)
self.task.save()
def setUp(self):
super(TaskEmailTests, self).setUp()
self.init_projects()
self.some_user = BlueBottleUserFactory.create(first_name='King',
primary_language='fr')
self.another_user = BlueBottleUserFactory.create(first_name='Kong',
primary_language='nl')
self.yet_another_user = BlueBottleUserFactory.create(first_name='Gong',
primary_language='en')
self.some_project = ProjectFactory.create()
self.some_project.owner.primary_language = 'en'
self.task = TaskFactory.create(
status=Task.TaskStatuses.in_progress,
author=self.some_project.owner,
)
self.taskmember1 = TaskMemberFactory.create(
member=self.some_user,
status=TaskMember.TaskMemberStatuses.applied,
task=self.task
)
self.taskmember2 = TaskMemberFactory.create(
member=self.another_user,
status=TaskMember.TaskMemberStatuses.applied,
task=self.task
)
self.task.save()
def test_calculate_task_count(self):
"""
Test that the task_count property on a user is calculated correctly.
We count a) tasks where a user is a task author and
b) TaskMembers where a user is applied, accepted or realized
"""
self.assertEqual(self.user.task_count, 0)
task = TaskFactory.create(author=self.user)
self.assertEqual(self.user.task_count, 1)
taskmember = TaskMemberFactory.create(
member=self.user,
status=TASKS_MEMBER_MODEL.TaskMemberStatuses.applied,
task=task
)
self.assertEqual(self.user.task_count, 2)
uncounted_taskmember = TaskMemberFactory.create(
member=self.user,
status=TASKS_MEMBER_MODEL.TaskMemberStatuses.stopped,
task=task
)
self.assertEqual(self.user.task_count, 2)
def test_task_ignored_non_active_project(self):
"""
Task that are connected to a project that hasn't started yet should be ignored.
"""
now = timezone.now()
project = ProjectFactory.create(status=ProjectPhase.objects.get(
slug='plan-new'))
task = TaskFactory.create(title='task1',
people_needed=2,
project=project,
status='open',
deadline=now - timezone.timedelta(days=5))
TaskMemberFactory.create(task=task, status='accepted')
self.assertEquals(len(mail.outbox), 1)
call_command('cron_status_realised')
# There should not be additional mails
self.assertEquals(len(mail.outbox), 1)
# Task should still be open
task1 = Task.objects.get(title='task1')
self.assertEquals(task1.status, 'open')
def test_people_registered_expired_task(self):
self.task.deadline = timezone.now() - timezone.timedelta(days=1)
self.task.save()
TaskMemberFactory.create(member=self.user, task=self.task)
self.assertEqual(self.project.people_registered, 1)
def test_people_registered_for_two_tasks(self):
TaskMemberFactory.create(member=self.user,
task=self.task)
TaskMemberFactory.create(member=self.user,
task=self.other_task)
self.assertEqual(self.project.people_registered, 2)
def test_event_sufficient_members(self):
"""
Ongoing Tasks with sufficient members (including externals) should be full progess
"""
task = TaskFactory.create(status='open', people_needed=2, type='event')
TaskMemberFactory.create(task=task, status='accepted', externals=1)
self.assertEqual(task.status, 'full')
def test_people_registered_closed_task(self):
self.task.status = 'closed'
self.task.save()
TaskMemberFactory.create(member=self.user,
task=self.task)
self.assertEqual(self.project.people_registered, 0)
def test_people_registered_expired_task(self):
self.task.deadline = timezone.now() - timezone.timedelta(days=1)
self.task.save()
TaskMemberFactory.create(member=self.user,
task=self.task)
self.assertEqual(self.project.people_registered, 0)
def test_theme_translated(self, queue_mock):
theme = ProjectThemeFactory.create(name='Cleaning the beach',
slug='cleaning-the-beach')
project = ProjectFactory.create(theme=theme)
task = TaskFactory.create(project=project)
TaskMemberFactory.create(task=task)
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags']['theme'], 'Cleaning the park')
def test_deadline_realised(self):
self.task.people_needed = 2
self.task.save()
TaskMemberFactory.create(task=self.task, status='accepted')
self.task.deadline_reached()
self.assertEqual(self.task.status, Task.TaskStatuses.realized)
def setUp(self):
super(HomepageEndpointTestCase, self).setUp()
self.init_projects()
self.stats = Statistics()
"""
Create 10 Project instances for one user with half in the campaign phase
and the other half in the done-complete phase
This will create:
- 10 running or realised projects
- 10 campaigners (eg 10 new people involved)
"""
self.user1 = BlueBottleUserFactory.create()
self.campaign_phase = ProjectPhase.objects.get(slug='campaign')
self.plan_phase = ProjectPhase.objects.get(slug='done-complete')
projects = []
for char in 'abcdefghij':
# Put half of the projects in the campaign phase.
if ord(char) % 2 == 1:
project = ProjectFactory.create(title=char * 3, slug=char * 3, status=self.campaign_phase)
else:
project = ProjectFactory.create(title=char * 3, slug=char * 3, status=self.plan_phase)
projects.append(project)
"""
Create 10 TaskMember instances for one project.
This will create:
- 1 realised task
- 1 task owner (eg 1 new person involved)
- 10 task members (eg 10 new people involved)
"""
self.task = TaskFactory.create(project=projects[0], status=Task.TaskStatuses.realized)
for char in 'abcdefghij':
# Put half of the projects in the campaign phase.
if ord(char) % 2 == 1:
task = TaskMemberFactory.create(task=self.task)
else:
task = TaskMemberFactory.create(task=self.task)
"""
Create 10 Donations with half to fundraisers
This will create:
- 10 donations of 1000 (total amount of 10000)
- 10 donators (eg 10 new people involved)
- 5 fundraisers (eg 5 new people involved)
"""
for char in 'abcdefghij':
if ord(char) % 2 == 1:
self.order = OrderFactory.create(status=StatusDefinition.SUCCESS)
self.donation = DonationFactory.create(amount=1000, order=self.order, fundraiser=None)
else:
self.order = OrderFactory.create(status=StatusDefinition.SUCCESS)
self.donation = DonationFactory.create(amount=1000, order=self.order)
def test_task_realized(self):
task = TaskFactory.create(status='open', people_needed=2, type='event')
TaskMemberFactory.create(task=task, status='accepted', externals=1)
self.assertEqual(task.status, 'full')
task.deadline = timezone.now() - timedelta(days=1)
task.deadline_reached()
self.assertEqual(task.status, 'realized')
def test_check_number_of_members_needed_no_externals_count(self):
""" Test that 'check_number_of_members_needed' returns the right count without externals"""
task = TaskFactory.create(status='open', people_needed=4)
task_member1 = TaskMemberFactory.create(task=task, status='accepted')
self.assertEqual(task_member1.check_number_of_members_needed(task), 1)
task_member2 = TaskMemberFactory.create(task=task, status='accepted')
self.assertEqual(task_member2.check_number_of_members_needed(task), 2)
self.assertEqual(task_member1.check_number_of_members_needed(task), 2)
def test_task_only_applied(self):
task = TaskFactory.create(status='open', people_needed=2, type='event')
TaskMemberFactory.create(task=task, status='applied')
self.assertEqual(task.status, 'open')
task.deadline = timezone.now() - timedelta(days=1)
task.deadline_reached()
self.assertEqual(task.status, 'closed')
def test_check_number_of_members_needed_no_externals_count(self):
""" Test that 'check_number_of_members_needed' returns the right count without externals"""
task = TaskFactory.create(status='open', people_needed=4)
task_member1 = TaskMemberFactory.create(task=task, status='accepted')
self.assertEqual(task_member1.task.people_accepted, 1)
task_member2 = TaskMemberFactory.create(task=task, status='accepted')
self.assertEqual(task_member2.task.people_accepted, 2)
self.assertEqual(task_member1.task.people_accepted, 2)
def test_task_count(self):
""" Test various task_count values """
# No task members assigned to a task of a project, so there is a task open
response = self.client.get(self.previews_url, HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['results'][0]['task_count'], 1)
task_member = TaskMemberFactory.create(member=self.another_user, task=self.task1, status='accepted')
# The task has one task member and two people needed, still one task open
response = self.client.get(self.previews_url, HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['results'][0]['task_count'], 1)
task_member2 = TaskMemberFactory.create(member=self.yet_another_user, task=self.task1, status='accepted')
# The task has two accepted task members for two people_needed, no more task open
response = self.client.get(self.previews_url, HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['results'][0]['task_count'], 0)
task_member2.status = 'applied'
task_member2.save()
# FIXME: Make sure task is marked as available in the code.
# The task has one accepted task member and one applied member, still one open task
# response = self.client.get(self.previews_url, HTTP_AUTHORIZATION=self.some_token)
# self.assertEqual(response.data['results'][0]['task_count'], 1)
self.task1.status = BB_TASK_MODEL.TaskStatuses.closed
self.task1.save()
# The task is closed, so don't give a task_count
response = self.client.get(self.previews_url, HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['results'][0]['task_count'], 0)
self.task1.status = BB_TASK_MODEL.TaskStatuses.realized
self.task1.save()
# The task is realized, so don't give a task_count
response = self.client.get(self.previews_url, HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['results'][0]['task_count'], 0)
self.task1.status = BB_TASK_MODEL.TaskStatuses.open
self.task1.save()
task2 = TaskFactory.create(
status=BB_TASK_MODEL.TaskStatuses.open,
author=self.some_project.owner,
project=self.some_project,
people_needed=2
)
# There are now two tasks for the same project, so task_count gives 2
response = self.client.get(self.previews_url, HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['results'][0]['task_count'], 2)
def test_check_number_of_members_needed_with_externals_count(self):
""" Test that 'check_number_of_members_needed' returns the right count with externals"""
task = TaskFactory.create(status='open', people_needed=4)
task_member1 = TaskMemberFactory.create(task=task, status='accepted',
externals=1)
self.assertEqual(task_member1.task.people_accepted, 2)
task_member2 = TaskMemberFactory.create(task=task, status='accepted',
externals=2)
self.assertEqual(task_member2.task.people_accepted, 5)
self.assertEqual(task_member1.task.people_accepted, 5)
def test_bulk_status_change(self, queue_mock):
for i in range(10):
TaskMemberFactory.create()
previous_call_count = queue_mock.call_count
TaskMember.objects.update(status='realized')
self.assertEqual(queue_mock.call_count, previous_call_count + len(Task.objects.all()),
'Analytics should be sent when update is called')
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags']['status'], 'realized')
def test_complete(self):
# Upload an email logo
image_file = open("./bluebottle/mails/tests/images/logo-email.gif",
"rb")
mail_settings = MailPlatformSettings.load()
mail_settings.email_logo.save("email-logo.gif",
File(image_file),
save=True)
mail_settings.save()
TaskMemberFactory.create(status='applied')
email = mail.outbox[0]
self.assertTrue('<img alt="logo"' in email.alternatives[0][0])
def test_task_member_realized_to_partially_rejected(self):
task = TaskFactory.create(status='realized',
people_needed=2,
type='ongoing')
member = TaskMemberFactory.create(task=task, status='realized')
TaskMemberFactory.create(task=task, status='realized')
self.assertEqual(task.status, 'realized')
member.status = 'rejected'
member.save()
self.assertEqual(task.status, 'realized')
def test_bulk_status_change(self, queue_mock):
for i in range(10):
TaskMemberFactory.create()
previous_call_count = queue_mock.call_count
TaskMember.objects.update(status='realized')
self.assertEqual(queue_mock.call_count,
previous_call_count + len(Task.objects.all()),
'Analytics should be sent when update is called')
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags']['status'], 'realized')
def setUp(self):
super(TestProjectPopularity, self).setUp()
self.init_projects()
self.project = ProjectFactory.create()
VoteFactory.create(project=self.project)
task = TaskFactory.create(project=self.project)
TaskMemberFactory.create(task=task)
order = OrderFactory.create(status=StatusDefinition.SUCCESS)
DonationFactory(order=order, project=self.project)
def setUp(self):
super(TestProjectPopularity, self).setUp()
self.init_projects()
self.project = ProjectFactory.create()
VoteFactory.create(project=self.project)
task = TaskFactory.create(project=self.project)
TaskMemberFactory.create(task=task)
order = OrderFactory.create(status=StatusDefinition.SUCCESS)
DonationFactory(order=order, project=self.project)
def test_task_status_changed(self):
"""
Test that tasks with (only) status 'in progress' and that are passed
their deadline get the status 'realized'
"""
now = timezone.now()
project = ProjectFactory.create(status=ProjectPhase.objects.get(
slug='campaign'))
task1 = TaskFactory.create(title='task1',
people_needed=5,
project=project,
deadline=now + timezone.timedelta(days=5))
task2 = TaskFactory.create(title='task2',
people_needed=5,
project=project,
deadline=now + timezone.timedelta(days=5))
task3 = TaskFactory.create(title='task3',
people_needed=5,
project=project,
type='event',
deadline=now + timezone.timedelta(days=5))
TaskMemberFactory.create(task=task1, status='accepted')
TaskMemberFactory.create_batch(5, task=task3, status='accepted')
self.assertEquals(len(mail.outbox), 6)
task1 = Task.objects.get(title='task1')
task2 = Task.objects.get(title='task2')
task3 = Task.objects.get(title='task3')
# Check task statuses
self.assertEqual(task1.status, 'open')
self.assertEqual(task2.status, 'open')
self.assertEqual(task3.status, 'full')
# Change deadline so we can finish the tasks
Task.objects.update(deadline=now - timezone.timedelta(days=5))
call_command('cron_status_realised')
task1 = Task.objects.get(title='task1')
task2 = Task.objects.get(title='task2')
task3 = Task.objects.get(title='task3')
self.assertEqual(task1.status, 'realized')
self.assertEqual(task2.status, 'closed')
self.assertEqual(task3.status, 'realized')
# Expect two extra mails for task owners
self.assertEquals(len(mail.outbox), 8)
def test_save_check_status_update_insufficent_accepted_members(self):
""" Check that the save method correctly sets the status of the task if not enough task members are
accepted for the task and the save method is called """
task = TaskFactory.create(status='open', people_needed=4)
task_member1 = TaskMemberFactory.create(task=task, status='accepted', externals=1)
task.save()
self.assertEqual(task.status, 'open')
task_member2 = TaskMemberFactory.create(task=task, status='accepted')
task.save()
# Total of 3 out of 4 people. Task status should be open.
self.assertEqual(task.status, 'open')
def test_data_export(self):
campaign = ProjectPhase.objects.get(slug='done-complete')
done = ProjectPhase.objects.get(slug='done-complete')
projects = ProjectFactory.create_batch(10, status=campaign)
tasks = TaskFactory.create_batch(10, project=projects[0], status='realized')
TaskMemberFactory.create_batch(10, task=tasks[0], status='realized')
for project in projects:
project.status = done
project.save()
self.client.force_login(self.superuser)
url = reverse('exportdb_export')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def setUp(self):
super(ParticipationStatisticsTest, self).setUp()
# Required by Project model save method
self.init_projects()
self.user_1 = BlueBottleUserFactory.create()
self.user_2 = BlueBottleUserFactory.create()
self.user_3 = BlueBottleUserFactory.create()
self.location = LocationFactory.create()
self.project_status_plan_new = ProjectPhase.objects.get(
slug='plan-new')
self.project_status_plan_submitted = ProjectPhase.objects.get(
slug='plan-submitted')
self.project_status_voting = ProjectPhase.objects.get(slug='voting')
self.project_status_voting_done = ProjectPhase.objects.get(
slug='voting-done')
self.project_status_campaign = ProjectPhase.objects.get(
slug='campaign')
self.project_status_done_complete = ProjectPhase.objects.get(
slug='done-complete')
self.project_status_done_incomplete = ProjectPhase.objects.get(
slug='done-incomplete')
self.project_status_closed = ProjectPhase.objects.get(slug='closed')
self.some_project = ProjectFactory.create(
owner=self.user_1,
status=self.project_status_done_complete,
location=self.location)
self.another_project = ProjectFactory.create(owner=self.user_2)
self.some_task = TaskFactory.create(project=self.some_project,
author=self.user_1)
self.another_task = TaskFactory.create(project=self.another_project,
author=self.user_2)
self.some_task_member = TaskMemberFactory.create(member=self.user_1,
task=self.some_task)
self.another_task_member = TaskMemberFactory.create(
member=self.user_2, task=self.another_task)
start = pendulum.create().subtract(days=7)
end = pendulum.create().add(days=7)
# TODO: Create atleast one project, task and task member outside the time range
self.statistics = ParticipationStatistics(start=start, end=end)
def test_task_status_changes(self):
"""
Test that tasks changes status.
"""
now = timezone.now()
project = ProjectFactory.create(status=ProjectPhase.objects.get(
slug='campaign'))
task1 = TaskFactory.create(title='My Task',
people_needed=5,
project=project,
status='open',
type='event',
deadline_to_apply=now -
timezone.timedelta(days=5),
deadline=now + timezone.timedelta(days=5))
task2 = TaskFactory.create(title='My Task 2',
people_needed=5,
project=project,
status='open',
type='ongoing',
deadline_to_apply=now -
timezone.timedelta(days=5),
deadline=now + timezone.timedelta(days=5))
TaskMemberFactory.create_batch(5, task=task1, status='accepted')
TaskMemberFactory.create_batch(5, task=task2, status='accepted')
task1 = Task.objects.get(title='My Task')
self.assertEqual(task1.status, 'full')
task2 = Task.objects.get(title='My Task 2')
self.assertEqual(task2.status, 'in progress')
task1.deadline = now - timezone.timedelta(days=5)
task1.save()
task2.deadline = now - timezone.timedelta(days=5)
task2.save()
call_command('cron_status_realised')
task1 = Task.objects.get(title='My Task')
self.assertEqual(task1.status, 'realized')
task2 = Task.objects.get(title='My Task 2')
self.assertEqual(task2.status, 'realized')
def test_task_member_applied_to_realized(self):
task = TaskFactory.create(status='open',
people_needed=2,
type='ongoing')
member = TaskMemberFactory.create(task=task, status='applied')
TaskMemberFactory.create(task=task, status='applied')
task.deadline_reached()
self.assertEqual(task.status, 'closed')
member.status = 'realized'
member.save()
self.assertEqual(task.status, 'realized')
def test_deadline_to_apply_reached_event_target_not_reached_email(self):
"""
Event task without enough people.
Run status realised cron job should send mails and change task status.
"""
TaskMemberFactory.create_batch(4, task=self.task, status='accepted')
self.assertEquals(len(mail.outbox), 4)
call_command('cron_status_realised')
self.assertEquals(len(mail.outbox), 5)
self.assertEquals(self.task.status, 'open')
# running the status realised cron job should not send an new email
call_command('cron_status_realised')
self.assertEquals(len(mail.outbox), 5)
def test_report_export(self):
campaign = ProjectPhase.objects.get(slug='done-complete')
done = ProjectPhase.objects.get(slug='done-complete')
projects = ProjectFactory.create_batch(10, status=campaign)
tasks = TaskFactory.create_batch(10, project=projects[0], status='realized')
TaskMemberFactory.create_batch(10, task=tasks[0], status='realized')
for project in projects:
project.status = done
project.save()
report = MetricsReport()
result = report.to_output()
wb = load_workbook(result)
self.assertEqual(wb.active.title, 'Definitions')
totals = wb.worksheets[1]
self.assertEqual(totals.title, 'Totals {}'.format(now().year))
def test_insufficient_members(self):
"""
Check that tasks with insufficient members are marked as 'open'
"""
task = TaskFactory.create(status='open', people_needed=4)
TaskMemberFactory.create(task=task, status='accepted', externals=1)
task.save()
self.assertEqual(task.status, 'open')
TaskMemberFactory.create(task=task, status='accepted')
task.save()
# Total of 3 out of 4 people. Task status should be open.
self.assertEqual(task.status, 'open')
def test_tags_generation(self, queue_mock):
user = BlueBottleUserFactory.create()
task = TaskFactory.create(author=user, people_needed=2)
task_member = TaskMemberFactory.create(time_spent=10.5,
member=user,
task=task,
status='applied')
project = task.project
expected_tags = {
'id': task_member.id,
'type': 'task_member',
'tenant': u'test',
'status': 'applied',
'location': '',
'location_group': '',
'country': project.country.name,
'theme': project.theme.name,
'theme_slug': project.theme.slug,
}
expected_fields = {
'id': task_member.id,
'task_id': task_member.task.id,
'project_id': project.id,
'user_id': user.id,
'hours': int(task_member.time_spent)
}
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags'], expected_tags)
self.assertEqual(kwargs['fields'], expected_fields)
def test_check_number_of_members_needed_set_in_progress(self):
""" Test that the task status changes when enough people are accepted for a task. It shouldn't update
when insufficient people are accepted."""
task = TaskFactory.create(status='open', people_needed=4)
task_member1 = TaskMemberFactory.create(task=task, status='accepted', externals=1)
self.assertEqual(task_member1.check_number_of_members_needed(task), 2)
# Not enough people yet
self.assertEqual(task.status, 'open')
task_member2 = TaskMemberFactory.create(task=task, status='accepted', externals=2)
self.assertEqual(task_member2.check_number_of_members_needed(task), 5)
# More than people_needed have applied
self.assertEqual(task.status, 'in progress')
def test_task_member_rejected(self):
task = TaskFactory.create(status=Task.TaskStatuses.open,
author=self.some_user,
project=self.some_project,
people_needed=1)
TaskMemberFactory.create(member=self.some_user,
task=task,
status='rejected')
task_member_data = {'task': task.id, 'motivation': 'Pick me!'}
response = self.client.post(self.task_member_url,
task_member_data,
HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_task_realized_when_members_realized(self):
"""
If all the task members are realized after the deadline for a task which
is not yet realized (eg. closed) then the task should also be realized.
"""
deadline = timezone.now() - timezone.timedelta(days=1)
task = TaskFactory.create(deadline=deadline, status='closed', people_needed=2)
task_member1 = TaskMemberFactory.create(task=task, status='accepted')
task_member2 = TaskMemberFactory.create(task=task, status='accepted')
task_member1.status = TaskMember.TaskMemberStatuses.realized
task_member1.save()
task_member2.status = TaskMember.TaskMemberStatuses.realized
task_member2.save()
self.assertEqual(task.status, Task.TaskStatuses.realized)
def test_member_applied_to_task_mail_not_to_project_owner(self):
"""
Test emails for realized task with a task member
"""
self.project.owner = BlueBottleUserFactory()
self.project.save()
self.task.status = "in progress"
self.assertEquals(len(mail.outbox), 0)
self.task.save()
self.task_member = TaskMemberFactory.create(task=self.task,
status='applied')
# Task owner receives email about new task member
self.assertEquals(len(mail.outbox), 1)
body = mail.outbox[0].body
self.assertTrue('applied for your task' in body)
self.assertFalse('with the following motivation' in body)
self.assertTrue(self.task_member.member.full_name in body)
self.assertEquals(mail.outbox[0].to[0], self.task.author.email)
self.task_member.status = 'accepted'
self.task_member.save()
# Task member receives email that he is accepted
self.assertEquals(len(mail.outbox), 2)
self.assertNotEquals(mail.outbox[1].subject.find("assigned"), -1)
self.assertEquals(mail.outbox[1].to[0], self.task_member.member.email)
def test_tags_generation(self, queue_mock):
user = BlueBottleUserFactory.create()
task = TaskFactory.create(author=user, people_needed=2)
task_member = TaskMemberFactory.create(time_spent=10.5, member=user, task=task, status='applied')
project = task.project
expected_tags = {
'type': 'task_member',
'tenant': u'test',
'status': 'applied',
'location': '',
'location_group': '',
'country': task.project.country.name,
'theme': project.theme.name,
'theme_slug': project.theme.slug,
}
expected_fields = {
'id': task_member.id,
'task_id': task.id,
'user_id': user.id,
'hours': int(task_member.time_spent)
}
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags'], expected_tags)
self.assertEqual(kwargs['fields'], expected_fields)
def test_task_auto_accept_taskmembers(self):
"""
When saving a task with accepting=automatic new task members should be accepted instantly
"""
task = TaskFactory(accepting='automatic')
task_member = TaskMemberFactory(task=task)
self.assertEqual(task_member.status, 'accepted')
def test_no_members_after_deadline_to_apply_withdrew(self):
task = TaskFactory.create(status='open',
people_needed=2,
type='ongoing')
self.assertEqual(task.status, 'open')
member = TaskMemberFactory.create(task=task,
status='accepted',
externals=0)
member.delete()
task.deadline_to_apply = timezone.now() - timedelta(days=1)
task.deadline_to_apply_reached()
self.assertEqual(task.status, 'closed')
self.assertEqual(task.people_needed, 2)
email = mail.outbox[-1]
self.assertEqual(
email.subject,
"The deadline to apply for your task '{}' has passed".format(
task.title))
self.assertTrue("the task is set to 'closed'" in email.body)
self.assertTrue('Edit task https://testserver/tasks/{}/edit'.format(
task.id) in email.body)
def test_save_check_status_update_sufficent_accepted_members(self):
""" Check that the save method correctly sets the status of the task if enough task members are
accepted for the task and the save method is called """
task = TaskFactory.create(status='open', people_needed=2)
task_member1 = TaskMemberFactory.create(task=task, status='accepted', externals=1)
task.save()
self.assertEqual(task.status, 'in progress')
def test_task_status_log_creation(self):
task_member = TaskMemberFactory.create(status='applied')
task_member.save()
log = TaskMemberStatusLog.objects.first()
self.assertEqual(TaskStatusLog.objects.count(), 1)
self.assertEqual(log.status, 'applied')
self.assertEqual(log.task_member_id, task_member.id)
def test_accepting_manual(self):
task = TaskFactory.create(status='open',
people_needed=4,
accepting='manual')
task_member = TaskMemberFactory.create(task=task, status='applied')
self.assertEqual(task_member.status, 'applied')
def test_theme_translated(self, queue_mock):
theme = ProjectThemeFactory.create(name='Cleaning the beach',
slug='cleaning-the-beach')
project = ProjectFactory.create(theme=theme)
task = TaskFactory.create(project=project)
task_member = TaskMemberFactory.create(task=task)
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags']['theme'], 'Cleaning the park')
def test_task_stats(self):
self.assertEqual(self.stats.tasks_realized, 0)
# project is in campaign phase
self.some_project.status = self.campaign_status
self.some_project.save()
# Create a task and add other user as member
self.task = TaskFactory.create(author=self.some_user,
project=self.some_project,
status=Task.TaskStatuses.realized)
TaskMemberFactory.create(task=self.task, member=self.another_user)
self.assertEqual(self.stats.tasks_realized, 1)
# People involved:
# - campaigner
# - task member (another_user)
self.assertEqual(self.stats.people_involved, 2)
def setUp(self):
self.init_projects()
self.user = BlueBottleUserFactory.create()
self.login(username=self.user.email, password='******')
self.task = TaskFactory.create(people_needed=2, time_needed=8)
self.task.author = BlueBottleUserFactory.create()
self.task.save()
self.task_member = TaskMemberFactory.create(member=self.user, task=self.task)
def test_delete_task_member_unauthorized(self):
task = TaskFactory.create()
task_member = TaskMemberFactory.create(member=self.another_user, task=task)
self.assertEquals(task.members.count(), 1)
response = self.client.delete('{0}{1}'.format(self.task_members_url, task_member.id),
token=self.some_token)
self.assertEquals(task.members.count(),1)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
def test_delete_task_member_no_allowed(self):
task = TaskFactory.create()
task_member = TaskMemberFactory.create(member=self.some_user, task=task)
self.assertEquals(task.people_applied, 1)
response = self.client.delete(
'{0}{1}'.format(self.task_members_url, task_member.id),
token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
def test_unchanged_status(self, queue_mock):
user = BlueBottleUserFactory.create()
task_member = TaskMemberFactory.create(member=user, status='applied')
previous_call_count = queue_mock.call_count
# Update record without changing status
task_member.motivation = 'I want an extra clean beach'
task_member.save()
self.assertEqual(previous_call_count, queue_mock.call_count,
'Analytics should only be sent when status changes')
def test_delete_task_member(self):
task = TaskFactory.create()
task_member = TaskMemberFactory.create(member=self.some_user, task=task)
self.assertEquals(task.members.count(), 1)
response = self.client.delete('{0}{1}'.format(self.task_members_url, task_member.id),
token=self.some_token)
self.assertEquals(task.members.count(),0)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT, response.data)
def test_status_change(self, queue_mock):
user = BlueBottleUserFactory.create()
task = TaskFactory.create(author=user, people_needed=2)
task_member = TaskMemberFactory.create(member=user, task=task, status='approved')
previous_call_count = queue_mock.call_count
# Update record without changing status
task_member.status = 'realized'
task_member.save()
self.assertEqual(previous_call_count+1, queue_mock.call_count,
'Analytics should be sent when task member status changes')
def test_taskmember_delete_status_changes(self, queue_mock):
user = BlueBottleUserFactory.create()
task = TaskFactory.create(author=user, people_needed=2, status='realized')
task_member = TaskMemberFactory.create(time_spent=10, member=user, task=task, status='applied')
task_member_url = reverse('task_member_detail', kwargs={'pk': task_member.id})
task_member_data = {
'task': task.id,
'status': 'withdrew'
}
self.client.put(task_member_url, task_member_data, token="JWT {0}".format(user.get_jwt_token()))
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags']['status'], 'withdrew')
def test_no_illegal_withdraw_(self):
"""
Test that a user cannot withdraw someone else
"""
task = TaskFactory.create(people_needed=2, time_needed=8)
task.author = BlueBottleUserFactory.create()
task.save()
another_user = BlueBottleUserFactory.create()
task_member = TaskMemberFactory.create(member=another_user, task=task)
self.assertEquals(task.members.count(), 1)
self.visit_path('/tasks/{0}'.format(task.id))
self.assertFalse(self.scroll_to_and_click_by_css('.withdraw'))
def test_withdraw_task_member(self):
task = TaskFactory.create()
task_member = TaskMemberFactory.create(member=self.some_user, task=task)
self.assertEquals(task.people_applied, 1)
response = self.client.put(
'{0}{1}'.format(self.task_members_url, task_member.id),
{
'status': 'withdrew',
'task': task.id
},
token=self.some_token)
self.assertEquals(task.people_applied, 0)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
def test_member_applied_to_task_mail(self):
"""
Test emails for realized task with a task member
"""
self.task.status = "in progress"
self.assertEquals(len(mail.outbox), 0)
self.task.save()
self.task_member = TaskMemberFactory.create(task=self.task,
status='applied')
# Task owner receives email about new task member
self.assertEquals(len(mail.outbox), 1)
self.assertNotEquals(mail.outbox[0].body.find("applied for your task"),
-1)
self.assertEquals(mail.outbox[0].to[0], self.task.author.email)
self.task_member.status = 'accepted'
self.task_member.save()
# Task member receives email that he is accepted
self.assertEquals(len(mail.outbox), 2)
self.assertNotEquals(mail.outbox[1].subject.find("assigned"), -1)
self.assertEquals(mail.outbox[1].to[0], self.task_member.member.email)
def test_people_registered_not_accepted(self):
TaskMemberFactory.create(member=self.user,
status='open',
task=self.task)
self.assertEqual(self.project.people_registered, 0)
