Exemple #1
0
    def test_generate_report(self):
        """ Uses shifts s1, s2 and volunteer v1
        Tests test_generate_report(volunteer_shift_list) """

        # register will return an exception on error
        # (such as when invalid parameters are passed)
        # if an exception does get raised, this test will automatically fail
        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        register(self.v1.id, self.s1.id)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift_1 = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                       shift_id=self.s1.id)
        self.assertIsNotNone(volunteer_shift_1)

        register(self.v1.id, self.s2.id)
        add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
        volunteer_shift_2 = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                       shift_id=self.s2.id)
        self.assertIsNotNone(volunteer_shift_2)

        volunteer_shift_list = [volunteer_shift_1, volunteer_shift_2]

        reports = generate_report(volunteer_shift_list)
        self.assertEqual(len(reports), 2)
        self.assertIsNotNone(reports)
Exemple #2
0
    def test_generate_report(self):
        """ Uses shifts s1, s2 and volunteer v1
        Tests test_generate_report(volunteer_shift_list) """

        # register will return an exception on error
        # (such as when invalid parameters are passed)
        # if an exception does get raised, this test will automatically fail
        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        register(self.v1.id, self.s1.id)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift_1 = VolunteerShift.objects.get(
            volunteer_id=self.v1.id, shift_id=self.s1.id)
        self.assertIsNotNone(volunteer_shift_1)

        register(self.v1.id, self.s2.id)
        add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
        volunteer_shift_2 = VolunteerShift.objects.get(
            volunteer_id=self.v1.id, shift_id=self.s2.id)
        self.assertIsNotNone(volunteer_shift_2)

        volunteer_shift_list = [volunteer_shift_1, volunteer_shift_2]

        reports = generate_report(volunteer_shift_list)
        self.assertEqual(len(reports), 2)
        self.assertIsNotNone(reports)
    def test_get_administrator_report(self):

        register(self.v1.id, self.s1.id)
        register(self.v2.id, self.s3.id)

        start_time = datetime.time(hour=11, minute=0)
        end_time = datetime.time(hour=12, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        add_shift_hours(self.v2.id, self.s3.id, start_time, end_time)

        report_1 = get_administrator_report(self.v1.first_name, "", "",
                                            self.e1.name, self.j1.name,
                                            "2012-10-22", "2012-10-30")
        report_2 = get_administrator_report(self.v1.first_name, "", "",
                                            self.e1.name, self.j2.name,
                                            "2012-9-1", "2012-10-26")
        report_3 = get_administrator_report("", "", "", self.e1.name,
                                            self.j2.name, "", "")

        # verify that report for logged shift appears
        self.assertEqual(len(report_1), 1)
        self.assertEqual(len(report_2), 0)
        self.assertEqual(len(report_3), 1)
        self.assertEqual(self.v1.first_name, report_1[0]["first_name"])
        self.assertEqual(self.v2.first_name, report_3[0]["first_name"])
Exemple #4
0
    def test_get_volunteer_report(self):

        # register volunteer for 2 shifts, log hours for one
        register(self.v1.id, self.s1.id)
        register(self.v1.id, self.s3.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        volunteer_shift_list_1 = get_volunteer_shifts(self.v1.id, self.e1.name,
                                                      self.j1.name,
                                                      "2012-10-22",
                                                      "2012-10-30")
        report_1 = generate_report(volunteer_shift_list_1)

        volunteer_shift_list_2 = get_volunteer_shifts(self.v1.id, self.e1.name,
                                                      self.j2.name, "2012-9-1",
                                                      "2012-10-26")
        report_2 = generate_report(volunteer_shift_list_2)

        # verify that report for logged shift appears
        self.assertEqual(len(report_1), 1)
        self.assertEqual(len(report_2), 0)
        self.assertEqual(self.e1.name, report_1[0]["event_name"])
        self.assertEqual(self.j1.name, report_1[0]["job_name"])
    def test_get_all_volunteer_shifts_with_hours(self):
        #  Test get_all_volunteer_shifts_with_hours()
        register(self.v1.id, self.s1.id)
        register(self.v2.id, self.s2.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)

        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        hours_list = get_all_volunteer_shifts_with_hours()

        self.assertEqual(len(hours_list), 1)
        self.assertEqual(self.v1.id, hours_list[0].volunteer_id)
        self.assertEqual(self.s1.id, hours_list[0].shift_id)

        self.assertIsNotNone(get_all_volunteer_shifts_with_hours())
    def test_get_all_volunteer_shifts_with_hours(self):
        #  Test get_all_volunteer_shifts_with_hours() 
        register(self.v1.id, self.s1.id)
        register(self.v2.id, self.s2.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)

        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        hours_list = get_all_volunteer_shifts_with_hours()

        self.assertEqual(len(hours_list), 1)
        self.assertEqual(self.v1.id, hours_list[0].volunteer_id)
        self.assertEqual(self.s1.id, hours_list[0].shift_id)

        self.assertIsNotNone(get_all_volunteer_shifts_with_hours())
    def test_get_volunteer_report(self):

        # register volunteer for 2 shifts, log hours for one
        register(self.v1.id, self.s1.id)
        register(self.v1.id, self.s3.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        report_1 = get_volunteer_report(self.v1.id, self.e1.name, self.j1.name, "2012-10-22", "2012-10-30")
        report_2 = get_volunteer_report(self.v1.id, self.e1.name, self.j2.name, "2012-9-1", "2012-10-26")

        # verify that report for logged shift appears
        self.assertEqual(len(report_1), 1)
        self.assertEqual(len(report_2), 0)
        self.assertEqual(self.e1.name, report_1[0]["event_name"])
        self.assertEqual(self.j1.name, report_1[0]["job_name"])
Exemple #8
0
    def form_valid(self, form):
        shift_id = self.kwargs['shift_id']
        volunteer_id = self.kwargs['volunteer_id']
        shift = get_shift_by_id(shift_id)
        start_time = form.cleaned_data['start_time']
        end_time = form.cleaned_data['end_time']
        shift_start_time = shift.start_time
        shift_end_time = shift.end_time
        try:
            if (end_time > start_time):
                if (start_time >= shift_start_time
                        and end_time <= shift_end_time):
                    add_shift_hours(volunteer_id, shift_id, start_time,
                                    end_time)
                    return HttpResponseRedirect(
                        reverse(
                            'shift:manage_volunteer_shifts',
                            args=(volunteer_id, )))
                else:
                    messages.add_message(
                        self.request, messages.INFO,
                        'Logged hours should be between shift hours')
                    return render(
                        self.request, 'shift/add_hours_manager.html', {
                            'form': form,
                            'shift_id': shift_id,
                            'volunteer_id': volunteer_id,
                            'shift': shift,
                        })

            else:
                messages.add_message(
                    self.request, messages.INFO,
                    'End time should be greater than start time')
                return render(
                    self.request, 'shift/add_hours_manager.html', {
                        'form': form,
                        'shift_id': shift_id,
                        'volunteer_id': volunteer_id,
                        'shift': shift,
                    })
        except:
            raise Http404
Exemple #9
0
    def form_valid(self, form):
        shift_id = self.kwargs['shift_id']
        volunteer_id = self.kwargs['volunteer_id']
        shift = get_shift_by_id(shift_id)
        start_time = form.cleaned_data['start_time']
        end_time = form.cleaned_data['end_time']
        shift_start_time = shift.start_time
        shift_end_time = shift.end_time
        try:
            if end_time > start_time:
                if (start_time >= shift_start_time
                        and end_time <= shift_end_time):
                    add_shift_hours(volunteer_id, shift_id, start_time,
                                    end_time)
                    return HttpResponseRedirect(
                        reverse('shift:manage_volunteer_shifts',
                                args=(volunteer_id, )))
                else:
                    messages.add_message(
                        self.request, messages.INFO,
                        'Logged hours should be between shift hours')
                    return render(
                        self.request, 'shift/add_hours_manager.html', {
                            'form': form,
                            'shift_id': shift_id,
                            'volunteer_id': volunteer_id,
                            'shift': shift,
                        })

            else:
                messages.add_message(
                    self.request, messages.INFO,
                    'End time should be greater than start time')
                return render(
                    self.request, 'shift/add_hours_manager.html', {
                        'form': form,
                        'shift_id': shift_id,
                        'volunteer_id': volunteer_id,
                        'shift': shift,
                    })
        except:
            raise Http404
    def test_get_unlogged_shifts_by_volunteer_id(self):
        """ Uses shifts s1, s2 and volunteer v1 """

        # sign up
        register(self.v1.id, self.s1.id)
        register(self.v1.id, self.s2.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)

        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        # test typical case
        shift_list = get_unlogged_shifts_by_volunteer_id(self.v1.id)
        self.assertIsNotNone(shift_list)
        self.assertNotEqual(shift_list, False)
        self.assertEqual(len(shift_list), 1)
        self.assertNotIn(self.s1, shift_list)
        self.assertIn(self.s2, shift_list)
        self.assertNotIn(self.s3, shift_list)
    def test_get_unlogged_shifts_by_volunteer_id(self):
        """ Uses shifts s1, s2 and volunteer v1 """

        # sign up
        register(self.v1.id, self.s1.id)
        register(self.v1.id, self.s2.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)

        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        # test typical case
        shift_list = get_unlogged_shifts_by_volunteer_id(self.v1.id)
        self.assertIsNotNone(shift_list)
        self.assertNotEqual(shift_list, False)
        self.assertEqual(len(shift_list), 1)
        self.assertNotIn(self.s1, shift_list)
        self.assertIn(self.s2, shift_list)
        self.assertNotIn(self.s3, shift_list)
    def test_get_administrator_report(self):

        register(self.v1.id, self.s1.id)
        register(self.v2.id, self.s3.id)

        start_time = datetime.time(hour=11, minute=0)
        end_time = datetime.time(hour=12, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        add_shift_hours(self.v2.id, self.s3.id, start_time, end_time)

        report_1 = get_administrator_report(self.v1.first_name,"","",self.e1.name,self.j1.name,"2012-10-22", "2012-10-30")
        report_2 = get_administrator_report(self.v1.first_name,"","",self.e1.name,self.j2.name,"2012-9-1", "2012-10-26")
        report_3 = get_administrator_report("","","",self.e1.name,self.j2.name,"", "")

        # verify that report for logged shift appears
        self.assertEqual(len(report_1), 1)
        self.assertEqual(len(report_2), 0)
        self.assertEqual(len(report_3), 1)
        self.assertEqual(self.v1.first_name, report_1[0]["first_name"])
        self.assertEqual(self.v2.first_name, report_3[0]["first_name"])
    def test_get_volunteer_shifts_with_hours(self):
        """ Uses volunteers v1 and v2
        Test get_volunteer_shifts_with_hours(v_id) """

        register(self.v1.id, self.s1.id)
        register(self.v1.id, self.s2.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)

        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        v1_hours = get_volunteer_shifts_with_hours(self.v1)
        v2_hours = get_volunteer_shifts_with_hours(self.v2)

        self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v1))
        self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v2))

        self.assertEqual(len(v1_hours), 1)
        self.assertEqual(self.s1.id, v1_hours[0].shift_id)
        self.assertEqual(len(v2_hours), 0)
    def test_get_volunteer_shifts_with_hours(self):
        """ Uses volunteers v1 and v2
        Test get_volunteer_shifts_with_hours(v_id) """

        register(self.v1.id, self.s1.id)
        register(self.v1.id, self.s2.id)

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)

        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        v1_hours = get_volunteer_shifts_with_hours(self.v1)
        v2_hours = get_volunteer_shifts_with_hours(self.v2)

        self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v1))
        self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v2))

        self.assertEqual(len(v1_hours), 1)
        self.assertEqual(self.s1.id, v1_hours[0].shift_id)
        self.assertEqual(len(v2_hours), 0)
    def test_get_logged_volunteers_by_shift_id(self):
        """ Uses volunteers v1,v2,v3 and shift s3 """

        # sign up
        register(self.v3.id, self.s3.id)
        register(self.v1.id, self.s3.id)
        register(self.v2.id, self.s3.id)

        start_time = datetime.time(hour=1, minute=0)
        end_time = datetime.time(hour=2, minute=0)
        add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)

        start_time = datetime.time(hour=2, minute=0)
        end_time = datetime.time(hour=3, minute=0)
        add_shift_hours(self.v3.id, self.s3.id, start_time, end_time)

        # get volunteer list
        logged_volunteer_list_for_shift = get_logged_volunteers_by_shift_id(self.s3.id)

        # test typical case and order
        self.assertEqual(len(logged_volunteer_list_for_shift), 2)
        self.assertEqual(logged_volunteer_list_for_shift[0].volunteer, self.v3)
        self.assertEqual(logged_volunteer_list_for_shift[1].volunteer, self.v1)
    def test_clear_shift_hours(self):
        """ Uses shifts s1, s2, s3 and volunteer v1 """

        register(self.v1.id, self.s1.id)
        self.assertIsNotNone(VolunteerShift.objects.get(
                                                        volunteer_id=self.v1.id,
                                                        shift_id=self.s1.id
                                                        ))

        register(self.v1.id, self.s2.id)
        self.assertIsNotNone(VolunteerShift.objects.get(
                                                        volunteer_id=self.v1.id,
                                                        shift_id=self.s2.id
                                                        ))

        register(self.v1.id, self.s3.id)
        self.assertIsNotNone(VolunteerShift.objects.get(
                                                        volunteer_id=self.v1.id,
                                                        shift_id=self.s3.id
                                                        ))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=12, minute=0)
        add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=6, minute=0)
        add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)

        clear_shift_hours(self.v1.id, self.s1.id)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s1.id
                                                    )
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)

        clear_shift_hours(self.v1.id, self.s2.id)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s2.id
                                                    )
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)

        clear_shift_hours(self.v1.id, self.s3.id)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s3.id
                                                    )
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)
    def test_get_logged_volunteers_by_shift_id(self):
        """ Uses volunteers v1,v2,v3 and shift s3 """

        # sign up
        register(self.v3.id, self.s3.id)
        register(self.v1.id, self.s3.id)
        register(self.v2.id, self.s3.id)

        start_time = datetime.time(hour=1, minute=0)
        end_time = datetime.time(hour=2, minute=0)
        add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)

        start_time = datetime.time(hour=2, minute=0)
        end_time = datetime.time(hour=3, minute=0)
        add_shift_hours(self.v3.id, self.s3.id, start_time, end_time)

        # get volunteer list
        logged_volunteer_list_for_shift = get_logged_volunteers_by_shift_id(
            self.s3.id)

        # test typical case and order
        self.assertEqual(len(logged_volunteer_list_for_shift), 2)
        self.assertEqual(logged_volunteer_list_for_shift[0].volunteer, self.v3)
        self.assertEqual(logged_volunteer_list_for_shift[1].volunteer, self.v1)
    def test_add_shift_hours(self):
        """ Uses shifts s1, s2, s3 and volunteers v1,v2,v3 """

        # register will return an exception on error
        # (such as when invalid parameters are passed)
        # if an exception does get raised, this test will automatically fail
        register(self.v1.id, self.s1.id)
        self.assertIsNotNone(VolunteerShift.objects.get(
                                                        volunteer_id=self.v1.id,
                                                        shift_id=self.s1.id
                                                        ))

        register(self.v1.id, self.s2.id)
        self.assertIsNotNone(VolunteerShift.objects.get(
                                                        volunteer_id=self.v1.id,
                                                        shift_id=self.s2.id
                                                        ))

        register(self.v1.id, self.s3.id)
        self.assertIsNotNone(VolunteerShift.objects.get(
                                                        volunteer_id=self.v1.id,
                                                        shift_id=self.s3.id
                                                        ))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s1.id
                                                    )
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=12, minute=0)
        add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s2.id
                                                    )
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=6, minute=0)
        add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s3.id
                                                    )
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)
    def test_clear_shift_hours(self):
        """ Uses shifts s1, s2, s3 and volunteer v1 """

        register(self.v1.id, self.s1.id)
        self.assertIsNotNone(
            VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                       shift_id=self.s1.id))

        register(self.v1.id, self.s2.id)
        self.assertIsNotNone(
            VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                       shift_id=self.s2.id))

        register(self.v1.id, self.s3.id)
        self.assertIsNotNone(
            VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                       shift_id=self.s3.id))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=12, minute=0)
        add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=6, minute=0)
        add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)

        clear_shift_hours(self.v1.id, self.s1.id)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s1.id)
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)

        clear_shift_hours(self.v1.id, self.s2.id)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s2.id)
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)

        clear_shift_hours(self.v1.id, self.s3.id)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s3.id)
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)
    def test_add_shift_hours(self):
        """ Uses shifts s1, s2, s3 and volunteers v1,v2,v3 """

        # register will return an exception on error
        # (such as when invalid parameters are passed)
        # if an exception does get raised, this test will automatically fail
        register(self.v1.id, self.s1.id)
        self.assertIsNotNone(
            VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                       shift_id=self.s1.id))

        register(self.v1.id, self.s2.id)
        self.assertIsNotNone(
            VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                       shift_id=self.s2.id))

        register(self.v1.id, self.s3.id)
        self.assertIsNotNone(
            VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                       shift_id=self.s3.id))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s1.id)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=12, minute=0)
        add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s2.id)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=6, minute=0)
        add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s3.id)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)
