def test_attachment_login_required(self):
# GIVEN
userhelper.given_a_user_exists()
# WHEN
responses = [
self.client.get(reverse('planner_attachments_list')),
self.client.post(reverse('planner_attachments_list')),
self.client.get(
reverse('planner_attachments_detail', kwargs={'pk': '9999'})),
self.client.delete(
reverse('planner_attachments_detail', kwargs={'pk': '9999'}))
]
# THEN
for response in responses:
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_courseschedule_event_login_required(self):
# GIVEN
userhelper.given_a_user_exists()
# WHEN
responses = [
self.client.get(
reverse('planner_resource_courseschedules_events',
kwargs={
'course_group': '9999',
'course': '9999'
}))
]
# THEN
for response in responses:
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_access_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_coursegroups_courses_courseschedules_list',
kwargs={
'course_group': course_group.pk,
'course': course.pk
})),
self.client.post(
reverse('planner_coursegroups_courses_courseschedules_list',
kwargs={
'course_group': course_group.pk,
'course': course.pk
})),
self.client.get(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': course_schedule.pk
})),
self.client.put(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': course_schedule.pk
})),
self.client.delete(
reverse('planner_coursegroups_courses_courseschedules_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': course_schedule.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_homework_login_required(self):
# GIVEN
userhelper.given_a_user_exists()
# WHEN
responses = [
self.client.get(reverse('planner_homework_list')),
self.client.get(
reverse('planner_coursegroups_courses_homework_list',
kwargs={
'course_group': '9999',
'course': '9999'
})),
self.client.post(
reverse('planner_coursegroups_courses_homework_list',
kwargs={
'course_group': '9999',
'course': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': '9999'
})),
self.client.put(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': '9999'
})),
self.client.delete(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': '9999'
}))
]
# THEN
for response in responses:
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
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_category_changed_deleted_grade_changes(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
category1 = categoryhelper.given_category_exists(course, weight=30)
category2 = categoryhelper.given_category_exists(course, title='Test Category 2', weight=50)
category3 = categoryhelper.given_category_exists(course, title='Test Category 3', weight=20)
homeworkhelper.given_homework_exists(course, category=category1, completed=True,
start=datetime.datetime(2017, 4, 8, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 8, 20, 30, tzinfo=pytz.utc),
current_grade='25/60')
homeworkhelper.given_homework_exists(course, category=category2, completed=True,
start=datetime.datetime(2017, 4, 9, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 9, 20, 30, tzinfo=pytz.utc),
current_grade='75/80')
homeworkhelper.given_homework_exists(course, category=category3, completed=True,
start=datetime.datetime(2017, 4, 10, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 10, 20, 30, tzinfo=pytz.utc),
current_grade='50/120')
homeworkhelper.given_homework_exists(course, category=category1, completed=True,
start=datetime.datetime(2017, 4, 11, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 11, 20, 30, tzinfo=pytz.utc),
current_grade='60/80')
homeworkhelper.given_homework_exists(course, category=category3, completed=True,
start=datetime.datetime(2017, 4, 11, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 11, 20, 30, tzinfo=pytz.utc),
current_grade='110/130')
course = Course.objects.get(pk=course.pk)
category1 = Category.objects.get(pk=category1.pk)
self.assertEqual(float(course.current_grade), 77.8893)
self.assertEqual(float(category1.average_grade), 60.7143)
self.assertEqual(float(category1.grade_by_weight), 18.2143)
# WHEN
category2.weight = 30
category2.save()
category1.weight = 50
category1.save()
# THEN
category1 = Category.objects.get(pk=category1.pk)
category2 = Category.objects.get(pk=category2.pk)
self.assertEqual(float(category1.average_grade), 60.7143)
self.assertEqual(float(category1.grade_by_weight), 30.3571)
self.assertEqual(float(category2.average_grade), 93.75)
self.assertEqual(float(category2.grade_by_weight), 28.125)
# WHEN
category2.delete()
# THEN
course = Course.objects.get(pk=course.pk)
category1 = Category.objects.get(pk=category1.pk)
self.assertEqual(float(course.current_grade), 61.6531)
self.assertEqual(float(category1.average_grade), 60.7143)
self.assertEqual(float(category1.grade_by_weight), 30.3571)
def test_course_deleted_grade_changes(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course1 = coursehelper.given_course_exists(course_group)
course2 = coursehelper.given_course_exists(course_group)
category1 = categoryhelper.given_category_exists(course1, weight=30)
category2 = categoryhelper.given_category_exists(
course1, title='Test Category 2', weight=50)
category3 = categoryhelper.given_category_exists(
course2, title='Test Category 3', weight=20)
homeworkhelper.given_homework_exists(
course1,
category=category1,
completed=True,
start=datetime.datetime(2017, 4, 8, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 8, 20, 30, tzinfo=pytz.utc),
current_grade='25/100')
homeworkhelper.given_homework_exists(
course1,
category=category2,
completed=True,
start=datetime.datetime(2017, 4, 9, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 9, 20, 30, tzinfo=pytz.utc),
current_grade='75/100')
homeworkhelper.given_homework_exists(
course2,
category=category3,
completed=True,
start=datetime.datetime(2017, 4, 10, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 10, 20, 30, tzinfo=pytz.utc),
current_grade='50/100')
homeworkhelper.given_homework_exists(
course1,
category=category1,
completed=True,
start=datetime.datetime(2017, 4, 11, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 11, 20, 30, tzinfo=pytz.utc),
current_grade='60/80')
homeworkhelper.given_homework_exists(
course2,
category=category3,
start=datetime.datetime(2017, 4, 12, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 12, 20, 30, tzinfo=pytz.utc),
completed=True,
current_grade='4/5')
course_group = CourseGroup.objects.get(pk=course_group.pk)
self.assertEqual(float(course_group.average_grade), 58.006)
# WHEN
course2.delete()
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
self.assertEqual(float(course_group.average_grade), 64.5833)
def test_homework_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='')
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group3)
category1 = categoryhelper.given_category_exists(course1, title='Uncategorized')
category2 = categoryhelper.given_category_exists(course2)
category3 = categoryhelper.given_category_exists(course3)
homework1 = homeworkhelper.given_homework_exists(course1, category=category1, completed=True,
current_grade="20/30")
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")
# WHEN
response = self.client.get(reverse("feed_private_homework_ical", kwargs={"slug": user1.settings.private_slug}))
# THEN
calendar = icalendar.Calendar.from_ical(response.content.decode('utf-8'))
self.assertEqual(len(calendar.subcomponents), 2)
self.assertEqual(calendar.subcomponents[0]['SUMMARY'], homework1.title)
self.assertEqual(calendar.subcomponents[0]['DESCRIPTION'],
'Class Info: {}\nGrade: {}\nComments: {}'.format(homework1.course.title,
homework1.current_grade,
homework1.comments))
self.assertEqual(calendar.subcomponents[0]['DTSTART'].dt, homework1.start)
self.assertEqual(calendar.subcomponents[0]['DTEND'].dt, homework1.end)
self.assertEqual(calendar.subcomponents[1]['SUMMARY'], homework2.title)
self.assertEqual(calendar.subcomponents[1]['DTSTART'].dt, homework2.start)
self.assertEqual(calendar.subcomponents[1]['DTEND'].dt, homework2.end)
self.assertEqual(calendar.subcomponents[1]['DESCRIPTION'],
'Class Info: {} for {} in {}\nComments: {}'.format(homework2.category.title,
homework2.course.title,
homework2.course.room,
homework2.comments))
def test_authenticated_view_success(self):
# GIVEN
user = userhelper.given_a_user_exists(self.client)
# WHEN
response1 = self.client.get(reverse('auth_user_detail'))
self.client.force_authenticate(user)
response2 = self.client.get(reverse('auth_user_detail'))
# THEN
self.assertEqual(response1.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
def test_token_with_whitespace_success(self):
# GIVEN
user = userhelper.given_a_user_exists()
# WHEN
data = {'username': f' {user.email} ', 'password': '******'}
response = self.client.post(reverse('auth_token_resource_obtain'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertIn('token', response.data)
def test_unweight_graded_points(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
category1 = categoryhelper.given_category_exists(course)
category2 = categoryhelper.given_category_exists(course, title='Test Category 2')
category3 = categoryhelper.given_category_exists(course, title='Test Category 3')
homework1 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
start=datetime.datetime(2017, 4, 8, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 8, 20, 30, tzinfo=pytz.utc),
current_grade='25/100')
homework2 = homeworkhelper.given_homework_exists(course, category=category2, completed=True,
start=datetime.datetime(2017, 4, 9, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 9, 20, 30, tzinfo=pytz.utc),
current_grade='75/100')
homework3 = homeworkhelper.given_homework_exists(course, category=category3, completed=True,
start=datetime.datetime(2017, 4, 10, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 10, 20, 30, tzinfo=pytz.utc),
current_grade='50/100')
homework4 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
start=datetime.datetime(2017, 4, 11, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 11, 20, 30, tzinfo=pytz.utc),
current_grade='60/80')
homework5 = homeworkhelper.given_homework_exists(course, category=category3,
start=datetime.datetime(2017, 4, 12, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 12, 20, 30, tzinfo=pytz.utc),
completed=True, current_grade='4/5')
# Incomplete homework are not graded
homeworkhelper.given_homework_exists(course, category=category1,
start=datetime.datetime(2017, 4, 8, 21, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 8, 21, 30, tzinfo=pytz.utc),
current_grade='80/100')
# WHEN
grade_points = gradingservice.get_grade_points_for_course(course.pk)
# THEN
self.assertEqual(len(grade_points), 5)
# (25) / 1
self.assertEqual(grade_points[0], [homework1.start, 25])
# (25 + 75) / 2
self.assertEqual(grade_points[1], [homework2.start, 50])
# (25 + 75 + 50) / 3
self.assertEqual(grade_points[2], [homework3.start, 50])
# (25 + 75 + 50 + (60/80)) / 4
self.assertEqual(grade_points[3], [homework4.start, 55.2632])
# (25 + 75 + 50 + (60/80) + (4/5)) / 5
self.assertEqual(grade_points[4], [homework5.start, 55.5844])
def test_weight_graded_points(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
category1 = categoryhelper.given_category_exists(course, weight=30)
category2 = categoryhelper.given_category_exists(course, title='Test Category 2', weight=50)
category3 = categoryhelper.given_category_exists(course, title='Test Category 3', weight=20)
homework1 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
start=datetime.datetime(2017, 4, 8, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 8, 20, 30, tzinfo=pytz.utc),
current_grade='25/100')
homework2 = homeworkhelper.given_homework_exists(course, category=category2, completed=True,
start=datetime.datetime(2017, 4, 9, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 9, 20, 30, tzinfo=pytz.utc),
current_grade='75/100')
homework3 = homeworkhelper.given_homework_exists(course, category=category3, completed=True,
start=datetime.datetime(2017, 4, 10, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 10, 20, 30, tzinfo=pytz.utc),
current_grade='50/100')
homework4 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
start=datetime.datetime(2017, 4, 11, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 11, 20, 30, tzinfo=pytz.utc),
current_grade='60/80')
homework5 = homeworkhelper.given_homework_exists(course, category=category3,
start=datetime.datetime(2017, 4, 12, 20, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 12, 20, 30, tzinfo=pytz.utc),
completed=True, current_grade='4/5')
# Incomplete homework are not graded
homeworkhelper.given_homework_exists(course, category=category1,
start=datetime.datetime(2017, 4, 8, 21, 0, tzinfo=pytz.utc),
end=datetime.datetime(2017, 4, 8, 21, 30, tzinfo=pytz.utc),
current_grade='80/100')
# WHEN
grade_points = gradingservice.get_grade_points_for_course(course.pk)
# THEN
self.assertEqual(len(grade_points), 5)
# ((25 * 30)) / 30
self.assertEqual(grade_points[0], [homework1.start, 25])
# ((25 * 30) + (75 * 50)) / 80
self.assertEqual(grade_points[1], [homework2.start, 56.25])
# ((25 * 30) + (75 * 50) + (50 * 20)) / 100
self.assertEqual(grade_points[2], [homework3.start, 55])
# ((25 * 30) + (75 * 50) + (50 * 20) + ((60/80) * 30)) / 100
self.assertEqual(grade_points[3], [homework4.start, 59.6154])
# ((25 * 30) + (75 * 50) + (50 * 20) + ((60/80) * 30) + ((4/5) * 10)) / 100
self.assertEqual(grade_points[4], [homework5.start, 62.3333])
def test_events_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()
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
# WHEN
response = self.client.get(reverse("feed_private_events_ical", kwargs={"slug": user1.settings.private_slug}))
# THEN
calendar = icalendar.Calendar.from_ical(response.content.decode('utf-8'))
self.assertEqual(len(calendar.subcomponents), 2)
self.assertEqual(calendar.subcomponents[0]['SUMMARY'], event1.title)
self.assertEqual(calendar.subcomponents[0]['DESCRIPTION'], f"Comments: {event1.comments}")
self.assertEqual(calendar.subcomponents[0]['DTSTART'].dt, event1.start)
self.assertEqual(calendar.subcomponents[0]['DTEND'].dt, event1.end)
self.assertEqual(calendar.subcomponents[1]['SUMMARY'], event1.title)
self.assertEqual(calendar.subcomponents[1]['DTSTART'].dt, event2.start)
self.assertEqual(calendar.subcomponents[1]['DTEND'].dt, event2.end)
self.assertEqual(calendar.subcomponents[1]['DESCRIPTION'], f"Comments: {event2.comments}")
def test_token_fail_no_password(self):
# GIVEN
user = userhelper.given_a_user_exists()
# WHEN
data = {
'username': user.get_username(),
}
response = self.client.post(reverse('auth_token_resource_obtain'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('password', response.data)
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'],
'Comments: <a href="{}">{}</a> in {}'.format(
course1.website, course1.title, course1.room))
def test_get_events(self):
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******',
email='*****@*****.**')
eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
eventhelper.given_event_exists(user2)
# WHEN
response = self.client.get(reverse('planner_events_list'))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Event.objects.count(), 3)
self.assertEqual(len(response.data), 2)
def test_related_field_owned_by_another_user_forbidden(self):
# GIVEN
user1 = userhelper.given_a_user_exists_and_is_authenticated(
self.client)
user2 = userhelper.given_a_user_exists(username='******',
email='*****@*****.**')
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1)
course2 = coursehelper.given_course_exists(course_group2)
material_group1 = materialgrouphelper.given_material_group_exists(
user1)
material_group2 = materialgrouphelper.given_material_group_exists(
user2)
material = materialhelper.given_material_exists(material_group1,
courses=[course1])
# WHEN
responses = [
self.client.post(reverse(
'planner_materialgroups_materials_list',
kwargs={'material_group': material_group1.pk}),
json.dumps({'courses': [course2.pk]}),
content_type='application/json'),
self.client.post(reverse(
'planner_materialgroups_materials_list',
kwargs={'material_group': material_group2.pk}),
json.dumps({}),
content_type='application/json'),
self.client.put(reverse('planner_materialgroups_materials_detail',
kwargs={
'material_group': material_group1.pk,
'pk': material.pk
}),
json.dumps({'material_group': material_group2.pk}),
content_type='application/json'),
self.client.put(reverse('planner_materialgroups_materials_detail',
kwargs={
'material_group': material_group1.pk,
'pk': material.pk
}),
json.dumps({'courses': [course2.pk]}),
content_type='application/json')
]
# THEN
for response in responses:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_weighted_grade_imbalanced(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
category1 = categoryhelper.given_category_exists(course)
category2 = categoryhelper.given_category_exists(
course, title='Test Category 2')
category3 = categoryhelper.given_category_exists(
course, title='Test Category 3')
# WHEN
homeworkhelper.given_homework_exists(course,
category=category1,
completed=True,
current_grade='10/10')
homeworkhelper.given_homework_exists(course,
category=category1,
completed=True,
current_grade='50/100')
homeworkhelper.given_homework_exists(course,
category=category2,
completed=True,
current_grade='40/50')
homeworkhelper.given_homework_exists(course,
category=category2,
completed=True,
current_grade='60/100')
homeworkhelper.given_homework_exists(course,
category=category3,
completed=True,
current_grade='200/200')
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course = Course.objects.get(pk=course.pk)
category1 = Category.objects.get(pk=category1.pk)
category2 = Category.objects.get(pk=category2.pk)
category3 = Category.objects.get(pk=category3.pk)
# 360/460 total points
self.assertEqual(float(course_group.average_grade), 78.2609)
self.assertEqual(float(course.current_grade), 78.2609)
# 60/110 total points
self.assertEqual(float(category1.average_grade), 54.5454)
# 100/150 total points
self.assertEqual(float(category2.average_grade), 66.6667)
# 200/200 total points
self.assertEqual(float(category3.average_grade), 100)
def test_get_materialgroups(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******',
email='*****@*****.**')
materialgrouphelper.given_material_group_exists(user1)
materialgrouphelper.given_material_group_exists(user2)
materialgrouphelper.given_material_group_exists(user2)
# WHEN
response = self.client.get(reverse('planner_materialgroups_list'))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(MaterialGroup.objects.count(), 3)
self.assertEqual(len(response.data), 2)
def test_get_attachments(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user2)
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = 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_group2)
homework1 = homeworkhelper.given_homework_exists(course1)
homework2 = homeworkhelper.given_homework_exists(course2)
attachmenthelper.given_attachment_exists(user1, course=course1)
attachmenthelper.given_attachment_exists(user2, course=course2)
attachmenthelper.given_attachment_exists(user2, course=course3)
attachmenthelper.given_attachment_exists(user2, course=course3)
attachmenthelper.given_attachment_exists(user1, event=event1)
attachmenthelper.given_attachment_exists(user2, event=event2)
attachmenthelper.given_attachment_exists(user2, event=event2)
attachmenthelper.given_attachment_exists(user1, homework=homework1)
attachmenthelper.given_attachment_exists(user2, homework=homework2)
attachmenthelper.given_attachment_exists(user2, homework=homework2)
# WHEN
response1 = self.client.get(reverse('planner_attachments_list'))
response2 = self.client.get(
reverse('planner_attachments_list') +
'?course={}'.format(course3.pk))
response3 = self.client.get(
reverse('planner_attachments_list') +
'?event={}'.format(event2.pk))
response4 = self.client.get(
reverse('planner_attachments_list') +
'?homework={}'.format(homework2.pk))
# THEN
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(response3.status_code, status.HTTP_200_OK)
self.assertEqual(response4.status_code, status.HTTP_200_OK)
self.assertEqual(Attachment.objects.count(), 10)
self.assertEqual(len(response1.data), 7)
self.assertEqual(len(response2.data), 2)
self.assertEqual(len(response3.data), 2)
self.assertEqual(len(response4.data), 2)
def test_access_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='*****@*****.**')
material_group = materialgrouphelper.given_material_group_exists(user1)
material = materialhelper.given_material_exists(material_group)
# WHEN
responses = [
self.client.get(
reverse('planner_materialgroups_materials_list',
kwargs={'material_group': material_group.pk})),
self.client.post(reverse(
'planner_materialgroups_materials_list',
kwargs={'material_group': material_group.pk}),
content_type='application/json'),
self.client.get(
reverse('planner_materialgroups_materials_detail',
kwargs={
'material_group': material_group.pk,
'pk': material.pk
})),
self.client.put(
reverse('planner_materialgroups_materials_detail',
kwargs={
'material_group': material_group.pk,
'pk': material.pk
})),
self.client.delete(
reverse('planner_materialgroups_materials_detail',
kwargs={
'material_group': material_group.pk,
'pk': material.pk
}))
]
# THEN
self.assertTrue(
Material.objects.filter(pk=material.pk,
material_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_incomplete_not_graded(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
category1 = categoryhelper.given_category_exists(course)
categoryhelper.given_category_exists(course, title='Test Category 2')
# WHEN
homework1 = homeworkhelper.given_homework_exists(
course, category=category1, current_grade='50/100')
homeworkhelper.given_homework_exists(course,
category=category1,
completed=True,
current_grade='100/100')
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course = Course.objects.get(pk=course.pk)
category = Category.objects.get(pk=category1.pk)
self.assertEqual(float(course_group.average_grade), 100)
self.assertEqual(float(course.current_grade), 100)
self.assertEqual(float(category.average_grade), 100)
# WHEN
homework1.completed = True
homework1.save()
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course = Course.objects.get(pk=course.pk)
category = Category.objects.get(pk=category1.pk)
self.assertEqual(float(course_group.average_grade), 75)
self.assertEqual(float(course.current_grade), 75)
self.assertEqual(float(category.average_grade), 75)
# WHEN
homework1.completed = False
homework1.save()
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course = Course.objects.get(pk=course.pk)
category = Category.objects.get(pk=category1.pk)
self.assertEqual(float(course_group.average_grade), 100)
self.assertEqual(float(course.current_grade), 100)
self.assertEqual(float(category.average_grade), 100)
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='*****@*****.**')
external_calendar = externalcalendarhelper.given_external_calendar_exists(user1)
# WHEN
responses = [
self.client.get(reverse('feed_externalcalendars_detail', kwargs={'pk': external_calendar.pk})),
self.client.put(reverse('feed_externalcalendars_detail', kwargs={'pk': external_calendar.pk})),
self.client.delete(reverse('feed_externalcalendars_detail', kwargs={'pk': external_calendar.pk})),
]
# THEN
self.assertTrue(ExternalCalendar.objects.filter(pk=external_calendar.pk, user_id=user1.pk).exists())
for response in responses:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_unweighted_grade_unchanged(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
category = categoryhelper.given_category_exists(course)
# WHEN
homeworkhelper.given_homework_exists(course, category=category, current_grade='-1/100')
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course = Course.objects.get(pk=course.pk)
category = Category.objects.get(pk=category.pk)
self.assertEqual(course_group.average_grade, -1)
self.assertEqual(course.current_grade, -1)
self.assertEqual(category.average_grade, -1)
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)
# WHEN
responses = [
self.client.get(reverse('planner_coursegroups_detail', kwargs={'pk': course_group.pk})),
self.client.put(reverse('planner_coursegroups_detail', kwargs={'pk': course_group.pk})),
self.client.delete(reverse('planner_coursegroups_detail', kwargs={'pk': course_group.pk}))
]
# THEN
self.assertTrue(CourseGroup.objects.filter(pk=course_group.pk, user_id=user1.pk).exists())
for response in responses:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_token_success(self):
# GIVEN
user = userhelper.given_a_user_exists()
# WHEN
data = {
'username': user.get_username(),
'password': '******'
}
response = self.client.post(reverse('auth_token_resource_obtain'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertIn('token', response.data)
user = get_user_model().objects.get(username=user.get_username())
self.assertIsNotNone(user.last_login)
def test_login_invalid_user(self):
# GIVEN
user = userhelper.given_a_user_exists()
# WHEN
responses = [
self.client.post(reverse('auth_token_resource_obtain'),
json.dumps({'username': '******', 'password': '******'}),
content_type='application/json'),
self.client.post(reverse('auth_token_resource_obtain'),
json.dumps({'username': user.get_username(), 'password': '******'}),
content_type='application/json')
]
# THEN
for response in responses:
self.assertContains(response, 'recognize that account',
status_code=status.HTTP_400_BAD_REQUEST)
def test_email_already_exists(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******',
email='*****@*****.**')
# WHEN
data = {
# Trying to change email to match user1's email
'email': user1.email,
'username': user2.username
}
response = self.client.put(reverse('auth_user_detail'), json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('email', response.data)
def test_events_for_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******',
email='*****@*****.**')
eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
eventhelper.given_event_exists(user2)
eventhelper.given_event_exists(user2)
self.assertEqual(Event.objects.count(), 4)
# WHEN
response = self.client.delete(reverse('planner_events_resource_delete'))
# THEN
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Event.objects.count(), 1)
self.assertEqual(Event.objects.for_user(user2.pk).count(), 0)
def test_related_field_owned_by_another_user_forbidden(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)
course1 = coursehelper.given_course_exists(course_group1)
coursehelper.given_course_exists(course_group2)
tmp_file = attachmenthelper.given_file_exists()
# WHEN
with open(tmp_file.name):
response = self.client.post(reverse('planner_attachments_list'),
{'course': course1.pk})
# THEN
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
