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='*****@*****.**') event1 = eventhelper.given_event_exists(user1) event2 = eventhelper.given_event_exists(user2) reminder = reminderhelper.given_reminder_exists(user1, event=event1) course_group2 = coursegrouphelper.given_course_group_exists(user2) course2 = coursehelper.given_course_exists(course_group2) homework2 = homeworkhelper.given_homework_exists(course2) # WHEN responses = [ self.client.post(reverse('planner_reminders_list'), json.dumps({'event': event2.pk}), content_type='application/json'), self.client.post(reverse('planner_reminders_list'), json.dumps({'homework': homework2.pk}), content_type='application/json'), self.client.put(reverse('planner_reminders_detail', kwargs={'pk': reminder.pk}), json.dumps({'event': event2.pk}), content_type='application/json'), self.client.put(reverse('planner_reminders_detail', kwargs={'pk': reminder.pk}), json.dumps({'homework': homework2.pk}), content_type='application/json') ] # THEN for response in responses: self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_events_feed(self): # GIVEN user1 = userhelper.given_a_user_exists() user1.settings.enable_private_slug() user2 = userhelper.given_a_user_exists(username='******', email='*****@*****.**') user2.settings.enable_private_slug() event1 = eventhelper.given_event_exists(user1) event2 = eventhelper.given_event_exists(user1) eventhelper.given_event_exists(user2) # WHEN response = self.client.get( reverse("feed_private_events_ical", kwargs={"slug": user1.settings.private_slug})) # THEN calendar = icalendar.Calendar.from_ical( response.content.decode('utf-8')) self.assertEqual(len(calendar.subcomponents), 2) self.assertEqual(calendar.subcomponents[0]['SUMMARY'], event1.title) self.assertEqual(calendar.subcomponents[0]['DESCRIPTION'], "Comments: {}".format(event1.comments)) self.assertEqual(calendar.subcomponents[0]['DTSTART'].dt, event1.start) self.assertEqual(calendar.subcomponents[0]['DTEND'].dt, event1.end) self.assertEqual(calendar.subcomponents[1]['SUMMARY'], event1.title) self.assertEqual(calendar.subcomponents[1]['DTSTART'].dt, event2.start) self.assertEqual(calendar.subcomponents[1]['DTEND'].dt, event2.end) self.assertEqual(calendar.subcomponents[1]['DESCRIPTION'], "Comments: {}".format(event2.comments))
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_title_search_query(self): user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user, title='test1') eventhelper.given_event_exists(user, title='test2') response = self.client.get( reverse('planner_events_list') + '?search=test1') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['title'], event.title)
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_create_event_reminder(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) # WHEN data = { 'title': 'some title', 'message': 'some message', 'offset': 1, 'offset_type': enums.HOURS, 'type': enums.POPUP, 'event': event.pk, # Read-only fields, unused in the POST but used in the validation of this dict afterward 'start_of_range': (event.start - timedelta(hours=1)).isoformat(), 'sent': False, 'user': user.pk } response = self.client.post(reverse('planner_reminders_list'), json.dumps(data), content_type='application/json') # THEN self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Reminder.objects.count(), 1) course = Reminder.objects.get(pk=response.data['id']) reminderhelper.verify_reminder_matches_data(self, course, data) reminderhelper.verify_reminder_matches_data(self, course, response.data)
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_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_update_reminder_by_id(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) reminder = reminderhelper.given_reminder_exists(user, event=event) # WHEN data = { 'title': 'some title', 'message': 'some message', 'offset': 1, 'offset_type': enums.HOURS, 'type': enums.POPUP } response = self.client.put(reverse('planner_reminders_detail', kwargs={'pk': reminder.pk}), json.dumps(data), content_type='application/json') # THEN self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertDictContainsSubset(data, response.data) reminder = Reminder.objects.get(pk=reminder.pk) reminderhelper.verify_reminder_matches_data(self, reminder, response.data)
def test_get_attachments(self): # GIVEN user1 = userhelper.given_a_user_exists() user2 = userhelper.given_a_user_exists_and_is_authenticated( self.client, username='******', email='*****@*****.**') event1 = eventhelper.given_event_exists(user1) event2 = eventhelper.given_event_exists(user2) course_group1 = coursegrouphelper.given_course_group_exists(user1) course_group2 = coursegrouphelper.given_course_group_exists(user2) course1 = coursehelper.given_course_exists(course_group1) course2 = coursehelper.given_course_exists(course_group2) course3 = coursehelper.given_course_exists(course_group2) homework1 = homeworkhelper.given_homework_exists(course1) homework2 = homeworkhelper.given_homework_exists(course2) attachmenthelper.given_attachment_exists(user1, course=course1) attachmenthelper.given_attachment_exists(user2, course=course2) attachmenthelper.given_attachment_exists(user2, course=course3) attachmenthelper.given_attachment_exists(user2, course=course3) attachmenthelper.given_attachment_exists(user1, event=event1) attachmenthelper.given_attachment_exists(user2, event=event2) attachmenthelper.given_attachment_exists(user2, event=event2) attachmenthelper.given_attachment_exists(user1, homework=homework1) attachmenthelper.given_attachment_exists(user2, homework=homework2) attachmenthelper.given_attachment_exists(user2, homework=homework2) # WHEN response1 = self.client.get(reverse('planner_attachments_list')) response2 = self.client.get( reverse('planner_attachments_list') + '?course={}'.format(course3.pk)) response3 = self.client.get( reverse('planner_attachments_list') + '?event={}'.format(event2.pk)) response4 = self.client.get( reverse('planner_attachments_list') + '?homework={}'.format(homework2.pk)) # THEN self.assertEqual(response1.status_code, status.HTTP_200_OK) self.assertEqual(response2.status_code, status.HTTP_200_OK) self.assertEqual(response3.status_code, status.HTTP_200_OK) self.assertEqual(response4.status_code, status.HTTP_200_OK) self.assertEqual(Attachment.objects.count(), 10) self.assertEqual(len(response1.data), 7) self.assertEqual(len(response2.data), 2) self.assertEqual(len(response3.data), 2) self.assertEqual(len(response4.data), 2)
def test_get_event_by_id(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) # WHEN response = self.client.get(reverse('planner_events_detail', kwargs={'pk': event.pk})) # THEN self.assertEqual(response.status_code, status.HTTP_200_OK) eventhelper.verify_event_matches_data(self, event, response.data)
def test_range_query(self): user = userhelper.given_a_user_exists_and_is_authenticated(self.client) eventhelper.given_event_exists( user, start=datetime.datetime(2017, 5, 8, 16, 0, 0, tzinfo=timezone.utc), end=datetime.datetime(2017, 5, 8, 17, 0, 0, tzinfo=timezone.utc)) event2 = eventhelper.given_event_exists( user, start=datetime.datetime(2017, 5, 8, 17, 0, 0, tzinfo=timezone.utc), end=datetime.datetime(2017, 5, 8, 18, 0, 0, tzinfo=timezone.utc)) eventhelper.given_event_exists( user, start=datetime.datetime(2017, 5, 8, 18, 30, 0, tzinfo=timezone.utc), end=datetime.datetime(2017, 5, 8, 19, 0, 0, tzinfo=timezone.utc)) event4 = eventhelper.given_event_exists( user, 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_events_list') + '?start__gte={}&end__lt={}'.format(quote(event2.start.isoformat()), quote(event4.end.isoformat()))) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 2)
def test_get_reminders(self): user1 = userhelper.given_a_user_exists() user2 = userhelper.given_a_user_exists_and_is_authenticated( self.client, username='******', email='*****@*****.**') event1 = eventhelper.given_event_exists(user1) event2 = eventhelper.given_event_exists(user2) course_group1 = coursegrouphelper.given_course_group_exists(user1) course_group2 = coursegrouphelper.given_course_group_exists(user2) course1 = coursehelper.given_course_exists(course_group1) course2 = coursehelper.given_course_exists(course_group2) course3 = coursehelper.given_course_exists(course_group2) homework1 = homeworkhelper.given_homework_exists(course1) homework2 = homeworkhelper.given_homework_exists(course2) homework3 = homeworkhelper.given_homework_exists(course3) homework4 = homeworkhelper.given_homework_exists(course3) reminderhelper.given_reminder_exists(user1, homework=homework1) reminderhelper.given_reminder_exists(user2, homework=homework2) reminderhelper.given_reminder_exists(user2, homework=homework3) reminderhelper.given_reminder_exists(user2, homework=homework4) reminderhelper.given_reminder_exists(user2, homework=homework4) reminderhelper.given_reminder_exists(user1, event=event1) reminderhelper.given_reminder_exists(user2, event=event2) reminderhelper.given_reminder_exists(user2, event=event2) # WHEN response1 = self.client.get(reverse('planner_reminders_list')) response2 = self.client.get( reverse('planner_reminders_list') + f'?homework={homework4.pk}') response3 = self.client.get( reverse('planner_reminders_list') + f'?event={event2.pk}') # THEN self.assertEqual(response1.status_code, status.HTTP_200_OK) self.assertEqual(response2.status_code, status.HTTP_200_OK) self.assertEqual(response3.status_code, status.HTTP_200_OK) self.assertEqual(Reminder.objects.count(), 8) self.assertEqual(len(response1.data), 6) self.assertEqual(len(response2.data), 2) self.assertEqual(len(response3.data), 2)
def test_delete_event_by_id(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) # WHEN response = self.client.delete(reverse('planner_events_detail', kwargs={'pk': event.pk})) # THEN self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertFalse(Event.objects.filter(pk=event.pk).exists()) self.assertEqual(Event.objects.count(), 0)
def test_process_email_reminders(self, mock_send_multipart_email): # GIVEN user = userhelper.given_a_user_exists() course_group = coursegrouphelper.given_course_group_exists(user) course = coursehelper.given_course_exists(course_group) homework = homeworkhelper.given_homework_exists(course) event1 = eventhelper.given_event_exists(user) event2 = eventhelper.given_event_exists( user, start=datetime.datetime.now().replace( tzinfo=pytz.timezone(user.settings.time_zone)) + datetime.timedelta(days=1), end=datetime.datetime.now().replace( tzinfo=pytz.timezone(user.settings.time_zone)) + datetime.timedelta(days=1, hours=1)) reminder1 = reminderhelper.given_reminder_exists(user, type=enums.EMAIL, event=event1) reminder2 = reminderhelper.given_reminder_exists(user, type=enums.EMAIL, homework=homework) # This reminder is ignored, as we're not yet in its send window reminder3 = reminderhelper.given_reminder_exists(user, type=enums.EMAIL, event=event2) # Sent reminders are ignored reminderhelper.given_reminder_exists(user, type=enums.EMAIL, sent=True, event=event1) # WHEN reminderservice.process_email_reminders() # THEN self.assertEqual(mock_send_multipart_email.call_count, 2) self.assertTrue(Reminder.objects.get(pk=reminder1.pk).sent) self.assertTrue(Reminder.objects.get(pk=reminder2.pk).sent) self.assertFalse(Reminder.objects.get(pk=reminder3.pk).sent)
def test_create_bad_data(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) reminderhelper.given_reminder_exists(user, event=event) # WHEN data = {'offset': 'asdf'} response = self.client.post(reverse('planner_reminders_list'), json.dumps(data), content_type='application/json') # THEN self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertIn('offset', response.data)
def test_update_bad_data(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) # WHEN data = { 'start': 'not-a-valid-date' } 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_400_BAD_REQUEST) self.assertIn('start', response.data)
def test_events_for_user(self): # GIVEN user1 = userhelper.given_a_user_exists() user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******', email='*****@*****.**') eventhelper.given_event_exists(user1) eventhelper.given_event_exists(user2) eventhelper.given_event_exists(user2) eventhelper.given_event_exists(user2) self.assertEqual(Event.objects.count(), 4) # WHEN response = self.client.delete(reverse('planner_events_resource_delete')) # THEN self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(Event.objects.count(), 1) self.assertEqual(Event.objects.for_user(user2.pk).count(), 0)
def test_update_start_before_end_fails(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) # WHEN data = { 'start': '2016-05-08T12:00:00Z', 'end': '2016-05-07T14:00:00Z', } 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_400_BAD_REQUEST) self.assertIn('must be before', response.data['non_field_errors'][0])
def test_update_read_only_field_does_nothing(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) reminder = reminderhelper.given_reminder_exists(user, event=event) start_of_range = reminder.start_of_range # WHEN data = {'start_of_range': '2014-05-08T12:00:00Z'} response = self.client.put(reverse('planner_reminders_detail', kwargs={'pk': reminder.pk}), json.dumps(data), content_type='application/json') # THEN self.assertEqual(response.status_code, status.HTTP_200_OK) reminder = Reminder.objects.get(pk=reminder.id) self.assertEqual(reminder.start_of_range, start_of_range)
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) event_reminder = reminderhelper.given_reminder_exists(user1, event=event) course_group = coursegrouphelper.given_course_group_exists(user1) course = coursehelper.given_course_exists(course_group) homework = homeworkhelper.given_homework_exists(course) reminderhelper.given_reminder_exists(user1, homework=homework) # WHEN responses = [ self.client.get( reverse('planner_reminders_list') + f'?event={event.pk}'), self.client.get( reverse('planner_reminders_list') + f'?homework={homework.pk}'), self.client.get( reverse('planner_reminders_detail', kwargs={'pk': event_reminder.pk})), self.client.put( reverse('planner_reminders_detail', kwargs={'pk': event_reminder.pk})), self.client.delete( reverse('planner_reminders_detail', kwargs={'pk': event_reminder.pk})) ] # THEN self.assertTrue( Reminder.objects.filter(pk=event_reminder.pk, 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_update_reminder_parent_updates(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) event = eventhelper.given_event_exists(user) reminder = reminderhelper.given_reminder_exists(user, event=event) # WHEN data = {'homework': homework.pk} response = self.client.patch(reverse('planner_reminders_detail', kwargs={'pk': reminder.pk}), json.dumps(data), content_type='application/json') # THEN self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data['homework'], homework.pk) self.assertIsNone(response.data['event'])
def test_patch_converts_to_utc(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) # WHEN data = { 'start': '2016-05-08T12:00:00-0500', 'end': '2016-05-08T14:00:00-0500', } 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) 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())
def test_get_events(self): user1 = userhelper.given_a_user_exists() user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******', email='*****@*****.**') eventhelper.given_event_exists(user1) eventhelper.given_event_exists(user2) eventhelper.given_event_exists(user2) # WHEN response = self.client.get(reverse('planner_events_list')) # THEN self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(Event.objects.count(), 3) self.assertEqual(len(response.data), 2)
def test_parent_change_triggers_reminder_update(self): # GIVEN user = userhelper.given_a_user_exists() event = eventhelper.given_event_exists(user) course_group = coursegrouphelper.given_course_group_exists(user) course = coursehelper.given_course_exists(course_group) homework = homeworkhelper.given_homework_exists(course) reminder1 = reminderhelper.given_reminder_exists(user, event=event) reminder2 = reminderhelper.given_reminder_exists(user, homework=homework) # WHEN event.start = datetime.datetime(2019, 5, 8, 12, 0, 0, tzinfo=timezone.utc) event.save() homework.start = datetime.datetime(2019, 1, 8, 10, 0, 0, tzinfo=timezone.utc) homework.save() # THEN reminder1 = Reminder.objects.get(pk=reminder1.id) reminder2 = Reminder.objects.get(pk=reminder2.id) self.assertEqual(reminder1.start_of_range, datetime.datetime(2019, 5, 8, 11, 45, 0, tzinfo=timezone.utc)) self.assertEqual(reminder2.start_of_range, datetime.datetime(2019, 1, 8, 9, 45, 0, tzinfo=timezone.utc))
def test_access_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='*****@*****.**') event = eventhelper.given_event_exists(user1) 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) homework = homeworkhelper.given_homework_exists(course1) attachment1 = attachmenthelper.given_attachment_exists(user1, course=course1) attachmenthelper.given_attachment_exists(user1, homework=homework) attachmenthelper.given_attachment_exists(user1, event=event) # WHEN responses = [ self.client.get( reverse('planner_attachments_list') + '?course={}'.format(course1.pk)), self.client.get( reverse('planner_attachments_list') + '?event={}'.format(event.pk)), self.client.get( reverse('planner_attachments_list') + '?homework={}'.format(homework.pk)), self.client.delete( reverse('planner_attachments_detail', kwargs={'pk': attachment1.pk})) ] # THEN 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_create_reminder_multiple_parents_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) event = eventhelper.given_event_exists(user) # WHEN data = { 'title': 'some title', 'message': 'some message', 'start_of_range': '2014-05-08T12:00:00Z', 'offset': 1, 'offset_type': enums.HOURS, 'type': enums.POPUP, 'homework': homework.pk, 'event': event.pk, } response = self.client.post(reverse('planner_reminders_list'), data) # THEN self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertIn('Only one of', response.data['non_field_errors'][0])
def test_create_event_attachment(self): # GIVEN user = userhelper.given_a_user_exists_and_is_authenticated(self.client) event = eventhelper.given_event_exists(user) tmp_file = attachmenthelper.given_file_exists() # WHEN with open(tmp_file.name) as fp: data = {'event': event.pk, 'file[]': [fp]} response = self.client.post(reverse('planner_attachments_list'), data) # THEN self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['title'], os.path.basename(tmp_file.name)) self.assertEqual(response.data[0]['size'], os.path.getsize(tmp_file.name)) self.assertEqual(response.data[0]['event'], data['event']) self.assertEqual(Attachment.objects.count(), 1) attachment = Attachment.objects.get(pk=response.data[0]['id']) attachmenthelper.verify_attachment_matches_data( self, attachment, response.data[0])