def setUp(self, *args, **kwargs): rval = super().setUp(*args, **kwargs) self.old_sf = create_submission_form() self.new_sf = create_submission_form() # both submission forms have to belong to the same submission self.new_sf.submission.current_submission_form = None self.new_sf.submission.save() self.new_sf.submission = self.old_sf.submission self.new_sf.save() return rval
def setUp(self): super().setUp() self.anyone = self._create_test_user('anyone') self.board_member_user = self._create_test_user('board_member', is_board_member=True) self.internal_user = self._create_test_user('internal', is_internal=True) self.primary_investigator_user = self._create_test_user( 'primary_investigator') self.sponsor_user = self._create_test_user('sponsor') self.submitter_user = self._create_test_user('submitter') self.another_board_member_user = self._create_test_user( 'another_board_member', is_board_member=True) sf = create_submission_form() sf.submitter = self.submitter_user sf.sponsor = self.sponsor_user sf.project_title = self.EC_NUMBER sf.save() investigator = sf.investigators.all()[0] investigator.user = self.primary_investigator_user investigator.save() sf.submission.ec_number = self.EC_NUMBER meeting = Meeting.objects.create(start=timezone.now()) entry = meeting.add_entry(submission=sf.submission, duration=timedelta(seconds=60)) entry.participations.create(user=self.board_member_user) sf.submission.next_meeting = meeting sf.submission.save() self.sf = sf
def test_readonly_submission_form(self): '''Tests if the readonly submissionform is accessible. ''' submission_form = create_submission_form() response = self.client.get( reverse('readonly_submission_form', kwargs={'submission_form_pk': submission_form.pk})) self.assertEqual(response.status_code, 200)
def test_submission_pdf(self): '''Tests if a pdf can be produced out of a pre existing submissionform. ''' submission_form = create_submission_form() response = self.client.get( reverse('ecs.core.views.submissions.submission_form_pdf', kwargs={'submission_form_pk': submission_form.pk})) self.assertEqual(response.status_code, 200) self.assertEqual(response['Content-Type'], 'application/pdf') self.assertEqual(next(response.streaming_content)[:5], b'%PDF-')
def test_document_download(self): submission_form = create_submission_form() document_pk = submission_form.documents.get().pk response = self.client.get( reverse('ecs.core.views.submissions.download_document', kwargs={ 'submission_form_pk': submission_form.pk, 'document_pk': document_pk })) self.assertEqual(response.status_code, 200) self.assertEqual(response['Content-Type'], 'application/pdf') self.assertEqual(next(response.streaming_content)[:5], b'%PDF-')
def test_submission_form_search(self): '''Tests if all submissions are searchable via the keyword argument. Tests that the correct count of submissions is returned by the search function. ''' create_submission_form(20200001) create_submission_form(20200042) create_submission_form(20209942) url = reverse('ecs.core.views.submissions.all_submissions') response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertEqual( len([ x for x in response.context['submissions'].object_list if not x.timetable_entries.count() ]), 3) response = self.client.get(url, {'keyword': '42'}) self.assertTrue(response.status_code, 200) self.assertEqual( len([ x for x in response.context['submissions'].object_list if not x.timetable_entries.exists() ]), 1) response = self.client.get(url, {'keyword': '42/2020'}) self.assertTrue(response.status_code, 200) self.assertEqual( len([ x for x in response.context['submissions'].object_list if not x.timetable_entries.exists() ]), 1)
def test_initial_review(self): submission_form = create_submission_form(presenter=self.user) self.client.logout() self.client.login(email=self.office_user.email, password='******') task = Task.objects.for_data(submission_form.submission).get( task_type__workflow_node__uid='initial_review') refetch = lambda: Task.objects.get(pk=task.pk) # accept initial review task response = self.client.post( reverse('ecs.tasks.views.accept_task', kwargs={'task_pk': task.pk})) self.assertEqual(response.status_code, 302) task = refetch() self.assertEqual(self.office_user, task.assigned_to) url = task.url response = self.client.get(url) self.assertEqual(response.status_code, 200) # delegate the task back to the pool reponse = self.client.post( url, { 'task_management-action': 'delegate', 'task_management-assign_to': '', 'task_management-submit': 'submit' }) task = refetch() self.assertEqual(None, task.assigned_to) # accept the task again response = self.client.post( reverse('ecs.tasks.views.accept_task', kwargs={'task_pk': task.pk})) self.assertEqual(response.status_code, 302) task = refetch() self.assertEqual(self.office_user, task.assigned_to) # complete the task reponse = self.client.post( url, { 'task_management-action': 'complete_0', 'task_management-submit': 'submit' }) task = refetch() self.assertTrue(task.closed_at is not None) self.client.logout() self.client.login(email=self.user.email, password='******')
def test_submission_data_for_notification(self): '''Tests if the submission_data_for_notification view is accessible for a created notification for a submission. ''' notification_type, _ = NotificationType.objects.get_or_create( name='foo notif') notification = Notification.objects.create(type=notification_type) submission_form = create_submission_form() response = self.client.get( reverse( 'ecs.notifications.views.submission_data_for_notification'), {'submission_form': submission_form.pk}) self.assertEqual(response.status_code, 200)
def test_notification_form(self): '''Tests notification creation and autosave mode. Further tests if notification can be saved, submited with incomplete data and finally if the correct redirect happens if submitted with complete data. ''' notification_type = NotificationType.objects.create(name='foo notif') # GET the form and expect a docstash transactions redirect, then follow this redirect response = self.client.get( reverse('ecs.notifications.views.create_notification', kwargs={'notification_type_pk': notification_type.pk})) self.assertEqual(response.status_code, 302) url = response['Location'] response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertTrue(b'foo notif' in response.content) self.assertTrue(b'<form' in response.content) # POST the form in `autosave` mode response = self.client.post( url, self._create_POST_data(autosave='autosave')) self.assertEqual(response.status_code, 200) self.assertFalse(b'<form' in response.content) # POST the form in `save` mode response = self.client.post( url, self._create_POST_data(save='save', comments='bar comment')) self.assertEqual(response.status_code, 200) self.assertFalse(b'<form' in response.content) # POST the form in `submit` mode (incomplete data) response = self.client.post(url, self._create_POST_data(submit='submit')) self.assertEqual(response.status_code, 200) self.assertTrue(b'<form' in response.content) form = response.context['form'] self.assertEqual(form['comments'].data, 'foo comment') # POST the form in `submit` mode (complete data) and follow the redirect submission_form = create_submission_form() response = self.client.post( url, self._create_POST_data(submit='submit', submission_forms=submission_form.pk)) self.assertEqual(response.status_code, 302) view_url = response['Location'] response = self.client.get(view_url) obj = response.context['notification'] self.assertEqual(obj.comments, 'foo comment') self.assertEqual(obj.submission_forms.all()[0], submission_form)
def test_automatic_meeting_assignment(self): '''Tests the scheduling mechanism for meetings by scheduling and unscheduling meetings and then checking for the next meeting. ''' s = create_submission_form().submission step = timedelta(days=1) start = timezone.now() + step meetings = [Meeting.objects.create(start=start + step * i, title="M%s" % i) for i in range(3)] def schedule(i): meetings[i].add_entry(submission=s, duration=timedelta(hours=1)) def unschedule(i): meetings[i].timetable_entries.all().delete() def check_next(i): try: next_meeting = s.meetings.order_by('start')[0] except IndexError: next_meeting = None self.assertEqual(next_meeting, None if i is None else meetings[i]) schedule(1) check_next(1) schedule(2) check_next(1) unschedule(1) check_next(2) unschedule(2) check_next(None) schedule(2) check_next(2) schedule(0) check_next(0) schedule(1) check_next(0) schedule(2) check_next(0) unschedule(0) check_next(1)
def test_meeting_assistant(self): '''Makes sure that the meeting assistant is fully functional. Tests that the meeting assistant starts and stops meetings correctly. ''' meeting = Meeting.objects.create(start=self.start) submission = create_submission_form().submission e0 = meeting.add_entry(duration=timedelta(seconds=42), submission=submission) e1 = meeting.add_entry(duration=timedelta(seconds=42*42)) response = self.client.get(reverse('ecs.meetings.views.meeting_assistant', kwargs={'meeting_pk': meeting.pk})) self.assertEqual(response.status_code, 200) response = self.client.get(reverse('ecs.meetings.views.meeting_assistant_start', kwargs={'meeting_pk': meeting.pk})) self.assertEqual(response.status_code, 302) meeting = self.refetch(meeting) self.assertTrue(meeting.started) response = self.client.get(reverse('ecs.meetings.views.meeting_assistant', kwargs={'meeting_pk': meeting.pk})) self.assertEqual(response.status_code, 302) response = self.client.get(reverse('ecs.meetings.views.meeting_assistant_top', kwargs={'meeting_pk': meeting.pk, 'top_pk': e0.pk})) self.assertEqual(response.status_code, 200) response = self.client.post(reverse('ecs.meetings.views.meeting_assistant_top', kwargs={'meeting_pk': meeting.pk, 'top_pk': e0.pk}), { 'close_top': 'on', 'result': '1', }) self.assertTrue(response.status_code, 302) self.assertFalse(self.refetch(e0).is_open) response = self.client.get(reverse('ecs.meetings.views.meeting_assistant_stop', kwargs={'meeting_pk': meeting.pk})) self.assertEqual(response.status_code, 404) response = self.client.post(reverse('ecs.meetings.views.meeting_assistant_top', kwargs={'meeting_pk': meeting.pk, 'top_pk': e1.pk}), { 'close_top': 'on', 'result': '2', }) self.assertTrue(response.status_code, 302) self.assertFalse(self.refetch(e1).is_open) response = self.client.get(reverse('ecs.meetings.views.meeting_assistant_stop', kwargs={'meeting_pk': meeting.pk})) self.assertEqual(response.status_code, 302) meeting = self.refetch(meeting) self.assertTrue(meeting.ended)
def test_document_download_anyone(self): submission_form = create_submission_form() document_pk = submission_form.documents.get().pk user, created = get_or_create_user('*****@*****.**') user.set_password('password') user.save() self.client.logout() self.client.login(email='*****@*****.**', password='******') response = self.client.get( reverse('ecs.core.views.submissions.download_document', kwargs={ 'submission_form_pk': submission_form.pk, 'document_pk': document_pk })) self.assertEqual(response.status_code, 404)
def test_submission_form_copy(self): '''Tests if a submissionform can be copied. Compares initial version against copied version. ''' submission_form = create_submission_form(presenter=self.user) response = self.client.get( reverse('ecs.core.views.submissions.copy_latest_submission_form', kwargs={'submission_pk': submission_form.submission.pk})) self.assertEqual(response.status_code, 302) url = reverse('ecs.core.views.submissions.copy_submission_form', kwargs={'submission_form_pk': submission_form.pk}) self.assertEqual(url, urlsplit(response['Location']).path) response = self.client.get(url) self.assertEqual(response.status_code, 302) target_url = response['Location'] response = self.client.get(target_url) self.assertEqual(response.status_code, 200) self.assertEqual(response.context['form'].initial.get('project_title'), submission_form.project_title)
def setUp(self, *args, **kwargs): super().setUp(*args, **kwargs) # alice is the submitter and bob is the default contact AdvancedSettings.objects.filter(pk=1).update(default_contact=self.bob) # there has to be a test submission submission_form = create_submission_form() submission_form.submitter_email = self.alice.email submission_form.save() self.submission_form = submission_form self.threads = submission_form.submission.thread_set now = timezone.now() self.vote = Vote.objects.create(submission_form=submission_form, result='1', published_at=now, valid_until=now + timedelta(days=365)) self.vote_b2 = Vote.objects.create(submission_form=submission_form, result='2', published_at=now)
def test_vote_extension_workflow(self): from django.contrib.auth.models import Group call_command('bootstrap') now = timezone.now() nt = NotificationType.objects.get( form='ecs.notifications.forms.ProgressReportNotificationForm') presenter = self.create_user('test_presenter') office = self.create_user('test_office', profile_extra={'is_internal': True}) office.groups.add(Group.objects.get(name='EC-Office')) executive = self.create_user('text_executive', profile_extra={ 'is_internal': True, 'is_executive': True }) executive.groups.add( Group.objects.get(name='EC-Executive'), Group.objects.get(name='EC-Office'), ) sf = create_submission_form(presenter=presenter) with self.login('test_presenter'): response = self.client.get( reverse('ecs.notifications.views.create_notification', kwargs={'notification_type_pk': nt.pk})) url = response['Location'] # docstash redirect # no vote yet => we cannot select the submission form response = self.client.get(url) self.assertFalse( response.context['form'].fields['submission_form'].queryset. filter(pk=sf.pk).exists()) # create a permanent final postive vote vote = sf.votes.create(result='1', is_final_version=True, signed_at=now, published_at=now, valid_until=now.replace(year=now.year + 1)) # now we have a vote => submission form is selectable response = self.client.get(url) self.assertTrue(response.context['form'].fields['submission_form']. queryset.filter(pk=sf.pk).exists()) # create a notification, request a vote extension response = self.client.post( url, { 'submission_form': sf.pk, 'extension_of_vote_requested': 'on', 'runs_till': '12.12.2012', 'submit': 'on', 'SAE_count': '0', 'SUSAR_count': '0', 'study_started': 'on', 'comments': 'foo', }) self.assertEqual(response.status_code, 302) notification = self.client.get( response['Location']).context['notification'] def do_review(user, action='complete'): response = self.client.get( reverse('ecs.tasks.views.my_tasks', kwargs={'submission_pk': sf.submission.pk})) task = response.context['open_tasks'].get( data_id=notification.pk, content_type=ContentType.objects.get_for_model( ProgressReportNotification), ) task.accept(user) response = self.client.get(task.url) self.assertEqual(response.status_code, 200) response = self.client.post( task.url, { 'task_management-submit': 'Abschicken', 'task_management-action': action, 'task_management-post_data': 'text=Test.', }) self.assertEqual(response.status_code, 302) # office review with self.login('test_office'): do_review(office) # executive review with self.login('text_executive'): do_review(executive, 'complete_0') notification = ProgressReportNotification.objects.get( pk=notification.pk) old_valid_until = vote.valid_until vote = Vote.objects.get(pk=vote.pk) self.assertEqual(vote.valid_until, old_valid_until + timedelta(365))