def setUpTestData(cls): """ Create two teachers with different working hours """ cls.first_teacher = create_teacher() cls.first_teacher.user.last_name = 'A_first' # for correct ordering cls.first_teacher.user.save() mixer.blend(WorkingHours, teacher=cls.first_teacher, weekday=0, start='13:00', end='15:30') # monday mixer.blend(WorkingHours, teacher=cls.first_teacher, weekday=1, start='17:00', end='19:00') # thursday cls.second_teacher = create_teacher() cls.second_teacher.user.last_name = 'B_second' # for correct ordering cls.second_teacher.user.save() mixer.blend(WorkingHours, teacher=cls.second_teacher, weekday=0, start='13:00', end='15:00') # monday mixer.blend(WorkingHours, teacher=cls.second_teacher, weekday=4, start='17:00', end='19:00') # thursday
def test_planning_unaccaptable_lesson(self): lazy_teacher = create_teacher( accepts_all_lessons=False ) # teacher2 does not accept any lesson, so cannot be planned hard_working_teacher = create_teacher() with self.assertRaises(ValidationError): mixer.blend(lessons.MasterClass, host=lazy_teacher) self.assertIsNotNone( mixer.blend(lessons.MasterClass, host=hard_working_teacher))
def test_get_teachers_by_lesson_type(self): """ Test that TeacherManager.find_free() ignores teachers that can't host this lesson types. """ create_teacher( accepts_all_lessons=False, works_24x7=True) # create teacher that cant host ordinary lessons lesson_type = lessons.OrdinaryLesson.get_contenttype().pk free_treachers = list( Teacher.objects.find_free(date=self.tzdatetime(2032, 5, 3), lesson_type=lesson_type)) self.assertEqual( len(free_treachers), 1) # because only one teacher can host ordinary lessons
def test_free_slots_for_lesson(self): """ Test for getting free time slots for a particular teacher with particular lesson """ other_teacher = create_teacher() master_class = mixer.blend(lessons.MasterClass, host=self.teacher) other_master_class = mixer.blend(lessons.MasterClass, host=other_teacher) entry = TimelineEntry(teacher=self.teacher, lesson=master_class, start=self.tzdatetime(2032, 5, 3, 14, 10), end=self.tzdatetime(2032, 5, 3, 14, 40)) entry.save() other_entry = TimelineEntry(teacher=other_teacher, lesson=other_master_class, start=self.tzdatetime(2032, 5, 3, 14, 10), end=self.tzdatetime(2032, 5, 3, 14, 40)) other_entry.save() slots = self.teacher.find_free_slots(self.tzdatetime(2032, 5, 3), lesson_id=master_class.pk) self.assertEquals(len(slots), 1) slots = self.teacher.find_free_slots(self.tzdatetime(2032, 5, 3), lesson_id=other_master_class.pk) self.assertEquals(len(slots), 0)
def setUp(self): """ Calendar administration is limited to staff members, so we login with a super user here. """ self.teacher = create_teacher() self.c.login(username=self.superuser_login, password=self.superuser_password)
def test_create_teacher(self): Teacher = apps.get_model('teachers.teacher') teacher = create_teacher() t = Teacher.objects.get(user__username=teacher.user.username) self.assertEqual(t, teacher) self.assertIsNotNone(t.user.crm) self.assertTrue(t.user.is_staff)
def test_hosted_lessons_starting_soon(self): teacher = create_teacher() lesson = mixer.blend(lessons.MasterClass, host=teacher, photo=mixer.RANDOM) mixer.blend('timeline.Entry', lesson=lesson, teacher=teacher, start=self.tzdatetime(2032, 12, 25, 12, 00)) hosted_lessons_starting_soon = self.customer.classes.hosted_lessons_starting_soon() self.assertEqual(len(hosted_lessons_starting_soon), 1) self.assertEqual(hosted_lessons_starting_soon[0], lesson)
def _generate_slots(self): teacher = create_teacher() mixer.blend(WorkingHours, teacher=teacher, weekday=0, start='13:00', end='15:00') return teacher.find_free_slots(date=self.tzdatetime(2032, 5, 3))
def setUpTestData(cls): cls.teacher = create_teacher() mixer.blend( 'extevents.ExternalEvent', teacher=cls.teacher, start=cls.tzdatetime(2032, 12, 5, 13, 30), end=cls.tzdatetime(2032, 12, 5, 14, 30), )
def setUpTestData(cls): cls.customer = create_customer() cls.host = create_teacher() mixer.blend(WorkingHours, teacher=cls.host, weekday=0, start='13:00', end='15:00') # monday
def _schedule(self, c, date, *args): c.timeline = mixer.blend( 'timeline.Entry', lesson_type=c.lesson_type, teacher=create_teacher(), start=date, ) c.save()
def setUp(self): self.teacher = create_teacher() self.entry = mixer.blend( TimelineEntry, taken_slots=1, teacher=self.teacher, start=self.tzdatetime(2032, 5, 10, 21, 0), is_finished=False, )
def test_hosted_lessons_fail_due_to_another_teacher(self): another_teacher = create_teacher() another_teacher.allowed_lessons.add( lessons.MasterClass.get_contenttype()) mixer.blend(lessons.MasterClass, host=another_teacher) res = self.teacher.available_lessons( lesson_type=lessons.MasterClass.get_contenttype()) self.assertEqual(len(res), 0)
def setUp(self): self.teacher = create_teacher() self.lesson = lessons.OrdinaryLesson.get_default() self.big_entry = mixer.blend( TimelineEntry, teacher=self.teacher, start=self.tzdatetime(2016, 1, 2, 18, 0), end=self.tzdatetime(2016, 1, 3, 12, 0), )
def setUpTestData(cls): cls.customer = create_customer() cls.teacher = create_teacher(works_24x7=True) cls.subscription = Subscription( customer=cls.customer, product=Product1.objects.get(pk=1), buy_price=150, ) cls.subscription.save()
def test_get_timeline_entries(self): teacher = create_teacher() lesson = mixer.blend(lessons.MasterClass, host=teacher) entry = mixer.blend('timeline.Entry', teacher=teacher, lesson=lesson, start=self.tzdatetime(2032, 12, 10, 12, 0)) found = lesson.get_timeline_entries() self.assertEqual(len(found), 1) self.assertEqual(found[0], entry)
def setUpTestData(cls): cls.host = create_teacher(works_24x7=True) cls.lesson = mixer.blend(lessons.MasterClass, host=cls.host, photo=mixer.RANDOM) cls.entry = mixer.blend( TimelineEntry, teacher=cls.host, lesson=cls.lesson, start=cls.tzdatetime(2032, 12, 5, 13, 00) )
def setUp(self): self.host = create_teacher(works_24x7=True) self.lesson = mixer.blend(lessons.MasterClass, host=self.host, photo=mixer.RANDOM) self.entry = mixer.blend( TimelineEntry, teacher=self.host, lesson=self.lesson, start=self.tzdatetime(2032, 12, 5, 13, 00) )
def setUp(self): self.teacher = create_teacher() self.src = models.GoogleCalendar( teacher=self.teacher, url='http://testing' ) self.src.save() patcher = patch('extevents.models.timezone') timezone = patcher.start() timezone.now = MagicMock(return_value=self.tzdatetime('UTC', 2023, 9, 11, 10, 0))
def test_save(self): start = self.tzdatetime('Europe/Moscow', 2016, 12, 1, 12, 50) end = self.tzdatetime('Europe/Moscow', 2016, 12, 1, 12, 59) event = models.ExternalEvent( teacher=create_teacher(), start=start, end=end, description='testdescr', src=self.src, ) event.save() self.assertIsNotNone(event.pk)
def setUp(self): self.teacher = create_teacher() self.monday = mixer.blend(WorkingHours, teacher=self.teacher, weekday=0, start='13:00', end='15:00') # monday self.tuesday = mixer.blend(WorkingHours, teacher=self.teacher, weekday=1, start='17:00', end='19:00') # tuesday
def setUpTestData(cls): cls.teacher = create_teacher() mixer.blend(WorkingHours, teacher=cls.teacher, weekday=0, start='13:00', end='15:00') # monday mixer.blend(WorkingHours, teacher=cls.teacher, weekday=1, start='17:00', end='19:00') # thursday
def test_trial_lesson_has_started(self): self.assertFalse(self.customer.trial_lesson_has_started()) self.customer.add_trial_lesson() self.assertFalse(self.customer.trial_lesson_has_started()) trial_class = self.customer.classes.first() trial_class.timeline = mixer.blend('timeline.Entry', teacher=create_teacher()) with patch('market.models.Class.has_started') as has_started: has_started.return_value = True self.assertTrue(self.customer.trial_lesson_has_started()) self.assertEqual(has_started.call_count, 1)
def test_preserving_other_teachers_when_cleaning_previous_events(self): some_other_teacher = create_teacher() for i in range(0, 10): mixer.blend( models.ExternalEvent, teacher=some_other_teacher, src=self.src, ) self.assertEqual(models.ExternalEvent.objects.count(), 20) self.src._ExternalEventSource__clear_previous_events() self.assertEqual(models.ExternalEvent.objects.count(), 10) # only events for self.teacher should be deleted self.assertEqual( models.ExternalEvent.objects.all()[0].teacher, some_other_teacher ) # events for some_other_teacher should not be touched
def test_two_teachers_for_single_slot(self): """ Check if find_free_slots returns only slots of selected teacher """ other_teacher = create_teacher() master_class = mixer.blend(lessons.MasterClass, host=other_teacher) entry = TimelineEntry(teacher=other_teacher, lesson=master_class, start=self.tzdatetime(2032, 5, 3, 14, 10), end=self.tzdatetime(2032, 5, 3, 14, 40)) entry.save() lesson_type = ContentType.objects.get_for_model(master_class) slots = self.teacher.find_free_slots(date=self.tzdatetime(2032, 5, 3), lesson_type=lesson_type.pk) self.assertEquals( len(slots), 0 ) # should not return anything — we are checking slots for self.teacher, not other_teacher
def _schedule(self, lesson_type=None, date=None): if date is None: date = self.tzdatetime(2032, 12, 1, 11, 30) if lesson_type is None: lesson_type = lessons.OrdinaryLesson.get_contenttype() c = self.customer.classes.filter(lesson_type=lesson_type, is_scheduled=False).first() """ If this test will fail when you change the SortingHat behaviour, just replace the above lines with the SortingHat invocation """ c.schedule( teacher=create_teacher(works_24x7=True), date=date, allow_besides_working_hours=True, ) c.save() self.assertTrue(c.is_scheduled) return c
def setUp(self): self.teacher = create_teacher() self.lesson = mixer.blend(lessons.MasterClass, host=self.teacher) self.entry = TimelineEntry( teacher=self.teacher, lesson=self.lesson, start=self.tzdatetime('Europe/Moscow', 2016, 1, 18, 14, 10), end=self.tzdatetime('Europe/Moscow', 2016, 1, 18, 14, 40), ) self.entry.save() mixer.blend(WorkingHours, teacher=self.teacher, weekday=0, start='13:00', end='15:00') self.absence = Absence( type='vacation', teacher=self.teacher, start=self.tzdatetime(2032, 5, 3, 0, 0), end=self.tzdatetime(2032, 5, 3, 23, 59), ) self.absence.save()
def setUp(self): self.teacher = create_teacher()
def setUp(self): self.teacher = create_teacher(works_24x7=True, accepts_all_lessons=False)
def setUp(self): self.host = create_teacher(works_24x7=True) self.customer = create_customer()