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_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_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_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_get_categories(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)
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group2)
categoryhelper.given_category_exists(course1)
categoryhelper.given_category_exists(course2, title='Test Category 2')
categoryhelper.given_category_exists(course3, title='Test Category 3')
categoryhelper.given_category_exists(course3, title='Test Category 4')
# WHEN
response1 = self.client.get(reverse('planner_categories_list'))
response2 = self.client.get(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group2.pk,
'course': course3.pk
}))
# THEN
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(Category.objects.count(), 4)
self.assertEqual(len(response1.data), 3)
self.assertEqual(len(response2.data), 2)
def test_create_category_exceeds_weight_course_100_fails(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)
categoryhelper.given_category_exists(course, weight=25)
categoryhelper.given_category_exists(course,
title='Test Category 2',
weight=25)
categoryhelper.given_category_exists(course,
title='Test Category 3',
weight=25)
categoryhelper.given_category_exists(course,
title='Test Category 4',
weight=25)
# WHEN
data = {
'title': 'some title',
'weight': 0.0000000001,
'color': '#7bd148'
}
response = self.client.post(reverse(
'planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group.pk,
'course': course.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('weight', response.data)
self.assertEqual(Category.objects.count(), 4)
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_get_category_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)
category = categoryhelper.given_category_exists(course)
homeworkhelper.given_homework_exists(course, category=category)
homeworkhelper.given_homework_exists(course,
completed=True,
category=category)
homeworkhelper.given_homework_exists(course,
completed=True,
current_grade='25/30',
category=category)
# WHEN
response = self.client.get(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': category.pk
}))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
category = Category.objects.get(pk=category.pk)
categoryhelper.verify_category_matches_data(self, category,
response.data)
self.assertEqual(response.data['num_homework'], 3)
self.assertEqual(response.data['num_homework_graded'], 1)
def test_update_category_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)
category = categoryhelper.given_category_exists(course)
# WHEN
data = {'title': 'some title', 'weight': '25.00', 'color': '#7bd148'}
response = self.client.put(reverse(
'planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': category.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
category = Category.objects.get(pk=category.pk)
categoryhelper.verify_category_matches_data(self, category,
response.data)
def test_trend_negative(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, 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='400/100')
homeworkhelper.given_homework_exists(course, category=category, 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='200/100')
homeworkhelper.given_homework_exists(course, category=category, 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='0/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(float(course_group.trend), -1)
self.assertEqual(float(course.trend), -1)
self.assertEqual(float(category.trend), -1)
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_update_homework_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)
category1 = categoryhelper.given_category_exists(course)
category2 = categoryhelper.given_category_exists(
course, title='Test Category 2')
material_group = materialgrouphelper.given_material_group_exists(user)
material1 = materialhelper.given_material_exists(material_group)
material2 = materialhelper.given_material_exists(material_group)
homework = homeworkhelper.given_homework_exists(course,
category=category1,
materials=[material1])
# WHEN
data = {
'title': 'some title',
'all_day': True,
'show_end_time': False,
'start': '2016-05-08T12:00:00Z',
'end': '2016-05-08T14:00:00Z',
'priority': 12,
'comments': 'some comment',
'current_grade': '33/40',
'completed': True,
'category': category2.pk,
'materials': [material2.pk],
'course': course.pk
}
response = self.client.put(reverse(
'planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': homework.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
homework = Homework.objects.get(pk=homework.pk)
homeworkhelper.verify_homework_matches_data(self, homework,
response.data)
def test_category_search_query(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)
category = categoryhelper.given_category_exists(course,
title='testcategory')
homework = homeworkhelper.given_homework_exists(course,
title='test1',
category=category)
homeworkhelper.given_homework_exists(course, title='test2')
response = self.client.get(
reverse('planner_homework_list') + '?search=testcategory')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['title'], homework.title)
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_delete_category_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)
category = categoryhelper.given_category_exists(course)
# WHEN
response = self.client.delete(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': category.pk
}))
# THEN
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(Category.objects.filter(pk=category.pk).exists())
def test_create_homework(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)
category = categoryhelper.given_category_exists(course)
material_group = materialgrouphelper.given_material_group_exists(user)
material = materialhelper.given_material_exists(material_group)
# WHEN
data = {
'title': 'some title',
'all_day': True,
'show_end_time': False,
'start': '2014-05-08T12:00:00Z',
'end': '2014-05-08T14:00:00Z',
'priority': 12,
'comments': 'some comment',
'current_grade': '25/30',
'completed': False,
'category': category.pk,
'materials': [material.pk],
'course': course.pk
}
response = self.client.post(reverse(
'planner_coursegroups_courses_homework_list',
kwargs={
'course_group': course_group.pk,
'course': course.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Homework.objects.count(), 1)
homework = Homework.objects.get(pk=response.data['id'])
homeworkhelper.verify_homework_matches_data(self, homework, data)
homeworkhelper.verify_homework_matches_data(self, homework,
response.data)
def test_update_read_only_field_does_nothing(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course1 = coursehelper.given_course_exists(course_group)
course2 = coursehelper.given_course_exists(course_group)
category = categoryhelper.given_category_exists(course2)
average_grade = category.average_grade
grade_by_weight = category.grade_by_weight
trend = category.trend
# WHEN
data = {
'average_grade': 23,
'grade_by_weight': 56,
'trend': 1.5,
'course': course1.pk,
# Intentionally NOT changing these value
'title': category.title,
'weight': category.weight,
'color': category.color
}
response = self.client.put(reverse(
'planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': course2.pk,
'pk': category.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
category = Category.objects.get(pk=category.id)
self.assertEqual(category.average_grade, average_grade)
self.assertEqual(category.grade_by_weight, grade_by_weight)
self.assertEqual(category.trend, trend)
self.assertEqual(category.course.pk, course2.pk)
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)
category = categoryhelper.given_category_exists(course)
# WHEN
data = {'color': 'invalid-hex'}
response = self.client.put(reverse(
'planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': category.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('color', response.data)
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='*****@*****.**')
materialgroup2 = materialgrouphelper.given_material_group_exists(user2)
material2 = materialhelper.given_material_exists(materialgroup2)
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)
category2 = categoryhelper.given_category_exists(course2)
homework = homeworkhelper.given_homework_exists(course1)
# WHEN
responses = [
self.client.post(reverse(
'planner_coursegroups_courses_homework_list',
kwargs={
'course_group': course_group1.pk,
'course': course2.pk
}),
json.dumps({}),
content_type='application/json'),
self.client.post(reverse(
'planner_coursegroups_courses_homework_list',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk
}),
json.dumps({'category': category2.pk}),
content_type='application/json'),
self.client.post(reverse(
'planner_coursegroups_courses_homework_list',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk
}),
json.dumps({'materials': [material2.pk]}),
content_type='application/json'),
self.client.patch(reverse(
'planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk,
'pk': homework.pk
}),
json.dumps({'course': course2.pk}),
content_type='application/json'),
self.client.patch(reverse(
'planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk,
'pk': homework.pk
}),
json.dumps({'materials': [material2.pk]}),
content_type='application/json'),
]
# THEN
for response in responses:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_unweighted_grade_changes(self):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course_group_ungraded = coursegrouphelper.given_course_group_exists(user)
course1 = coursehelper.given_course_exists(course_group)
course2 = coursehelper.given_course_exists(course_group)
course_ungraded = coursehelper.given_course_exists(course_group_ungraded)
category1 = categoryhelper.given_category_exists(course1)
category2 = categoryhelper.given_category_exists(course2)
category_ungraded = categoryhelper.given_category_exists(course_ungraded)
# WHEN
homework1 = homeworkhelper.given_homework_exists(course1, category=category1, completed=True,
current_grade='100/100')
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course_group_ungraded = CourseGroup.objects.get(pk=course_group_ungraded.pk)
course1 = Course.objects.get(pk=course1.pk)
course2 = Course.objects.get(pk=course2.pk)
course_ungraded = Course.objects.get(pk=course_ungraded.pk)
category1 = Category.objects.get(pk=category1.pk)
category2 = Category.objects.get(pk=category2.pk)
category_ungraded = Category.objects.get(pk=category_ungraded.pk)
self.assertEqual(float(course_group.average_grade), 100)
self.assertEqual(course_group_ungraded.average_grade, -1)
self.assertEqual(course1.current_grade, 100)
self.assertEqual(course2.current_grade, -1)
self.assertEqual(course_ungraded.current_grade, -1)
self.assertEqual(float(category1.average_grade), 100)
self.assertEqual(category2.average_grade, -1)
self.assertEqual(category_ungraded.average_grade, -1)
# WHEN
homeworkhelper.given_homework_exists(course2, category=category2, completed=True, current_grade='50/100')
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course_group_ungraded = CourseGroup.objects.get(pk=course_group_ungraded.pk)
course1 = Course.objects.get(pk=course1.pk)
course2 = Course.objects.get(pk=course2.pk)
course_ungraded = Course.objects.get(pk=course_ungraded.pk)
category1 = Category.objects.get(pk=category1.pk)
category2 = Category.objects.get(pk=category2.pk)
category_ungraded = Category.objects.get(pk=category_ungraded.pk)
self.assertEqual(float(course_group.average_grade), 75)
self.assertEqual(course_group_ungraded.average_grade, -1)
self.assertEqual(course1.current_grade, 100)
self.assertEqual(course2.current_grade, 50)
self.assertEqual(course_ungraded.current_grade, -1)
self.assertEqual(float(category1.average_grade), 100)
self.assertEqual(category2.average_grade, 50)
self.assertEqual(category_ungraded.average_grade, -1)
# WHEN
homeworkhelper.given_homework_exists(course1, category=category1, completed=True, current_grade='80/100')
# THEN
course_group = CourseGroup.objects.get(pk=course_group.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(float(course_group.average_grade), 70)
self.assertEqual(course1.current_grade, 90)
self.assertEqual(course2.current_grade, 50)
self.assertEqual(float(category1.average_grade), 90)
self.assertEqual(category2.average_grade, 50)
# WHEN
homework1.delete()
# THEN
course_group = CourseGroup.objects.get(pk=course_group.pk)
course_group_ungraded = CourseGroup.objects.get(pk=course_group_ungraded.pk)
course1 = Course.objects.get(pk=course1.pk)
course2 = Course.objects.get(pk=course2.pk)
course_ungraded = Course.objects.get(pk=course_ungraded.pk)
category1 = Category.objects.get(pk=category1.pk)
category2 = Category.objects.get(pk=category2.pk)
category_ungraded = Category.objects.get(pk=category_ungraded.pk)
self.assertEqual(float(course_group.average_grade), 65)
self.assertEqual(course_group_ungraded.average_grade, -1)
self.assertEqual(course1.current_grade, 80)
self.assertEqual(course2.current_grade, 50)
self.assertEqual(course_ungraded.current_grade, -1)
self.assertEqual(float(category1.average_grade), 80)
self.assertEqual(category2.average_grade, 50)
self.assertEqual(category_ungraded.average_grade, -1)
def test_error_on_object_owned_by_another_user(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)
category = categoryhelper.given_category_exists(course1)
# WHEN
responses = [
self.client.get(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk
})),
self.client.post(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk
})),
self.client.get(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group2.pk,
'course': course1.pk
})),
self.client.get(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk,
'pk': category.pk
})),
self.client.put(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk,
'pk': category.pk
})),
self.client.delete(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group1.pk,
'course': course1.pk,
'pk': category.pk
}))
]
# THEN
self.assertTrue(
Category.objects.filter(
pk=category.pk,
course__course_group__user_id=user1.pk).exists())
for response in responses:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_weighted_course_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=60)
category3 = categoryhelper.given_category_exists(course, title='Test Category 3', weight=10)
# WHEN
homework1 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
current_grade='25/100')
homeworkhelper.given_homework_exists(course, category=category1, completed=True, current_grade='75/100')
homework3 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
current_grade='50/100')
# THEN
course = Course.objects.get(pk=course.pk)
# (((.5 * .3) + (0 * .6) + (0 * .1)) / .3) * 100
self.assertEqual(float(course.current_grade), 50)
# WHEN
homework4 = homeworkhelper.given_homework_exists(course, category=category2, completed=True,
current_grade='35/100')
# THEN
course = Course.objects.get(pk=course.pk)
# (((.5 * .3) + (.35 * .6) + (0 * .1)) / .9) * 100
self.assertEqual(float(course.current_grade), 40)
# WHEN
homeworkhelper.given_homework_exists(course, category=category3, completed=True, current_grade='90/100')
# THEN
course = Course.objects.get(pk=course.pk)
# ((.5 * .3) + (.35 * .6) + (.9 * .1)) * 100
self.assertEqual(float(course.current_grade), 45)
# WHEN
homeworkhelper.given_homework_exists(course, category=category1, completed=True, current_grade='75/100')
homeworkhelper.given_homework_exists(course, category=category2, completed=True, current_grade='85/100')
homework8 = homeworkhelper.given_homework_exists(course, category=category3, completed=True,
current_grade='45/100')
# THEN
course = Course.objects.get(pk=course.pk)
# ((.5625 * .3) + (.6 * .6) + (.675 * .1)) * 100
self.assertEqual(float(course.current_grade), 59.6250)
# WHEN
homework4.current_grade = '80/100'
homework4.save()
homework8.current_grade = '80/100'
homework8.save()
# THEN
course = Course.objects.get(pk=course.pk)
# ((.5625 * .3) + (.825 * .6) + (.85 * .1)) * 100
self.assertEqual(float(course.current_grade), 74.875)
# WHEN
homework1.delete()
homework3.delete()
# THEN
course = Course.objects.get(pk=course.pk)
# ((.75 * .3) + (.825 * .6) + (.85 * .1)) * 100
self.assertEqual(float(course.current_grade), 80.5)
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)
category = categoryhelper.given_category_exists(course)
responses = [
self.client.get(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': '9999',
'course': '9999'
})),
self.client.post(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group.pk,
'course': '9999'
})),
self.client.post(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': '9999',
'course': course.pk
})),
self.client.get(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group.pk,
'course': '9999'
})),
self.client.post(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': course_group.pk,
'course': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': '9999',
'course': course.pk
})),
self.client.post(
reverse('planner_coursegroups_courses_categories_list',
kwargs={
'course_group': '9999',
'course': course.pk
})),
self.client.get(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': '9999',
'pk': '9999'
})),
self.client.put(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': '9999',
'pk': '9999'
})),
self.client.delete(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': course_group.pk,
'course': '9999',
'pk': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': '9999',
'course': course.pk,
'pk': '9999'
})),
self.client.put(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': '9999',
'course': course.pk,
'pk': '9999'
})),
self.client.delete(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': '9999',
'course': course.pk,
'pk': '9999'
})),
self.client.get(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': category.pk
})),
self.client.put(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': category.pk
})),
self.client.delete(
reverse('planner_coursegroups_courses_categories_detail',
kwargs={
'course_group': '9999',
'course': '9999',
'pk': category.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())
def test_get_grades(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group1 = coursegrouphelper.given_course_group_exists(user)
course_group2 = coursegrouphelper.given_course_group_exists(user)
course1 = coursehelper.given_course_exists(course_group1)
course2 = coursehelper.given_course_exists(course_group2)
category1 = categoryhelper.given_category_exists(course1, weight=50)
category2 = categoryhelper.given_category_exists(
course1, title='Test Category 2', weight=50)
# This category having no weight will result in the course not having weighted grading
category3 = categoryhelper.given_category_exists(
course2, title='Test Category 3', weight=0)
homework1 = homeworkhelper.given_homework_exists(course1,
category=category1,
completed=True,
current_grade='20/30')
homework2 = homeworkhelper.given_homework_exists(course1,
category=category1,
completed=True,
current_grade='25/30')
homework3 = homeworkhelper.given_homework_exists(course1,
category=category2,
completed=True,
current_grade='15/30')
homework4 = homeworkhelper.given_homework_exists(course2,
category=category3,
completed=True,
current_grade='20/30')
homework5 = homeworkhelper.given_homework_exists(course2,
category=category3,
completed=True,
current_grade='25/30')
# Incomplete homework are not graded
homeworkhelper.given_homework_exists(course1,
category=category2,
current_grade='-1/100')
# Completed homework with no grade set are not graded
homeworkhelper.given_homework_exists(course2,
category=category3,
completed=True,
current_grade='-1/100')
# WHEN
response = self.client.get(reverse('planner_resource_grades'))
# THEN
self.assertEquals(len(response.data['course_groups']), 2)
self.assertEquals(len(response.data['course_groups'][0]['courses']), 1)
self.assertEquals(len(response.data['course_groups'][1]['courses']), 1)
self.assertEquals(
len(response.data['course_groups'][0]['courses'][0]['categories']),
2)
self.assertEquals(
len(response.data['course_groups'][1]['courses'][0]['categories']),
1)
self.assertEquals(
len(response.data['course_groups'][0]['courses'][0]
['grade_points']), 3)
self.assertEquals(
len(response.data['course_groups'][1]['courses'][0]
['grade_points']), 2)
self.assertIn('title', response.data['course_groups'][0])
self.assertEquals(
float(response.data['course_groups'][0]['overall_grade']), 62.5)
self.assertIn('trend', response.data['course_groups'][0])
self.assertIn('num_homework_graded', response.data['course_groups'][0])
self.assertIn('title', response.data['course_groups'][0]['courses'][0])
self.assertEquals(
float(response.data['course_groups'][0]['courses'][0]
['overall_grade']), 62.5)
self.assertIn('trend', response.data['course_groups'][0]['courses'][0])
self.assertIn('num_homework_graded',
response.data['course_groups'][0]['courses'][0])
self.assertIn('has_weighted_grading',
response.data['course_groups'][0]['courses'][0])
grade_points = response.data['course_groups'][0]['courses'][0][
'grade_points']
self.assertEquals(grade_points[0][0], homework1.start)
self.assertEquals(grade_points[0][1], 66.6667)
self.assertEquals(grade_points[1][0], homework2.start)
self.assertEquals(grade_points[1][1], 75.0)
self.assertEquals(grade_points[2][0], homework3.start)
self.assertEquals(grade_points[2][1], 66.6667)
self.assertIn(
'title',
response.data['course_groups'][0]['courses'][0]['categories'][0])
self.assertEquals(
float(response.data['course_groups'][0]['courses'][0]['categories']
[0]['overall_grade']), 75.0)
self.assertIn(
'trend',
response.data['course_groups'][0]['courses'][0]['categories'][0])
self.assertIn(
'num_homework_graded',
response.data['course_groups'][0]['courses'][0]['categories'][0])
self.assertIn(
'weight',
response.data['course_groups'][0]['courses'][0]['categories'][0])
self.assertIn(
'color',
response.data['course_groups'][0]['courses'][0]['categories'][0])
self.assertIn(
'grade_by_weight',
response.data['course_groups'][0]['courses'][0]['categories'][0])
self.assertIn(
'title',
response.data['course_groups'][0]['courses'][0]['categories'][1])
self.assertEquals(
float(response.data['course_groups'][0]['courses'][0]['categories']
[1]['overall_grade']), 50.0)
self.assertIn(
'trend',
response.data['course_groups'][0]['courses'][0]['categories'][1])
self.assertIn(
'num_homework_graded',
response.data['course_groups'][0]['courses'][0]['categories'][1])
self.assertIn(
'weight',
response.data['course_groups'][0]['courses'][0]['categories'][1])
self.assertIn(
'color',
response.data['course_groups'][0]['courses'][0]['categories'][1])
self.assertIn(
'grade_by_weight',
response.data['course_groups'][0]['courses'][0]['categories'][1])
self.assertIn('title', response.data['course_groups'][1])
self.assertEquals(
float(response.data['course_groups'][1]['overall_grade']), 75.0)
self.assertIn('trend', response.data['course_groups'][1])
self.assertIn('num_homework_graded', response.data['course_groups'][1])
self.assertIn('title', response.data['course_groups'][1]['courses'][0])
self.assertEquals(
float(response.data['course_groups'][1]['courses'][0]
['overall_grade']), 75.0)
self.assertIn('trend', response.data['course_groups'][1]['courses'][0])
self.assertIn('num_homework_graded',
response.data['course_groups'][1]['courses'][0])
self.assertIn('has_weighted_grading',
response.data['course_groups'][1]['courses'][0])
grade_points = response.data['course_groups'][1]['courses'][0][
'grade_points']
self.assertEquals(grade_points[0][0], homework4.start)
self.assertEquals(grade_points[0][1], 66.6667)
self.assertEquals(grade_points[1][0], homework5.start)
self.assertEquals(grade_points[1][1], 75.0)
self.assertIn(
'title',
response.data['course_groups'][1]['courses'][0]['categories'][0])
self.assertEquals(
float(response.data['course_groups'][1]['courses'][0]['categories']
[0]['overall_grade']), 75.0)
self.assertIn(
'trend',
response.data['course_groups'][1]['courses'][0]['categories'][0])
self.assertIn(
'num_homework_graded',
response.data['course_groups'][1]['courses'][0]['categories'][0])
self.assertIn(
'weight',
response.data['course_groups'][1]['courses'][0]['categories'][0])
self.assertIn(
'color',
response.data['course_groups'][1]['courses'][0]['categories'][0])
self.assertIn(
'grade_by_weight',
response.data['course_groups'][1]['courses'][0]['categories'][0])
def test_unweighted_course_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)
category2 = categoryhelper.given_category_exists(course, title='Test Category 2')
# WHEN
homework1 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
current_grade='25/100')
homework2 = homeworkhelper.given_homework_exists(course, category=category1, completed=True,
current_grade='75/100')
homework3 = homeworkhelper.given_homework_exists(course, category=category2, completed=True,
current_grade='25/100')
homework4 = homeworkhelper.given_homework_exists(course, category=category2, completed=True,
current_grade='75/100')
homeworkhelper.given_homework_exists(course, category=category1, completed=True, current_grade='100/100')
# THEN
course = Course.objects.get(pk=course.pk)
# (25 + 75 + 25 + 75 + 100) / 5
self.assertEqual(float(course.current_grade), 60)
# WHEN
homeworkhelper.given_homework_exists(course, category=category1, completed=True, current_grade='25/100')
homeworkhelper.given_homework_exists(course, category=category2, completed=True, current_grade='25/100')
# THEN
course = Course.objects.get(pk=course.pk)
# (25 + 75 + 25 + 75 + 100 + 25 + 25) / 7
self.assertEqual(float(course.current_grade), 50)
# WHEN
homework1.current_grade = '80/100'
homework1.save()
homework2.current_grade = '90/100'
homework2.save()
# THEN
course = Course.objects.get(pk=course.pk)
# (80 + 90 + 25 + 75 + 100 + 25 + 25) / 7
self.assertEqual(float(course.current_grade), 60)
# WHEN
homework3.current_grade = '80/100'
homework3.save()
homework4.current_grade = '90/100'
homework4.save()
# THEN
course = Course.objects.get(pk=course.pk)
# (80 + 90 + 80 + 90 + 100 + 25 + 25) / 7
self.assertEqual(float(course.current_grade), 70)
# WHEN
homework3.delete()
homework4.delete()
# THEN
course = Course.objects.get(pk=course.pk)
# (80 + 90 + 100 + 25 + 25) / 5
self.assertEqual(float(course.current_grade), 64)
