def test_get_materials(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
material_group1 = materialgrouphelper.given_material_group_exists(
user1)
material_group2 = materialgrouphelper.given_material_group_exists(
user2)
material_group3 = materialgrouphelper.given_material_group_exists(
user2)
materialhelper.given_material_exists(material_group1)
materialhelper.given_material_exists(material_group2)
materialhelper.given_material_exists(material_group3)
materialhelper.given_material_exists(material_group3)
# WHEN
response1 = self.client.get(reverse('planner_materials_list'))
response2 = self.client.get(
reverse('planner_materialgroups_materials_list',
kwargs={'material_group': material_group3.pk}))
# THEN
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(Material.objects.count(), 4)
self.assertEqual(len(response1.data), 3)
self.assertEqual(len(response2.data), 2)
def test_update_material_by_id(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)
material_group1 = materialgrouphelper.given_material_group_exists(user)
material_group2 = materialgrouphelper.given_material_group_exists(user)
material = materialhelper.given_material_exists(material_group1, courses=[course1])
# WHEN
data = {
'title': 'some title',
'status': enums.TO_SELL,
'condition': enums.USED_POOR,
'website': 'http://www.some-material.com',
'price': '500.27',
'details': 'N/A',
'material_group': material_group2.pk,
'courses': [course2.pk]
}
response = self.client.put(
reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': material_group1.pk, 'pk': material.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
material = Material.objects.get(pk=material.pk)
materialhelper.verify_material_matches_data(self, material, response.data)
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_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_update_multiple_courses(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)
material_group1 = materialgrouphelper.given_material_group_exists(user)
material = materialhelper.given_material_exists(material_group1)
# WHEN
data = {
'courses': [course1.pk, course2.pk],
# Intentionally NOT changing these value
'title': material.title,
'material_group': material.material_group.pk
}
response = self.client.put(reverse(
'planner_materialgroups_materials_detail',
kwargs={
'material_group': material_group1.pk,
'pk': material.pk
}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['courses'], data['courses'])
material = Material.objects.get(pk=material.pk)
materialhelper.verify_material_matches_data(self, material,
response.data)
def test_create_material(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)
material_group = materialgrouphelper.given_material_group_exists(user)
# WHEN
data = {
'title': 'some title',
'status': enums.TO_SELL,
'condition': enums.USED_POOR,
'website': 'http://www.some-material.com',
'price': '500.27',
'details': 'N/A',
'material_group': material_group.pk,
'courses': [course.pk]
}
response = self.client.post(reverse(
'planner_materialgroups_materials_list',
kwargs={'material_group': material_group.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Material.objects.count(), 1)
material = Material.objects.get(pk=response.data['id'])
materialhelper.verify_material_matches_data(self, material,
response.data)
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(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
else:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_get_materialgroup_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
material_group = materialgrouphelper.given_material_group_exists(user)
# WHEN
response = self.client.get(reverse('planner_materialgroups_detail', kwargs={'pk': material_group.pk}))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
materialgrouphelper.verify_material_group_matches_data(self, material_group, response.data)
def test_delete_materialgroup_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
material_group = materialgrouphelper.given_material_group_exists(user)
# WHEN
response = self.client.delete(reverse('planner_materialgroups_detail', kwargs={'pk': material_group.pk}))
# THEN
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(MaterialGroup.objects.filter(pk=material_group.pk).exists())
self.assertEqual(MaterialGroup.objects.count(), 0)
def test_courses_filter_query(self):
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)
coursehelper.given_course_exists(course_group)
material_group = materialgrouphelper.given_material_group_exists(user)
material = materialhelper.given_material_exists(material_group, courses=[course1, course2])
response = self.client.get(
reverse('planner_materials_list') + f'?courses={course1.pk}&courses={course2.pk}')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['title'], material.title)
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_create_bad_data(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
material_group = materialgrouphelper.given_material_group_exists(user)
# WHEN
data = {'status': 'not-a-valid-status'}
response = self.client.post(reverse(
'planner_materialgroups_materials_list',
kwargs={'material_group': material_group.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('status', response.data)
self.assertEqual(Material.objects.count(), 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='*****@*****.**')
material_group = materialgrouphelper.given_material_group_exists(user1)
# WHEN
responses = [
self.client.get(reverse('planner_materialgroups_detail', kwargs={'pk': material_group.pk})),
self.client.put(reverse('planner_materialgroups_detail', kwargs={'pk': material_group.pk})),
self.client.delete(reverse('planner_materialgroups_detail', kwargs={'pk': material_group.pk}))
]
# THEN
self.assertTrue(MaterialGroup.objects.filter(pk=material_group.pk, user_id=user1.pk).exists())
for response in responses:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_update_read_only_field_does_nothing(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******',
email='*****@*****.**')
material_group = materialgrouphelper.given_material_group_exists(user2)
# WHEN
data = {
'user': user1.pk,
# Intentionally NOT changing these value
'title': material_group.title,
}
response = self.client.put(reverse('planner_materialgroups_detail', kwargs={'pk': material_group.pk}),
json.dumps(data), content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
material_group = MaterialGroup.objects.get(pk=material_group.id)
self.assertEqual(material_group.get_user().pk, user2.pk)
def test_update_materialgroup_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
material_group = materialgrouphelper.given_material_group_exists(user)
self.assertEqual(material_group.title, 'Test Material Group')
self.assertTrue(material_group.shown_on_calendar)
# WHEN
data = {
'title': 'new title',
'shown_on_calendar': False
}
response = self.client.put(reverse('planner_materialgroups_detail', kwargs={'pk': material_group.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
material_group = MaterialGroup.objects.get(pk=material_group.pk)
materialgrouphelper.verify_material_group_matches_data(self, material_group, response.data)
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_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_not_found(self):
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
material_group = materialgrouphelper.given_material_group_exists(user)
material = materialhelper.given_material_exists(material_group)
responses = [
self.client.get(reverse('planner_materialgroups_materials_list', kwargs={'material_group': '9999'})),
self.client.post(
reverse('planner_materialgroups_materials_list', kwargs={'material_group': '9999'}),
content_type='application/json'),
self.client.get(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': '9999', 'pk': '9999'})),
self.client.put(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': '9999', 'pk': '9999'})),
self.client.delete(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': '9999', 'pk': '9999'})),
self.client.get(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': material_group.pk, 'pk': '9999'})),
self.client.put(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': material_group.pk, 'pk': '9999'})),
self.client.delete(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': material_group.pk, 'pk': '9999'})),
self.client.get(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': '9999', 'pk': material.pk})),
self.client.put(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': '9999', 'pk': material.pk})),
self.client.delete(reverse('planner_materialgroups_materials_detail',
kwargs={'material_group': '9999', 'pk': material.pk}))
]
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)
self.assertIn('not found', response.data['detail'].lower())
