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_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_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, 1)
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): 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 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_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_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_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_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.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_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_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_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 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_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_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 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_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_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_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_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_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_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_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_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_all_tasks_realised_closed_project(self): member = TaskMemberFactory.create( task=self.task, status='accepted', time_spent=4 ) member.status = TaskMember.TaskMemberStatuses.absent member.save() self.assertEqual(member.time_spent, 0)
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 test_event_running_accepted_running_after_deadline_to_apply(self): task = TaskFactory.create(status='open', people_needed=2, type='event') TaskMemberFactory.create(task=task, status='accepted', externals=2) task.deadline_to_apply = timezone.now() - timedelta(days=1) task.deadline_to_apply_reached() self.assertEqual(task.status, 'full') 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 has been set to 'full'" in email.body) self.assertTrue("Leave a message" in email.body)
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_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)
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_task_stats_user_both_owner_and_member(self): # 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.some_user, status='realized') self.assertEqual(self.stats.tasks_realized, 1) self.assertEqual(self.stats.task_members, 1) self.assertEqual(self.stats.time_spent, 4) # People involved: # - campaigner as both owner and member self.assertEqual(self.stats.people_involved, 1) self.assertEqual(self.stats.people_involved, 1)
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_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_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_rejected_member(self): task = TaskFactory.create(status='open', people_needed=2, type='event') member = TaskMemberFactory.create(task=task, status='accepted', externals=1) self.assertEqual(task.status, 'full') member.status = 'rejected' member.save() self.assertEqual(task.status, 'open')
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)