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