def test_delete_externalcalendar_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(user)
externalcalendarhelper.given_external_calendar_exists(user)
# WHEN
response = self.client.delete(reverse('feed_externalcalendars_detail', kwargs={'pk': external_calendar.pk}))
# THEN
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(ExternalCalendar.objects.filter(pk=external_calendar.pk).exists())
self.assertEqual(ExternalCalendar.objects.count(), 1)
def test_error_on_object_owned_by_another_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
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_update_externalcalendar_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(
user)
self.assertEqual(external_calendar.title, 'My Calendar')
self.assertTrue(external_calendar.shown_on_calendar)
# WHEN
data = {
'title': 'new title',
'shown_on_calendar': False,
# Intentionally NOT changing these value
'url': external_calendar.url
}
response = self.client.put(reverse('feed_externalcalendars_detail',
kwargs={'pk':
external_calendar.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
external_calendar = ExternalCalendar.objects.get(
pk=external_calendar.id)
externalcalendarhelper.verify_externalcalendar_matches_data(
self, external_calendar, 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_get_externalcalendar_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(user)
# WHEN
response = self.client.get(reverse('feed_externalcalendars_detail', kwargs={'pk': external_calendar.pk}))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
externalcalendarhelper.verify_externalcalendar_matches_data(self, external_calendar, response.data)
def test_get_external_calendar_invalid_ical(self, mock_urlopen):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(
user)
icalfeedhelper.given_urlopen_mock_from_file(
os.path.join('resources', 'bad.ical'), mock_urlopen)
# WHEN
response = self.client.get(
reverse('feed_resource_externalcalendars_events',
kwargs={'pk': external_calendar.pk}))
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("valid ICAL", response.data[0])
external_calendar = ExternalCalendar.objects.get(
pk=external_calendar.pk)
self.assertFalse(external_calendar.shown_on_calendar)
def test_get_external_calendar_cached(self, mock_urlopen):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(
user)
icalfeedhelper.given_urlopen_mock_from_file(
os.path.join('resources', 'sample.ical'), mock_urlopen)
# WHEN
response_db = self.client.get(
reverse('feed_resource_externalcalendars_events',
kwargs={'pk': external_calendar.pk}))
with mock.patch('helium.feed.services.icalexternalcalendarservice._create_events_from_calendar') as \
_create_events_from_calendar:
response_cached = self.client.get(
reverse('feed_resource_externalcalendars_events',
kwargs={'pk': external_calendar.pk}))
# THEN
self.assertEqual(response_db.status_code, status.HTTP_200_OK)
self.assertEqual(response_cached.status_code, status.HTTP_200_OK)
self.assertEqual(_create_events_from_calendar.call_count, 0)
self.assertEqual(len(response_db.data), len(response_cached.data))
self.assertEqual(response_db.data[0]['title'],
response_cached.data[0]['title'])
self.assertEqual(response_db.data[0]['all_day'],
response_cached.data[0]['all_day'])
self.assertEqual(response_db.data[0]['show_end_time'],
response_cached.data[0]['show_end_time'])
self.assertEqual(response_db.data[0]['start'],
response_cached.data[0]['start'])
self.assertEqual(response_db.data[0]['end'],
response_cached.data[0]['end'])
self.assertEqual(response_db.data[0]['priority'],
response_cached.data[0]['priority'])
self.assertEqual(response_db.data[0]['url'],
response_cached.data[0]['url'])
self.assertEqual(response_db.data[0]['comments'],
response_cached.data[0]['comments'])
self.assertEqual(response_db.data[0]['user'],
response_cached.data[0]['user'])
self.assertEqual(response_db.data[0]['calendar_item_type'],
response_cached.data[0]['calendar_item_type'])
def test_update_invalid_url_disables_calendar(self, mock_urlopen):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(user)
commonhelper.given_urlopen_response_value(status.HTTP_404_NOT_FOUND, mock_urlopen)
# WHEN
data = {
'url': 'http://www.not-a-valid-ical-url.com/nope',
# Intentionally NOT changing these value
'title': external_calendar.title
}
response = self.client.put(reverse('feed_externalcalendars_detail', kwargs={'pk': external_calendar.pk}),
json.dumps(data), content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['url'], data['url'])
self.assertFalse(response.data['shown_on_calendar'])
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='*****@*****.**')
external_calendar = externalcalendarhelper.given_external_calendar_exists(user2)
# WHEN
data = {
'user': user1.pk,
# Intentionally NOT changing these value
'title': external_calendar.title,
'url': external_calendar.url
}
response = self.client.put(reverse('feed_externalcalendars_detail', kwargs={'pk': external_calendar.pk}),
json.dumps(data), content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(external_calendar.user.pk, user2.pk)
def test_get_externalcalendars(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
externalcalendarhelper.given_external_calendar_exists(user1)
externalcalendarhelper.given_external_calendar_exists(user2)
externalcalendarhelper.given_external_calendar_exists(user2)
# WHEN
response = self.client.get(reverse('feed_externalcalendars_list'))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(ExternalCalendar.objects.count(), 3)
self.assertEqual(len(response.data), 2)
def test_get_external_calendar_as_events(self, mock_urlopen):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(
user)
icalfeedhelper.given_urlopen_mock_from_file(
os.path.join('resources', 'sample.ical'), mock_urlopen)
# WHEN
response = self.client.get(
reverse('feed_resource_externalcalendars_events',
kwargs={'pk': external_calendar.pk}))
# THEN
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['title'], 'test1')
self.assertEqual(response.data[0]['all_day'], False)
self.assertEqual(response.data[0]['show_end_time'], True)
self.assertEqual(response.data[0]['start'], '2017-08-02T17:34:00Z')
self.assertEqual(response.data[0]['end'], '2017-08-02T18:04:00Z')
self.assertEqual(response.data[0]['priority'], 50)
self.assertEqual(response.data[0]['url'],
'http://www.some-test-url.com')
self.assertEqual(response.data[0]['comments'], 'test1 description')
self.assertEqual(response.data[0]['user'], user.pk)
self.assertEqual(response.data[0]['calendar_item_type'],
enums.EXTERNAL)
self.assertEqual(response.data[1]['title'], 'New Year\'s Day')
self.assertEqual(response.data[1]['all_day'], True)
self.assertEqual(response.data[1]['show_end_time'], False)
self.assertEqual(response.data[1]['start'], '2017-01-01T08:00:00Z')
self.assertEqual(response.data[1]['end'], '2017-01-02T08:00:00Z')
self.assertEqual(response.data[1]['priority'], 50)
self.assertEqual(response.data[1]['url'], None)
self.assertEqual(response.data[1]['comments'], 'all day event test')
self.assertEqual(response.data[1]['user'], user.pk)
self.assertEqual(response.data[1]['calendar_item_type'],
enums.EXTERNAL)
def test_update_invalid_ical(self, mock_urlopen):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
external_calendar = externalcalendarhelper.given_external_calendar_exists(
user)
icalfeedhelper.given_urlopen_mock_from_file(
os.path.join('resources', 'bad.ical'), mock_urlopen)
# WHEN
data = {
'url': 'http://www.example.com/bad-ical',
# Intentionally NOT changing these value
'title': external_calendar.title
}
response = self.client.put(reverse('feed_externalcalendars_detail',
kwargs={'pk':
external_calendar.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['url'], data['url'])
self.assertFalse(response.data['shown_on_calendar'])