def test_get_course_schedules(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user2)
course_group3 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1)
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group3)
course4 = coursehelper.given_course_exists(course_group3)
courseschedulehelper.given_course_schedule_exists(course1)
courseschedulehelper.given_course_schedule_exists(course2)
courseschedulehelper.given_course_schedule_exists(course3)
courseschedulehelper.given_course_schedule_exists(course4)
courseschedulehelper.given_course_schedule_exists(course4)
# WHEN
response = self.client.get(
reverse('planner_coursegroups_courses_courseschedules_list',
kwargs={
'course_group': course_group3.pk,
'course': course4.pk
}))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(CourseSchedule.objects.count(), 5)
self.assertEqual(len(response.data), 2)
def test_get_course_schedule_cached(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
courseschedulehelper.given_course_schedule_exists(course)
# WHEN
response_db = self.client.get(reverse('planner_resource_courseschedules_events',
kwargs={'course_group': course_group.pk, 'course': course.pk}))
with mock.patch('helium.planner.services.coursescheduleservice._create_events_from_course_schedules') as \
_create_events_from_course_schedules_mock:
response_cached = self.client.get(reverse('planner_resource_courseschedules_events',
kwargs={'course_group': course_group.pk, 'course': course.pk}))
# THEN
self.assertEqual(_create_events_from_course_schedules_mock.call_count, 0)
self.assertEqual(len(response_cached.data), len(response_db.data))
cached_event = [e for e in response_cached.data if e['id'] == response_db.data[0]['id']]
self.assertTrue(len(cached_event) == 1)
self.assertEqual(cached_event[0]['title'], response_db.data[0]['title'])
self.assertEqual(cached_event[0]['start'], response_db.data[0]['start'])
self.assertEqual(cached_event[0]['end'], response_db.data[0]['end'])
self.assertEqual(cached_event[0]['all_day'], response_db.data[0]['all_day'])
self.assertEqual(cached_event[0]['show_end_time'], response_db.data[0]['show_end_time'])
self.assertEqual(cached_event[0]['comments'], response_db.data[0]['comments'])
def test_get_course_schedule_as_events(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
courseschedulehelper.given_course_schedule_exists(course)
# WHEN
response = self.client.get(
reverse('planner_resource_courseschedules_events',
kwargs={
'course_group': course_group.pk,
'course': course.pk
}))
# THEN
self.assertEqual(len(response.data), 53)
self.assertEqual(response.data[0]['title'], course.title)
self.assertEqual(response.data[0]['start'], '2017-01-06T10:30:00Z')
self.assertEqual(response.data[0]['end'], '2017-01-06T13:00:00Z')
self.assertEqual(response.data[0]['all_day'], False)
self.assertEqual(response.data[0]['show_end_time'], True)
self.assertEqual(
response.data[0]['comments'],
'<a href="{}">{}</a> in {}'.format(course.website, course.title,
course.room))
def test_export_success(self):
# GIVEN
user1 = userhelper.given_a_user_exists_and_is_authenticated(self.client)
user2 = userhelper.given_a_user_exists(username='******', email='*****@*****.**')
external_calendar = externalcalendarhelper.given_external_calendar_exists(user1)
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user1)
course_group3 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1, room='')
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group3)
course_schedule1 = courseschedulehelper.given_course_schedule_exists(course1)
course_schedule2 = courseschedulehelper.given_course_schedule_exists(course2)
courseschedulehelper.given_course_schedule_exists(course3)
category1 = categoryhelper.given_category_exists(course1, title='Uncategorized')
category2 = categoryhelper.given_category_exists(course2)
category3 = categoryhelper.given_category_exists(course3)
material_group1 = materialgrouphelper.given_material_group_exists(user1)
material_group2 = materialgrouphelper.given_material_group_exists(user2)
material1 = materialhelper.given_material_exists(material_group1)
materialhelper.given_material_exists(material_group2)
homework1 = homeworkhelper.given_homework_exists(course1, category=category1, completed=True,
current_grade="20/30", materials=[material1])
homework2 = homeworkhelper.given_homework_exists(course2, category=category2, current_grade="-1/100")
homeworkhelper.given_homework_exists(course3, category=category3, completed=True, current_grade="-1/100")
reminder = reminderhelper.given_reminder_exists(user1, homework=homework1)
# WHEN
response = self.client.get(reverse('importexport_resource_export'))
data = json.loads(response.content.decode('utf-8'))
# THEN
course_group1 = CourseGroup.objects.get(pk=course_group1.pk)
course_group2 = CourseGroup.objects.get(pk=course_group2.pk)
course1 = Course.objects.get(pk=course1.pk)
course2 = Course.objects.get(pk=course2.pk)
category1 = Category.objects.get(pk=category1.pk)
category2 = Category.objects.get(pk=category2.pk)
self.assertEqual(response.status_code, status.HTTP_200_OK)
externalcalendarhelper.verify_externalcalendar_matches_data(self, external_calendar,
data['external_calendars'][0])
eventhelper.verify_event_matches_data(self, event1, data['events'][0])
eventhelper.verify_event_matches_data(self, event2, data['events'][1])
coursegrouphelper.verify_course_group_matches_data(self, course_group1, data['course_groups'][0])
coursegrouphelper.verify_course_group_matches_data(self, course_group2, data['course_groups'][1])
coursehelper.verify_course_matches_data(self, course1, data['courses'][0])
coursehelper.verify_course_matches_data(self, course2, data['courses'][1])
courseschedulehelper.verify_course_schedule_matches(self, course_schedule1, data['course_schedules'][0])
courseschedulehelper.verify_course_schedule_matches(self, course_schedule2, data['course_schedules'][1])
categoryhelper.verify_category_matches_data(self, category1, data['categories'][1])
categoryhelper.verify_category_matches_data(self, category2, data['categories'][0])
homeworkhelper.verify_homework_matches_data(self, homework1, data['homework'][0])
homeworkhelper.verify_homework_matches_data(self, homework2, data['homework'][1])
reminderhelper.verify_reminder_matches_data(self, reminder, data['reminders'][0])
def test_error_on_object_owned_by_another_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
course_group = coursegrouphelper.given_course_group_exists(user1)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
# WHEN
responses = [
self.client.get(
reverse('planner_resource_courseschedules_events',
kwargs={
'course_group': course_group.pk,
'course': course.pk
}))
]
# THEN
self.assertTrue(
CourseSchedule.objects.filter(
pk=course_schedule.pk,
course__course_group__user_id=user1.pk).exists())
for response in responses:
if isinstance(response.data, list):
self.assertEqual(len(response.data), 0)
else:
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
def test_course_schedule_cache_cleared_when_course_changed(
self, get_many_mock):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
self.client.get(
reverse('planner_resource_courseschedules_events',
kwargs={
'course_group': course_group.pk,
'course': course.pk
}))
self.assertEqual(get_many_mock.call_count, 0)
# WHEN
course.start_date = datetime.date(2017, 1, 2)
course.save()
course_schedule.mon_start_time = datetime.time(2, 00, 0)
course_schedule.save()
self.client.get(
reverse('planner_resource_courseschedules_events',
kwargs={
'course_group': course_group.pk,
'course': course.pk
}))
# THEN
self.assertEqual(get_many_mock.call_count, 0)
def test_courseschedules_feed(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user1.settings.enable_private_slug()
user2 = userhelper.given_a_user_exists(username='******', email='*****@*****.**')
user2.settings.enable_private_slug()
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user1)
course_group3 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1, room='SSC 123')
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group3)
courseschedulehelper.given_course_schedule_exists(course1)
courseschedulehelper.given_course_schedule_exists(course2)
courseschedulehelper.given_course_schedule_exists(course3)
# WHEN
response = self.client.get(
reverse("feed_private_courseschedules_ical", kwargs={"slug": user1.settings.private_slug}))
# THEN
calendar = icalendar.Calendar.from_ical(response.content.decode('utf-8'))
self.assertEqual(len(calendar.subcomponents), 106)
self.assertEqual(calendar.subcomponents[0]['SUMMARY'], course1.title)
self.assertEqual(str(calendar.subcomponents[0]['DTSTART'].dt), '2017-01-06 02:30:00-08:00')
self.assertEqual(str(calendar.subcomponents[0]['DTEND'].dt), '2017-01-06 05:00:00-08:00')
self.assertEqual(calendar.subcomponents[0]['DESCRIPTION'],
f'Comments: <a href="{course1.website}">{course1.title}</a> in {course1.room}')
def test_get_end_time_for_weekday(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(course, days_of_week='1111111',
sun_end_time=datetime.time(3, 0, 0),
mon_end_time=datetime.time(3, 0, 1),
tue_end_time=datetime.time(3, 0, 2),
wed_end_time=datetime.time(3, 0, 3),
thu_end_time=datetime.time(3, 0, 4),
fri_end_time=datetime.time(3, 0, 5),
sat_end_time=datetime.time(3, 0, 6))
# WHEN
day_0 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 0)
day_1 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 1)
day_2 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 2)
day_3 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 3)
day_4 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 4)
day_5 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 5)
day_6 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 6)
# THEN
self.assertEqual(day_0, datetime.time(3, 0, 0))
self.assertEqual(day_1, datetime.time(3, 0, 1))
self.assertEqual(day_2, datetime.time(3, 0, 2))
self.assertEqual(day_3, datetime.time(3, 0, 3))
self.assertEqual(day_4, datetime.time(3, 0, 4))
self.assertEqual(day_5, datetime.time(3, 0, 5))
self.assertEqual(day_6, datetime.time(3, 0, 6))
self.assertRaises(HeliumCourseScheduleError,
coursescheduleservice._get_end_time_for_weekday, course_schedule, 7)
# WHEN
course_schedule.days_of_week = '1011111'
course_schedule.save()
day_0 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 0)
day_1 = coursescheduleservice._get_end_time_for_weekday(course_schedule, 1)
# THEN
self.assertIsNotNone(day_0)
self.assertIsNone(day_1)
def test_update_course_schedule_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
# WHEN
data = {
'days_of_week': '0001000',
'wed_start_time': '18:30:00',
'wed_end_time': '19:30:00',
# These fields are set to their defaults
'sun_start_time': '12:00:00',
'sun_end_time': '12:00:00',
'mon_start_time': '12:00:00',
'mon_end_time': '12:00:00',
'tue_start_time': '12:00:00',
'tue_end_time': '12:00:00',
'thu_start_time': '12:00:00',
'thu_end_time': '12:00:00',
'fri_start_time': '12:00:00',
'fri_end_time': '12:00:00',
'sat_start_time': '12:00:00',
'sat_end_time': '12:00:00',
}
response = self.client.put(reverse(
'planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': course_schedule.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
course_schedule = CourseSchedule.objects.get(pk=course_schedule.pk)
courseschedulehelper.verify_course_schedule_matches(
self, course_schedule, response.data)
def test_delete_course_schedule_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
# WHEN
response = self.client.delete(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': course_schedule.pk
}))
# THEN
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(
CourseSchedule.objects.filter(pk=course_group.pk).exists())
self.assertEqual(CourseSchedule.objects.count(), 0)
def test_get_course_schedule_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
# WHEN
response = self.client.get(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': course_schedule.pk
}))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
course_schedule = CourseSchedule.objects.get(pk=course_schedule.pk)
courseschedulehelper.verify_course_schedule_matches(
self, course_schedule, response.data)
def test_update_bad_data(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
# WHEN
data = {'sun_start_time': 'not-a-valid-time'}
response = self.client.put(reverse(
'planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': course_schedule.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('sun_start_time', response.data)
def test_not_found(self):
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
responses = [
self.client.get(
reverse('planner_coursegroups_courses_courseschedules_list',
kwargs={
'course_group': '9999',
'course': '9999'
})),
self.client.post(
reverse('planner_coursegroups_courses_courseschedules_list',
kwargs={
'course_group': '9999',
'course': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': '9999'
})),
self.client.put(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': '9999'
})),
self.client.delete(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': '9999',
'pk': '9999'
})),
self.client.put(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': '9999',
'pk': '9999'
})),
self.client.delete(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': '9999',
'pk': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': course.pk,
'pk': '9999'
})),
self.client.put(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': course.pk,
'pk': '9999'
})),
self.client.delete(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': course.pk,
'pk': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': course_schedule.pk
})),
self.client.put(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': course_schedule.pk
})),
self.client.delete(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': course_schedule.pk
}))
]
for response in responses:
if isinstance(response.data, list):
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
else:
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
self.assertIn('not found', response.data['detail'].lower())
