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='*****@*****.**')
event = eventhelper.given_event_exists(user1)
# WHEN
responses = [
self.client.get(
reverse('planner_events_detail', kwargs={'pk': event.pk})),
self.client.put(
reverse('planner_events_detail', kwargs={'pk': event.pk})),
self.client.delete(
reverse('planner_events_detail', kwargs={'pk': event.pk}))
]
# THEN
self.assertTrue(
Event.objects.filter(pk=event.pk, 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_error_on_object_owned_by_another_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
course_group = coursegrouphelper.given_course_group_exists(user1)
course = coursehelper.given_course_exists(course_group)
course_schedule = courseschedulehelper.given_course_schedule_exists(
course)
# WHEN
responses = [
self.client.get(
reverse('planner_resource_courseschedules_events',
kwargs={
'course_group': course_group.pk,
'course': course.pk
}))
]
# THEN
self.assertTrue(
CourseSchedule.objects.filter(
pk=course_schedule.pk,
course__course_group__user_id=user1.pk).exists())
for response in responses:
if isinstance(response.data, list):
self.assertEqual(len(response.data), 0)
else:
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
def test_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_import_invalid_json(self):
# GIVEN
userhelper.given_a_user_exists_and_is_authenticated(self.client)
tmp_file = attachmenthelper.given_file_exists(ext='.json')
# WHEN
with open(tmp_file.name) as fp:
data = {
'file[]': [fp]
}
response = self.client.post(
reverse('importexport_resource_import'),
data)
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('detail', response.data)
self.assertEqual(ExternalCalendar.objects.count(), 0)
self.assertEqual(CourseGroup.objects.count(), 0)
self.assertEqual(Course.objects.count(), 0)
self.assertEqual(CourseSchedule.objects.count(), 0)
self.assertEqual(Category.objects.count(), 0)
self.assertEqual(MaterialGroup.objects.count(), 0)
self.assertEqual(Material.objects.count(), 0)
self.assertEqual(Event.objects.count(), 0)
self.assertEqual(Homework.objects.count(), 0)
self.assertEqual(Reminder.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='*****@*****.**')
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_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_import_invalid_relationships(self):
# GIVEN
userhelper.given_a_user_exists_and_is_authenticated(self.client)
# WHEN
with open(
os.path.join(
os.path.dirname(__file__),
os.path.join('../../resources',
'invalidsample.json'))) as fp:
data = {'file[]': [fp]}
response = self.client.post(
reverse('importexport_resource_import'), data)
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('course', response.data['homework'][1])
self.assertIn('may not be null',
response.data['homework'][1]['course'][0])
self.assertIn('materials', response.data['homework'][1])
self.assertIn('object does not exist',
response.data['homework'][1]['materials'][0])
self.assertEqual(ExternalCalendar.objects.count(), 0)
self.assertEqual(CourseGroup.objects.count(), 0)
self.assertEqual(Course.objects.count(), 0)
self.assertEqual(CourseSchedule.objects.count(), 0)
self.assertEqual(Category.objects.count(), 0)
self.assertEqual(MaterialGroup.objects.count(), 0)
self.assertEqual(Material.objects.count(), 0)
self.assertEqual(Event.objects.count(), 0)
self.assertEqual(Homework.objects.count(), 0)
self.assertEqual(Reminder.objects.count(), 0)
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)
homework = homeworkhelper.given_homework_exists(course)
# WHEN
responses = [
self.client.get(
reverse('planner_coursegroups_courses_homework_list',
kwargs={
'course_group': course_group.pk,
'course': course.pk
})),
self.client.post(
reverse('planner_coursegroups_courses_homework_list',
kwargs={
'course_group': course_group.pk,
'course': course.pk
})),
self.client.get(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': homework.pk
})),
self.client.put(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': homework.pk
})),
self.client.delete(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': homework.pk
}))
]
# THEN
self.assertTrue(
Homework.objects.for_user(
user1.pk).filter(pk=homework.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_revoke_token(self):
# GIVEN
userhelper.given_a_user_exists_and_is_authenticated(self.client)
# WHEN
response1 = self.client.delete(reverse('auth_token_resource_revoke'))
response2 = self.client.get(reverse('auth_user_detail'))
# THEN
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(Token.objects.count(), 0)
def test_put_bad_data_fails(self):
# GIVEN
userhelper.given_a_user_exists_and_is_authenticated(self.client)
# WHEN
data = {'time_zone': 'invalid'}
response = self.client.put(reverse('auth_user_settings_detail'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('time_zone', response.data)
def test_create_bad_data(self):
# GIVEN
userhelper.given_a_user_exists_and_is_authenticated(self.client)
# WHEN
data = {'start': 'not-a-valid-date'}
response = self.client.post(reverse('planner_events_list'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('start', response.data)
def test_create_orphaned_attachment_fails(self):
# GIVEN
userhelper.given_a_user_exists_and_is_authenticated(self.client)
tmp_file = attachmenthelper.given_file_exists()
# WHEN
with open(tmp_file.name) as fp:
data = {'file[]': [fp]}
response = self.client.post(reverse('planner_attachments_list'),
data)
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('One of', response.data[0]['non_field_errors'][0])
def test_not_found(self):
userhelper.given_a_user_exists_and_is_authenticated(self.client)
responses = [
self.client.get(reverse('feed_externalcalendars_detail', kwargs={'pk': '9999'})),
self.client.put(reverse('feed_externalcalendars_detail', kwargs={'pk': '9999'}))
]
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())
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_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_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_get_homework(self):
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)
homeworkhelper.given_homework_exists(course1)
homeworkhelper.given_homework_exists(course2)
homeworkhelper.given_homework_exists(course3)
homeworkhelper.given_homework_exists(course3)
# WHEN
response1 = self.client.get(reverse('planner_homework_list'))
response2 = self.client.get(
reverse('planner_coursegroups_courses_homework_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(Homework.objects.count(), 4)
self.assertEqual(len(response1.data), 3)
self.assertEqual(len(response2.data), 2)
def test_password_change_fails_to_meet_requirements(self):
# GIVEN
userhelper.given_a_user_exists_and_is_authenticated(self.client)
# THEN
data = {
'old_password': '******',
'password': '******',
}
response = self.client.put(reverse('auth_user_detail'),
json.dumps(data),
content_type='application/json')
# WHEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('password', response.data)
def test_patch_converts_to_utc(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)
homework = homeworkhelper.given_homework_exists(course)
# WHEN
data = {
'start': '2016-05-08T12:00:00-0500',
'end': '2016-05-08T14:00:00-0500',
}
response = self.client.patch(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)
homework = Homework.objects.get(pk=homework.pk)
self.assertEquals(
homework.start.isoformat(),
parser.parse(data['start']).astimezone(timezone.utc).isoformat())
self.assertEquals(
homework.end.isoformat(),
parser.parse(data['end']).astimezone(timezone.utc).isoformat())
def test_email_changing(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
self.assertEqual(user.email, '*****@*****.**')
self.assertIsNone(user.email_changing)
self.assertEqual(user.username, 'test_user')
# WHEN
data = {
'email': '*****@*****.**',
# Intentionally NOT changing these value
'username': user.username
}
response = self.client.put(reverse('auth_user_detail'), json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['username'], user.username)
self.assertEqual(response.data['email'], user.email)
self.assertEqual(response.data['email_changing'], '*****@*****.**')
user = get_user_model().objects.get(pk=user.id)
self.assertEqual(user.email, response.data['email'])
self.assertEqual(user.email_changing, response.data['email_changing'])
self.assertEqual(user.username, response.data['username'])
def test_get_user(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
# WHEN
response = self.client.get(reverse('auth_user_detail'))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertNotIn('verification_code', response.data)
self.assertEqual(user.username, response.data['username'])
self.assertEqual(user.email, response.data['email'])
self.assertNotIn('phone_verification_code', response.data['profile'])
self.assertEqual(user.profile.phone, response.data['profile']['phone'])
self.assertEqual(user.profile.user.pk, response.data['profile']['user'])
self.assertEqual(user.settings.default_view, response.data['settings']['default_view'])
self.assertEqual(user.settings.week_starts_on, response.data['settings']['week_starts_on'])
self.assertEqual(user.settings.all_day_offset, response.data['settings']['all_day_offset'])
self.assertEqual(user.settings.show_getting_started, response.data['settings']['show_getting_started'])
self.assertEqual(user.settings.events_color, response.data['settings']['events_color'])
self.assertEqual(user.settings.default_reminder_offset, response.data['settings']['default_reminder_offset'])
self.assertEqual(user.settings.default_reminder_offset_type,
response.data['settings']['default_reminder_offset_type'])
self.assertEqual(user.settings.default_reminder_type, response.data['settings']['default_reminder_type'])
self.assertEqual(user.settings.receive_emails_from_admin,
response.data['settings']['receive_emails_from_admin'])
self.assertEqual(user.settings.private_slug, response.data['settings']['private_slug'])
self.assertEqual(user.settings.user.pk, response.data['settings']['user'])
def test_range_query(self):
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
coursehelper.given_course_exists(course_group,
start_date=datetime.date(2016, 5, 8),
end_date=datetime.date(2016, 8, 15))
course2 = coursehelper.given_course_exists(
course_group,
start_date=datetime.date(2016, 8, 15),
end_date=datetime.date(2016, 11, 20))
course3 = coursehelper.given_course_exists(
course_group,
start_date=datetime.date(2017, 1, 8),
end_date=datetime.date(2017, 3, 25))
coursehelper.given_course_exists(course_group,
start_date=datetime.date(2017, 3, 25),
end_date=datetime.date(2017, 8, 15))
response = self.client.get(
reverse('planner_coursegroups_courses_list',
kwargs={'course_group': course_group.pk}) +
'?start_date__gte={}&end_date__lte={}'.format(
course2.start_date.isoformat(), course3.end_date.isoformat()))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
def test_update_start_before_end_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)
homework = homeworkhelper.given_homework_exists(course)
# WHEN
data = {
'start': '2016-05-08T12:00:00Z',
'end': '2016-05-07T14:00:00Z',
}
response = self.client.patch(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_400_BAD_REQUEST)
self.assertIn('must be before', response.data['non_field_errors'][0])
def test_create_course(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
# WHEN
data = {
'title': 'some title',
'room': 'my room',
'credits': 3,
'color': '#7bd148',
'website': 'http://www.mywebsite.com',
'is_online': True,
'teacher_name': 'my teacher',
'teacher_email': '*****@*****.**',
'start_date': '2015-03-05',
'end_date': '2015-07-09',
'course_group': course_group.pk,
# Read-only fields, unused in the POST but used in the validation of this dict afterward
'current_grade': -1,
'trend': None,
}
response = self.client.post(reverse(
'planner_coursegroups_courses_list',
kwargs={'course_group': course_group.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Course.objects.count(), 1)
course = Course.objects.get(pk=response.data['id'])
coursehelper.verify_course_matches_data(self, course, data)
coursehelper.verify_course_matches_data(self, course, response.data)
def test_patch_assumes_naive_datetime_to_utc(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
user.settings.time_zone = 'America/New_York'
user.settings.save()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
homework = homeworkhelper.given_homework_exists(course)
# WHEN
data = {
'start': '2016-05-08 12:00:00',
'end': '2016-05-08 14:00:00',
}
response = self.client.patch(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)
homework = Homework.objects.get(pk=homework.pk)
start = timezone.make_aware(parser.parse(data['start']), timezone.utc)
end = timezone.make_aware(parser.parse(data['end']), timezone.utc)
self.assertEquals(homework.start.isoformat(), start.isoformat())
self.assertEquals(homework.end.isoformat(), end.isoformat())
def test_update_event_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# 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',
'owner_id': '54321'
}
response = self.client.put(reverse('planner_events_detail',
kwargs={'pk': event.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
event = Event.objects.get(pk=event.pk)
eventhelper.verify_event_matches_data(self, event, response.data)
def test_update_invalid_fraction_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)
homework = homeworkhelper.given_homework_exists(course)
# WHEN
response1 = self.client.patch(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': homework.pk
}),
json.dumps({'current_grade': 'not-a-fraction'}),
content_type='application/json')
response2 = self.client.patch(
reverse('planner_coursegroups_courses_homework_detail',
kwargs={
'course_group': course_group.pk,
'course': course.pk,
'pk': homework.pk
}),
json.dumps({'current_grade': 'invalid/4'}),
content_type='application/json')
# THEN
self.assertEqual(response1.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response2.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('current_grade', response1.data)
self.assertIn('current_grade', response2.data)
def test_patch_assumes_naive_datetime_to_utc(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
user.settings.time_zone = 'America/New_York'
user.settings.save()
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'start': '2016-05-08 12:00:00',
'end': '2016-05-08 14:00:00',
}
response = self.client.patch(reverse('planner_events_detail',
kwargs={'pk': event.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
event = Event.objects.get(pk=event.pk)
start = timezone.make_aware(parser.parse(data['start']), pytz.utc)
end = timezone.make_aware(parser.parse(data['end']), pytz.utc)
self.assertEquals(event.start.isoformat(), start.isoformat())
self.assertEquals(event.end.isoformat(), end.isoformat())
def test_range_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)
homeworkhelper.given_homework_exists(
course,
start=datetime.datetime(2017, 5, 8, 16, 0, 0, tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 17, 0, 0, tzinfo=timezone.utc))
homework2 = homeworkhelper.given_homework_exists(
course,
start=datetime.datetime(2017, 5, 8, 17, 0, 0, tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 18, 0, 0, tzinfo=timezone.utc))
homeworkhelper.given_homework_exists(
course,
start=datetime.datetime(2017, 5, 8, 18, 30, 0,
tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 19, 0, 0, tzinfo=timezone.utc))
homework4 = homeworkhelper.given_homework_exists(
course,
start=datetime.datetime(2017, 5, 8, 19, 30, 0,
tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 21, 0, 0, tzinfo=timezone.utc))
response = self.client.get(
reverse('planner_homework_list') +
'?start__gte={}&end__lt={}'.format(
quote(homework2.start.isoformat()),
quote(homework4.end.isoformat())))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
def test_create_converts_to_utc(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
# WHEN
data = {
'title': 'some title',
'all_day': False,
'show_end_time': True,
'start': '2014-05-08T12:00:00-0500',
'end': '2014-05-08T14:00:00-0500',
'priority': 75,
'comments': 'some comment',
# Read-only fields, unused in the POST but used in the validation of this dict afterward
'user': user.pk
}
response = self.client.post(reverse('planner_events_list'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Event.objects.count(), 1)
event = Event.objects.get(pk=response.data['id'])
self.assertEquals(event.start.isoformat(), parser.parse(data['start']).astimezone(timezone.utc).isoformat())
self.assertEquals(event.end.isoformat(), parser.parse(data['end']).astimezone(timezone.utc).isoformat())
