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