Exemple #21
0
    def test_clear_shift_hours(self):

        u1 = User.objects.create_user("Yoshi")

        v1 = Volunteer(
            first_name="Yoshi",
            last_name="Turtle",
            address="Mario Land",
            city="Nintendo Land",
            state="Nintendo State",
            country="Nintendo Nation",
            phone_number="2374983247",
            email="*****@*****.**",
            user=u1,
        )

        v1.save()

        e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")

        e1.save()

        j1 = Job(
            name="Software Developer",
            start_date="2012-10-22",
            end_date="2012-10-23",
            description="A software job",
            event=e1,
        )

        j2 = Job(
            name="Systems Administrator",
            start_date="2012-9-1",
            end_date="2012-10-26",
            description="A systems administrator job",
            event=e1,
        )

        j1.save()
        j2.save()

        s1 = Shift(date="2012-10-23", start_time="9:00", end_time="3:00", max_volunteers=1, job=j1)

        s2 = Shift(date="2012-10-23", start_time="10:00", end_time="4:00", max_volunteers=2, job=j1)

        s3 = Shift(date="2012-10-23", start_time="12:00", end_time="6:00", max_volunteers=4, job=j2)

        s1.save()
        s2.save()
        s3.save()

        register(v1.id, s1.id)
        self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id))

        register(v1.id, s2.id)
        self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s2.id))

        register(v1.id, s3.id)
        self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s3.id))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(v1.id, s1.id, start_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=12, minute=0)
        add_shift_hours(v1.id, s2.id, start_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=6, minute=0)
        add_shift_hours(v1.id, s3.id, start_time, end_time)

        clear_shift_hours(v1.id, s1.id)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)

        clear_shift_hours(v1.id, s2.id)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s2.id)
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)

        clear_shift_hours(v1.id, s3.id)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s3.id)
        self.assertIsNone(volunteer_shift.start_time)
        self.assertIsNone(volunteer_shift.end_time)
    def test_edit_shift_hours(self):
        """ Uses shift s1 and volunteer v1 """

        register(self.v1.id, self.s1.id)
        self.assertIsNotNone(VolunteerShift.objects.get(
                                                        volunteer_id=self.v1.id,
                                                        shift_id=self.s1.id
                                                        ))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=11, minute=0)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s1.id
                                                    )
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=1, minute=0)
        end_time = datetime.time(hour=4, minute=0)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s1.id
                                                    )
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=4, minute=15)
        end_time = datetime.time(hour=12, minute=35)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s1.id
                                                    )
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=2, minute=5)
        end_time = datetime.time(hour=4, minute=15)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s1.id
                                                    )
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=5, minute=30)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(
                                                    volunteer_id=self.v1.id,
                                                    shift_id=self.s1.id
                                                    )
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)
Exemple #23
0
    def test_edit_shift_hours(self):
        u1 = User.objects.create_user("Yoshi")

        v1 = Volunteer(
            first_name="Yoshi",
            last_name="Turtle",
            address="Mario Land",
            city="Nintendo Land",
            state="Nintendo State",
            country="Nintendo Nation",
            phone_number="2374983247",
            email="*****@*****.**",
            user=u1,
        )

        v1.save()

        e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")

        e1.save()

        j1 = Job(
            name="Software Developer",
            start_date="2012-10-22",
            end_date="2012-10-23",
            description="A software job",
            event=e1,
        )

        j1.save()

        s1 = Shift(date="2012-10-23", start_time="1:00", end_time="12:00", max_volunteers=1, job=j1)

        s1.save()

        register(v1.id, s1.id)
        self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(v1.id, s1.id, start_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=11, minute=0)
        edit_shift_hours(v1.id, s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=1, minute=0)
        end_time = datetime.time(hour=4, minute=0)
        edit_shift_hours(v1.id, s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=4, minute=15)
        end_time = datetime.time(hour=12, minute=35)
        edit_shift_hours(v1.id, s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=2, minute=5)
        end_time = datetime.time(hour=4, minute=15)
        edit_shift_hours(v1.id, s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=5, minute=30)
        edit_shift_hours(v1.id, s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)
    def test_edit_shift_hours(self):
        """ Uses shift s1 and volunteer v1 """

        register(self.v1.id, self.s1.id)
        self.assertIsNotNone(
            VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                       shift_id=self.s1.id))

        start_time = datetime.time(hour=9, minute=0)
        end_time = datetime.time(hour=10, minute=0)
        add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)

        start_time = datetime.time(hour=10, minute=0)
        end_time = datetime.time(hour=11, minute=0)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=1, minute=0)
        end_time = datetime.time(hour=4, minute=0)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=4, minute=15)
        end_time = datetime.time(hour=12, minute=35)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=2, minute=5)
        end_time = datetime.time(hour=4, minute=15)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)

        start_time = datetime.time(hour=5, minute=0)
        end_time = datetime.time(hour=5, minute=30)
        edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
        volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
                                                     shift_id=self.s1.id)
        self.assertIsNotNone(volunteer_shift.start_time)
        self.assertIsNotNone(volunteer_shift.end_time)
        self.assertEqual(volunteer_shift.start_time, start_time)
        self.assertEqual(volunteer_shift.end_time, end_time)