def test_expired_sourcing(self):
""" A crowdsourcing project should never get a payout status """
TaskFactory.create(project=self.expired_project, status='realized')
self.expired_project.amount_asked = 0
self.expired_project.save()
self.assertEqual(self.expired_project.payout_status, None)
self.assertEqual(self.expired_project.status, self.complete)
def test_task_search_by_status(self):
"""
Ensure we can filter task list by status
"""
TaskFactory.create(
status=Task.TaskStatuses.in_progress,
author=self.some_project.owner,
project=self.some_project,
)
TaskFactory.create(
status=Task.TaskStatuses.open,
author=self.another_project.owner,
project=self.another_project,
)
self.assertEqual(3, Task.objects.count())
# Test as a different user
response = self.client.get(self.task_url, {'status': 'open'},
token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data['count'], 2)
response = self.client.get(self.task_url, {'status': 'in progress'},
token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data['count'], 1)
def test_some_tasks_realised(self):
TaskFactory.create(project=self.project, status=Task.TaskStatuses.in_progress)
self.task.status = Task.TaskStatuses.realized
self.task.save()
self.assertEqual(self.task.status, Task.TaskStatuses.realized)
self.assertEqual(self.project.status.slug, 'campaign')
def test_search_for_date_range(self):
"""
Search tasks for a date range. Return ongoing and event tasks
with deadline in range
"""
ongoing_task_4 = TaskFactory.create(status='open',
type='ongoing',
deadline=self.now +
timezone.timedelta(days=365),
people_needed=1)
TaskFactory.create(status='open',
type='event',
deadline=self.now + timezone.timedelta(days=365),
people_needed=1)
search_date = {
'start': str((self.tomorrow + timezone.timedelta(days=3)).date()),
'end': str((self.month + timezone.timedelta(days=15)).date())
}
response = self.client.get(self.task_url, search_date,
token=self.some_token)
# Search should return event_task_2, ongoing_task_1, and ongoing_task_3
ids = [self.event_task_2.id, self.ongoing_task_1.id,
self.ongoing_task_3.id, ongoing_task_4.id]
self.assertEqual(response.data['count'], 4)
self.assertTrue(response.data['results'][0]['id'] in ids)
self.assertTrue(response.data['results'][1]['id'] in ids)
self.assertTrue(response.data['results'][2]['id'] in ids)
self.assertTrue(response.data['results'][3]['id'] in ids)
def test_task_search_by_status(self):
"""
Ensure we can filter task list by status
"""
self.task1 = TaskFactory.create(
status=BB_TASK_MODEL.TaskStatuses.in_progress,
author=self.some_project.owner,
project=self.some_project,
)
self.task2 = TaskFactory.create(
status=BB_TASK_MODEL.TaskStatuses.open,
author=self.another_project.owner,
project=self.another_project,
)
self.assertEqual(2, BB_TASK_MODEL.objects.count())
# Test as a different user
response = self.client.get(self.task_url, {'status': 'open'}, token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data['count'], 1)
response = self.client.get(self.task_url, {'status': 'in progress'}, token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data['count'], 1)
def setUp(self):
super(TestTaskSurveyAggregation, self).setUp()
self.init_projects()
self.project = ProjectFactory.create()
self.task1 = TaskFactory.create(project=self.project)
self.task2 = TaskFactory.create(project=self.project)
self.task3 = TaskFactory.create(project=self.project)
self.survey = SurveyFactory(title='test survey')
self.project_response = ResponseFactory.create(
project=self.project,
survey=self.survey
)
self.task_response1 = ResponseFactory.create(
project=self.project,
task=self.task1,
survey=self.survey
)
self.task_response2 = ResponseFactory.create(
project=self.project,
task=self.task2,
survey=self.survey
)
self.task_response3 = ResponseFactory.create(
project=self.project,
task=self.task3,
survey=self.survey
)
def test_sourcing_tasks_incomplete_in_progress(self):
self.project.amount_asked = 0 # makes it sourcing
TaskFactory.create(project=self.project,
status=TASK_MODEL.TaskStatuses.in_progress)
self.project.deadline_reached()
self.assertEquals(self.project.status, self.incomplete)
def setUp(self):
super(TestTaskSurveyAggregation, self).setUp()
self.init_projects()
self.project = ProjectFactory.create()
self.task1 = TaskFactory.create(project=self.project)
self.task2 = TaskFactory.create(project=self.project)
self.task3 = TaskFactory.create(project=self.project)
self.survey = SurveyFactory(title='test survey')
self.project_response = ResponseFactory.create(
project=self.project,
survey=self.survey
)
self.task_response1 = ResponseFactory.create(
project=self.project,
task=self.task1,
survey=self.survey
)
self.task_response2 = ResponseFactory.create(
project=self.project,
task=self.task2,
survey=self.survey
)
self.task_response3 = ResponseFactory.create(
project=self.project,
task=self.task3,
survey=self.survey
)
def test_some_tasks_realised(self):
TaskFactory.create(project=self.project, status=Task.TaskStatuses.in_progress)
self.task.status = Task.TaskStatuses.realized
self.task.save()
self.assertEqual(self.task.status, Task.TaskStatuses.realized)
self.assertEqual(self.project.status.slug, 'campaign')
def test_search_for_date_range(self):
"""
Search tasks for a date range. Return ongoing and event tasks
with deadline in range
"""
ongoing_task_4 = TaskFactory.create(status='open',
type='ongoing',
deadline=self.now +
timezone.timedelta(days=365),
people_needed=1)
TaskFactory.create(status='open',
type='event',
deadline=self.now + timezone.timedelta(days=365),
people_needed=1)
search_date = {
'start': str((self.tomorrow + timezone.timedelta(days=3)).date()),
'end': str((self.month + timezone.timedelta(days=15)).date())
}
response = self.client.get(self.task_url,
search_date,
token=self.some_token)
# Search should return event_task_2, ongoing_task_1, and ongoing_task_3
ids = [
self.event_task_2.id, self.ongoing_task_1.id,
self.ongoing_task_3.id, ongoing_task_4.id
]
self.assertEqual(response.data['count'], 4)
self.assertTrue(response.data['results'][0]['id'] in ids)
self.assertTrue(response.data['results'][1]['id'] in ids)
self.assertTrue(response.data['results'][2]['id'] in ids)
self.assertTrue(response.data['results'][3]['id'] in ids)
def test_sourcing_tasks_complete(self):
""" one remaining open task """
self.project.amount_asked = 0 # makes it sourcing
TaskFactory.create(project=self.project,
status=Task.TaskStatuses.realized)
self.project.deadline_reached()
self.assertEquals(self.project.status, self.complete)
def test_sourcing_tasks_incomplete_in_progress(self):
self.project.amount_asked = 0 # makes it sourcing
TaskFactory.create(project=self.project,
status=Task.TaskStatuses.in_progress)
self.project.deadline_reached()
self.assertEquals(self.project.status, self.incomplete)
self.assertEquals(self.project.payout_status, None)
def test_sourcing_tasks_incomplete_open(self):
""" on remaining in progress task """
self.project.amount_asked = 0 # makes it sourcing
TaskFactory.create(project=self.project,
status=TASK_MODEL.TaskStatuses.open)
self.project.deadline_reached()
self.assertEquals(self.project.status, self.incomplete)
def test_sourcing_tasks_complete(self):
""" one remaining open task """
self.project.amount_asked = 0 # makes it sourcing
TaskFactory.create(project=self.project,
status=TASK_MODEL.TaskStatuses.realized)
self.project.deadline_reached()
self.assertEquals(self.project.status, self.complete)
def status_response(self, url):
self.task1.delete()
task1 = TaskFactory.create(
status=Task.TaskStatuses.open,
author=self.some_project.owner,
project=self.some_project,
people_needed=2
)
task2 = TaskFactory.create(
status=Task.TaskStatuses.closed,
author=self.some_project.owner,
project=self.some_project,
people_needed=2
)
task3 = TaskFactory.create(
status=Task.TaskStatuses.realized,
author=self.some_project.owner,
project=self.some_project,
people_needed=2
)
task4 = TaskFactory.create(
status=Task.TaskStatuses.in_progress,
author=self.some_project.owner,
project=self.some_project,
people_needed=2
)
response = self.client.get(url,
{'status': 'open'},
HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], task1.id)
response = self.client.get(url,
{'status': 'closed'},
HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], task2.id)
response = self.client.get(url,
{'status': 'realized'},
HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], task3.id)
response = self.client.get(url,
{'status': 'in progress'},
HTTP_AUTHORIZATION=self.some_token)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], task4.id)
def test_theme_translated(self, queue_mock):
theme = ProjectThemeFactory.create(name='Cleaning the beach',
slug='cleaning-the-beach')
project = ProjectFactory.create(theme=theme)
user = BlueBottleUserFactory.create()
TaskFactory.create(author=user, project=project)
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags']['theme'], 'Cleaning the park')
def test_funding_tasks_incomplete(self):
""" a funding project with incomplete tasks is still complete """
self.project.amount_asked = 100
self.pay(self.project, 100)
self.project.save()
TaskFactory.create(project=self.project, status=TASK_MODEL.TaskStatuses.open)
self.project.deadline_reached()
self.assertEquals(self.project.status, self.complete)
def test_funding_tasks_incomplete(self):
""" a funding project with incomplete tasks is still complete """
self.project.amount_asked = 100
self.pay(self.project, 100)
self.project.save()
TaskFactory.create(project=self.project, status=Task.TaskStatuses.open)
self.project.deadline_reached()
self.assertEquals(self.project.status, self.complete)
self.assertEquals(self.project.payout_status, 'needs_approval')
def test_bulk_status_change(self, queue_mock):
for i in range(10):
TaskFactory.create()
previous_call_count = queue_mock.call_count
Task.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_related_permissions_no_owner_permission(self):
TaskFactory.create(project=self.some_project)
authenticated = Group.objects.get(name='Authenticated')
authenticated.permissions.remove(
Permission.objects.get(codename='api_add_own_taskmember'))
authenticated.permissions.remove(
Permission.objects.get(codename='api_add_taskmember'))
response = self.client.get(self.tasks_url, token=self.user_token)
self.assertFalse(response.data['results'][0]['related_permissions']
['task_members']['POST'])
def test_bulk_status_change(self, queue_mock):
for i in range(10):
TaskFactory.create()
previous_call_count = queue_mock.call_count
Task.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_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_no_mail_no_campaign_notifications(self):
"""
Test that users who have campaign_notifications turned off don't get email
"""
task_owner1 = BlueBottleUserFactory.create(campaign_notifications=False)
TaskFactory.create(
author=task_owner1,
project=self.project
)
# Add extra project and owner that should not get any email
project_owner = BlueBottleUserFactory.create(campaign_notifications=False)
ProjectFactory(owner=project_owner, status=self.phase1)
# Create a follower by donating
donator1 = BlueBottleUserFactory.create(campaign_notifications=False)
order = OrderFactory.create(user=donator1,
status=StatusDefinition.CREATED)
DonationFactory(order=order, amount=35,
project=self.project,
fundraiser=None)
order.locked()
order.success()
order.save()
# Create a follower by being a fundraiser for the project
fundraiser_person = BlueBottleUserFactory.create(campaign_notifications=False)
FundraiserFactory(project=self.project,
owner=fundraiser_person)
self.assertEqual(Follow.objects.count(), 3)
# Create follower by voting
voter_person = BlueBottleUserFactory.create(
campaign_notifications=False)
VoteFactory(voter=voter_person, project=self.project)
# Project owner creates a wallpost and emails followers
TextWallpostFactory.create(
content_object=self.project, author=self.project.owner,
text="test2", email_followers=True)
mail_count = 0
# People who should get an email: self.some_user, task_owner1,
# fundraiser_person, commenter, voter and donator1
for email in mail.outbox:
if "New wallpost on" in email.subject:
mail_count += 1
self.assertEqual(mail_count, 0)
def test_search_event_correct_timezone_awareness(self):
"""
Test that the search for an event yields the correct
tasks, given a task with a tricky timezone.
"""
task = TaskFactory.create(status='open',
type='event',
title='task',
deadline=self.now +
timezone.timedelta(days=3),
people_needed=1)
task.save()
task2 = TaskFactory.create(
status='open',
title='task2',
type='event',
deadline=self.now +
timezone.timedelta(days=1, hours=23, minutes=59),
people_needed=1)
task2.save()
task3 = TaskFactory.create(
status='open',
title='task3',
type='event',
deadline=self.now + timezone.timedelta(days=4, hours=4, minutes=0),
people_needed=1)
task3.save()
search_date = {
'start': str(task.deadline.date()),
'end': str(task.deadline.date())
}
response = self.client.get(self.task_url,
search_date,
token=self.some_token)
# Search should return task, ongoing_task_1, and ongoing_task_3
# Task2 and Task3 should NOT be returned
ids = [task.id, self.ongoing_task_1.id, self.ongoing_task_3.id]
self.assertEqual(response.data['count'], 3)
self.assertIn(response.data['results'][0]['id'], ids)
self.assertIn(response.data['results'][1]['id'], ids)
self.assertIn(response.data['results'][2]['id'], ids)
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 setUp(self):
super(TestProjectPeopleCount, self).setUp()
self.init_projects()
self.project = ProjectFactory.create(title='test', amount_asked=100)
self.project.status = ProjectPhase.objects.get(slug='campaign')
self.project.save()
self.user = BlueBottleUserFactory.create()
self.another_user = BlueBottleUserFactory.create()
self.task = TaskFactory.create(
project=self.project, people_needed=10, status='open')
self.other_task = TaskFactory.create(
project=self.project, people_needed=10, status='open')
def test_no_mail_no_campaign_notifications(self):
""" Test that users who have campaign_notifications turned off don't get email """
task_owner1 = BlueBottleUserFactory.create(campaign_notifications=False)
task = TaskFactory.create(
author=task_owner1,
project=self.project
)
# Add extra project and owner that should not get any email
project_owner = BlueBottleUserFactory.create(campaign_notifications=False)
project2 = ProjectFactory(owner=project_owner, status=self.phase1)
# Create a follower by donating
donator1 = BlueBottleUserFactory.create(campaign_notifications=False)
order = OrderFactory.create(user=donator1, status=StatusDefinition.CREATED)
donation = DonationFactory(order=order, amount=35, project=self.project, fundraiser=None)
# Create a follower by being a fundraiser for the project
fundraiser_person = BlueBottleUserFactory.create(campaign_notifications=False)
fundraiser = FundraiserFactory(project=self.project, owner=fundraiser_person)
self.assertEqual(Follow.objects.count(), 3)
# Project owner creates a wallpost and emails followers
some_wallpost_2 = TextWallpostFactory.create(content_object=self.project, author=self.project.owner, text="test2", email_followers=True)
mail_count = 0
# People who should get an email: self.some_user, task_owner1, fundraiser_person, commenter, and donator1
receivers = []
for email in mail.outbox:
if "New wallpost on" in email.subject:
mail_count += 1
self.assertEqual(mail_count, 0)
def test_wallpost_no_mail(self):
""" Test that followers don't get an email if email_followers is false. Email_followers boolean is false by default on wallpost model"""
self.assertEqual(len(mail.outbox), 0)
self.assertEqual(Follow.objects.count(), 0)
commenter = BlueBottleUserFactory.create()
commenter2 = BlueBottleUserFactory.create()
# Create follower by creating a donation
order = OrderFactory.create(user=self.another_user, status=StatusDefinition.CREATED)
# Make sure to set Fundraiser to None. Otherwise, a fundraiser is created
donation = DonationFactory(order=order, amount=35, project=self.project, fundraiser=None)
# Create follower by creating a task owner
task_owner1 = BlueBottleUserFactory.create()
task = TaskFactory.create(
author=task_owner1,
project=self.project
)
# Verify we have two followers
self.assertEqual(Follow.objects.count(), 2)
# Create a text Wallpost for our dummy project
some_wallpost = TextWallpostFactory.create(content_object=self.project, author=self.project.owner, text="test1", email_followers=False)
self.assertEqual(Follow.objects.count(), 2)
# Some other emails are sent, so we do not compare the mail count. Instead we look at the subject
for email in mail.outbox:
self.assertTrue("New wallpost on" not in email.subject)
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 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(TaskApiIntegrationTests, self).setUp()
self.init_projects()
campaign = ProjectPhase.objects.get(slug='campaign')
self.some_user = BlueBottleUserFactory.create()
self.some_token = "JWT {0}".format(self.some_user.get_jwt_token())
self.some_project = ProjectFactory.create(owner=self.some_user,
status=campaign)
self.another_user = BlueBottleUserFactory.create()
self.another_token = "JWT {0}".format(
self.another_user.get_jwt_token())
self.another_project = ProjectFactory.create(owner=self.another_user)
self.task = TaskFactory.create(project=self.some_project)
self.skill1 = SkillFactory.create()
self.skill2 = SkillFactory.create()
self.skill3 = SkillFactory.create()
self.skill4 = SkillFactory.create()
self.task_url = reverse('task-list')
self.task_preview_url = reverse('task_preview_list')
self.task_members_url = reverse('task-member-list')
self.task_detail_url = reverse('task_detail', args=(self.task.pk, ))
def setUp(self):
super(TestTaskMails, self).setUp()
self.init_projects()
self.status_running = ProjectPhase.objects.get(slug='campaign')
self.project = ProjectFactory.create(status=self.status_running)
self.task = TaskFactory.create(project=self.project)
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 test_task_member_resume(self):
task = TaskFactory.create(status=Task.TaskStatuses.open,
author=self.some_user,
project=self.some_project,
people_needed=4,
time_needed=8)
resume_file = open('./bluebottle/projects/test_images/upload.png',
mode='rb')
task_member_data = {
'task': task.id,
'resume': resume_file,
'motivation': 'Pick me!'
}
response = self.client.post(self.task_member_url,
task_member_data,
token=self.another_token,
format='multipart')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
resume = response.data['resume']
self.assertTrue(
resume['url'].startswith('/downloads/taskmember/resume'))
self.assertTrue(resume['name'].startswith('upload'))
task_member = TaskMember.objects.get(pk=response.data['id'])
self.assertTrue(task_member.resume.name.startswith('private'))
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 setUp(self):
from bluebottle.bb_projects.models import ProjectPhase, ProjectTheme
super(WallpostMailTests, self).setUp()
self.init_projects()
self.user_a = self.create_user(email='*****@*****.**',
first_name='aname ',
last_name='alast',
primary_language='fr')
self.user_b = self.create_user(email='*****@*****.**',
first_name='bname ',
last_name='blast',
primary_language='nl')
self.user_c = self.create_user(email='*****@*****.**',
first_name='cname ',
last_name='clast',
primary_language='en')
self.user_d = self.create_user(email='*****@*****.**',
first_name='dname ',
last_name='dlast',
primary_language='en')
# self.project = self.create_project(owner=self.user_a)
self.theme_1 = ProjectTheme.objects.get(translations__name='Education')
self.phase_1 = ProjectPhase.objects.get(slug='campaign')
self.project_1 = ProjectFactory.create(owner=self.user_a,
status=self.phase_1,
theme=self.theme_1)
self.task_1 = TaskFactory(author=self.user_a, project=self.project_1)
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 setUp(self):
super(TaskApiTestcase, self).setUp()
self.init_projects()
self.some_user = BlueBottleUserFactory.create()
self.some_token = "JWT {0}".format(self.some_user.get_jwt_token())
campaign_status = ProjectPhase.objects.get(slug='campaign')
self.some_project = ProjectFactory.create(owner=self.some_user,
status=campaign_status)
self.task1 = TaskFactory.create(
status=Task.TaskStatuses.open,
author=self.some_project.owner,
project=self.some_project,
people_needed=2
)
self.another_user = BlueBottleUserFactory.create()
self.another_token = "JWT {0}".format(self.another_user.get_jwt_token())
self.yet_another_user = BlueBottleUserFactory.create()
self.yet_another_token = "JWT {0}".format(
self.yet_another_user.get_jwt_token())
self.previews_url = reverse('project_preview_list')
self.task_preview_url = reverse('task_preview_list')
self.tasks_url = reverse('task_list')
self.task_member_url = reverse('task_member_list')
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_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 setUp(self):
super(TaskMailTestBase, self).setUp()
self.init_projects()
self.status_running = ProjectPhase.objects.get(slug='campaign')
self.project = ProjectFactory.create(status=self.status_running)
self.task = TaskFactory.create(project=self.project, deadline=now() + timedelta(days=2))
def test_search_for_specific_date_with_event_task(self):
"""
Search for tasks taking place on a specific date
when there is an event-type task.
"""
later = self.now + timezone.timedelta(days=3)
event_task_3 = TaskFactory.create(
status='open',
type='event',
project=ProjectFactory(deadline=later),
deadline=later,
people_needed=1)
search_date = {'start': str(later)}
response = self.client.get(self.task_url,
search_date,
token=self.some_token)
# The result should include ongoing_task_1, ongoing_task_3 and
# event_task_3 because its on the deadline date
ids = [self.ongoing_task_1.id, self.ongoing_task_3.id, event_task_3.id]
self.assertEquals(response.data['count'], 3)
self.assertIn(response.data['results'][0]['id'], ids)
self.assertIn(response.data['results'][1]['id'], ids)
self.assertIn(response.data['results'][2]['id'], ids)
def setUp(self):
super(TaskApiTestcase, self).setUp()
self.init_projects()
self.some_user = BlueBottleUserFactory.create()
self.some_token = "JWT {0}".format(self.some_user.get_jwt_token())
campaign_status = ProjectPhase.objects.get(slug='campaign')
self.some_project = ProjectFactory.create(owner=self.some_user,
status=campaign_status)
self.task1 = TaskFactory.create(status=Task.TaskStatuses.open,
author=self.some_project.owner,
project=self.some_project,
people_needed=2)
self.another_user = BlueBottleUserFactory.create()
self.another_token = "JWT {0}".format(
self.another_user.get_jwt_token())
self.yet_another_user = BlueBottleUserFactory.create()
self.yet_another_token = "JWT {0}".format(
self.yet_another_user.get_jwt_token())
self.previews_url = reverse('project_preview_list')
self.task_preview_url = reverse('task_preview_list')
self.tasks_url = reverse('task-list')
self.task_member_url = reverse('task-member-list')
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_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_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_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 = TaskFactory.create(status='open', people_needed=4)
task.save()
log = TaskStatusLog.objects.first()
self.assertEqual(TaskStatusLog.objects.count(), 1)
self.assertEqual(log.status, 'open')
self.assertEqual(log.task_id, task.id)
def test_task_status_log_creation(self):
task = TaskFactory.create(status='open', people_needed=4)
task.save()
log = TaskStatusLog.objects.first()
self.assertEqual(TaskStatusLog.objects.count(), 1)
self.assertEqual(log.status, 'open')
self.assertEqual(log.task_id, task.id)
def test_task_preview_search(self):
# create project phases
phase1 = ProjectPhaseFactory.create(viewable=True)
phase2 = ProjectPhaseFactory.create(viewable=False)
self.some_project.status = phase1
self.some_project.save()
self.another_project.status = phase2
self.another_project.save()
# create tasks for projects
self.task1 = TaskFactory.create(
status=BB_TASK_MODEL.TaskStatuses.in_progress,
author=self.some_project.owner,
project=self.some_project,
)
self.task2 = TaskFactory.create(
status=BB_TASK_MODEL.TaskStatuses.open,
author=self.another_project.owner,
project=self.another_project,
)
self.assertEqual(2, BB_PROJECT_MODEL.objects.count())
self.assertEqual(2, BB_TASK_MODEL.objects.count())
api_url = self.task_url + 'previews/'
# test that only one task preview is returned
response = self.client.get(api_url, token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data['count'], 1)
response = self.client.get(api_url, {'status': 'in progress'}, token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data['count'], 1)
response = self.client.get(api_url, {'status': 'open'}, token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data['count'], 0)
skill = self.task1.skill
response = self.client.get(api_url, {'skill': skill.id}, token=self.some_token)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], self.task1.id)
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 setUp(self):
super(TaskUnitTestBase, self).setUp()
self.init_projects()
self.status_running = ProjectPhase.objects.get(slug='campaign')
self.project = ProjectFactory.create(status=self.status_running, amount_asked=0)
self.task = TaskFactory.create(
project=self.project,
)
def test_theme_translated(self, queue_mock):
theme = ProjectThemeFactory.create(name='Cleaning the beach',
slug='cleaning-the-beach')
project = ProjectFactory.create(theme=theme)
user = BlueBottleUserFactory.create()
task = TaskFactory.create(author=user, project=project)
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags']['theme'], 'Cleaning the park')
def setUp(self):
"""Setup reusable data."""
self.init_projects()
self.now = datetime.combine(timezone.now(), datetime.max.time())
self.now = timezone.get_current_timezone().localize(self.now)
self.tomorrow = self.now + timezone.timedelta(days=1)
self.week = self.now + timezone.timedelta(days=7)
self.month = self.now + timezone.timedelta(days=30)
self.some_user = BlueBottleUserFactory.create()
self.some_token = "JWT {0}".format(self.some_user.get_jwt_token())
self.task_url = '/api/bb_tasks/'
self.event_task_1 = TaskFactory.create(status='open',
title='event_task_1',
type='event',
deadline=self.tomorrow,
people_needed=1)
self.event_task_2 = TaskFactory.create(status='open',
title='event_task_2',
type='event',
deadline=self.month,
people_needed=1)
self.ongoing_task_1 = TaskFactory.create(status='open',
title='ongoing_task_1',
type='ongoing',
deadline=self.week,
people_needed=1)
self.ongoing_task_2 = TaskFactory.create(status='open',
title='ongoing_task_2',
type='ongoing',
deadline=self.tomorrow,
people_needed=1)
self.ongoing_task_3 = TaskFactory.create(status='open',
title='ongoing_task_3',
type='ongoing',
deadline=self.month,
people_needed=1)
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 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_search_event_correct_timezone_awareness(self):
"""
Test that the search for an event yields the correct
tasks, given a task with a tricky timezone.
"""
task = TaskFactory.create(status='open',
type='event',
title='task',
deadline=self.now + timezone.timedelta(days=3),
people_needed=1)
task.save()
task2 = TaskFactory.create(status='open',
title='task2',
type='event',
deadline=self.now + timezone.timedelta(days=1, hours=23, minutes=59),
people_needed=1)
task2.save()
task3 = TaskFactory.create(status='open',
title='task3',
type='event',
deadline=self.now + timezone.timedelta(days=4, hours=4, minutes=0),
people_needed=1)
task3.save()
search_date = {
'start': str(task.deadline.date()),
'end': str(task.deadline.date())
}
response = self.client.get(self.task_url, search_date,
token=self.some_token)
# Search should return task, ongoing_task_1, and ongoing_task_3
# Task2 and Task3 should NOT be returned
ids = [task.id, self.ongoing_task_1.id, self.ongoing_task_3.id]
self.assertEqual(response.data['count'], 3)
self.assertIn(response.data['results'][0]['id'], ids)
self.assertIn(response.data['results'][1]['id'], ids)
self.assertIn(response.data['results'][2]['id'], ids)
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_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)
