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))
