def setUp(self):
self.pi_user = blend_user()
self.ci_user = blend_user()
proposal = mixer.blend(Proposal)
Membership.objects.create(user=self.pi_user, proposal=proposal, role=Membership.PI)
Membership.objects.create(user=self.ci_user, proposal=proposal, role=Membership.CI)
self.proposal_invite = ProposalInvite.objects.create(
proposal=proposal,
role=Membership.CI,
email='*****@*****.**',
sent=timezone.now(),
used=None
)
def setUp(self):
self.user = blend_user(user_params=dict(
username='******',
email='*****@*****.**'
))
self.user.set_password('sopassword')
self.user.save()
def test_proposal_table_not_staff(self):
user = blend_user()
self.client.force_login(user)
response = self.client.get(
reverse('proposals:semester-admin', kwargs={'pk': self.semester.id})
)
self.assertEqual(response.status_code, 403)
def test_staff_dont_need_to_accept(self):
user = blend_user(user_params={'is_staff': True, 'is_superuser': True})
user.profile.terms_accepted = None
user.profile.save()
self.client.force_login(user)
response = self.client.get(reverse('userrequests:list'))
self.assertContains(response, 'Submitted Requests')
def test_user_has_not_accepted_terms(self):
user = blend_user()
user.profile.terms_accepted = None
user.profile.save()
self.client.force_login(user)
response = self.client.get(reverse('userrequests:list'))
self.assertRedirects(response, reverse('accept-terms'))
def test_cannot_invite_to_other_proposal(self):
self.client.force_login(blend_user())
response = self.client.post(
reverse('proposals:invite', kwargs={'pk': self.proposal.id}),
data={'email': '*****@*****.**'},
follow=True
)
self.assertEqual(response.status_code, 404)
self.assertFalse(ProposalInvite.objects.filter(email='*****@*****.**', proposal=self.proposal).exists())
def setUp(self):
self.user = blend_user()
self.proposal = mixer.blend(Proposal)
mixer.blend(Membership, proposal=self.proposal, user=self.user)
self.userrequest = mixer.blend(UserRequest, proposal=self.proposal, group_id=mixer.RANDOM)
self.request = mixer.blend(Request, user_request=self.userrequest)
mixer.blend(Molecule, request=self.request, instrument_name='1M0-SCICAM-SBIG')
self.client.force_login(self.user)
super().setUp()
def test_cannot_view_others_details(self):
other_user = blend_user()
app = mixer.blend(ScienceApplication,
status=ScienceApplication.DRAFT,
submitter=other_user,
call=self.call)
response = self.client.get(
reverse('sciapplications:detail', kwargs={'pk': app.id}))
self.assertEqual(response.status_code, 404)
def test_staff_can_view_details(self):
staff_user = blend_user(user_params={'is_staff': True})
self.client.force_login(staff_user)
app = mixer.blend(ScienceApplication,
status=ScienceApplication.DRAFT,
submitter=self.user,
call=self.call)
response = self.client.get(
reverse('sciapplications:detail', kwargs={'pk': app.id}))
self.assertContains(response, app.title)
def test_no_proposals_for_semester(self):
user = blend_user()
semester = mixer.blend(Semester, id='2016A')
other_semester = mixer.blend(Semester, id='2017A')
proposal = mixer.blend(Proposal)
mixer.blend(TimeAllocation, semester=semester)
mixer.blend(Membership, user=user, proposal=proposal)
self.client.force_login(user)
response = self.client.get(reverse('proposals:list') + '?semester={}'.format(other_semester.id))
self.assertContains(response, 'No proposals for this semester.')
def test_terms_not_accepted(self):
user = blend_user()
user.profile.terms_accepted = None
user.profile.save()
self.client.force_login(user)
form_data = {'accept': False}
response = self.client.post(reverse('accept-terms'), data=form_data, follow=True)
self.assertContains(response, 'Accept Terms')
user.profile.refresh_from_db()
self.assertFalse(user.profile.terms_accepted)
def test_terms_accepted(self):
user = blend_user()
user.profile.terms_accepted = None
user.profile.save()
self.client.force_login(user)
form_data = {'accept': True}
response = self.client.post(reverse('accept-terms'), data=form_data, follow=True)
self.assertRedirects(response, reverse('userrequests:list'))
user.profile.refresh_from_db()
self.assertTrue(user.profile.terms_accepted)
def test_cannot_set_global_limit_other_proposal(self):
self.client.force_login(self.pi_user)
other_user = blend_user()
other_proposal = mixer.blend(Proposal)
membership = mixer.blend(Membership, user=other_user, proposal=other_proposal)
response = self.client.post(
reverse('proposals:membership-global', kwargs={'pk': other_proposal.id}),
data={'time_limit': 2},
)
self.assertEqual(response.status_code, 404)
self.assertEqual(membership.time_limit, -1)
def setUp(self):
self.semester = mixer.blend(Semester,
start=timezone.now() + timedelta(days=1),
end=timezone.now() + timedelta(days=365))
self.user = blend_user()
self.client.force_login(self.user)
self.call = mixer.blend(Call,
semester=self.semester,
deadline=timezone.now() + timedelta(days=7),
proposal_type=Call.SCI_PROPOSAL)
mixer.blend(Instrument, call=self.call)
def test_cannot_delete_others(self):
other_user = blend_user()
app = mixer.blend(ScienceApplication,
status=ScienceApplication.DRAFT,
submitter=other_user,
call=self.call)
response = self.client.post(reverse('sciapplications:delete',
kwargs={'pk': app.id}),
data={'submit': 'Confirm'},
follow=True)
self.assertEqual(response.status_code, 404)
self.assertTrue(ScienceApplication.objects.filter(pk=app.id).exists())
def test_cannot_set_others_limit(self):
self.client.force_login(self.pi_user)
other_user = blend_user()
other_proposal = mixer.blend(Proposal)
membership = Membership.objects.create(user=other_user, proposal=other_proposal)
response = self.client.post(
reverse('proposals:membership-limit', kwargs={'pk': membership.id}),
data={'time_limit': 300},
)
membership.refresh_from_db()
self.assertEqual(response.status_code, 404)
self.assertEqual(membership.time_limit, -1)
def test_ci_cannot_remove_ci(self):
other_user = blend_user()
other_cim = mixer.blend(Membership, user=other_user, proposal=self.proposal)
self.client.force_login(self.ci_user)
self.assertEqual(self.proposal.membership_set.count(), 3)
response = self.client.post(
reverse('proposals:membership-delete', kwargs={'pk': other_cim.id}),
data={'submit': 'Confirm'},
follow=True
)
self.assertEqual(response.status_code, 404)
self.assertEqual(self.proposal.membership_set.count(), 3)
def setUp(self):
super().setUp()
self.profile = blend_user(profile_params={'notifications_enabled': True}).profile
self.data = {
'first_name': self.profile.user.first_name,
'last_name': self.profile.user.last_name,
'email': self.profile.user.email,
'username': self.profile.user.username,
'institution': self.profile.institution,
'title': self.profile.title,
'notifications_enabled': self.profile.notifications_enabled
}
self.client.force_login(self.profile.user)
def setUp(self):
self.user = blend_user()
self.proposals = mixer.cycle(3).blend(Proposal)
for proposal in self.proposals:
mixer.blend(Membership, proposal=proposal, user=self.user)
self.userrequests = mixer.cycle(3).blend(
UserRequest,
proposal=(p for p in self.proposals)
)
self.requests = mixer.cycle(3).blend(
Request,
user_request=(ur for ur in self.userrequests),
)
self.client.force_login(self.user)
def test_staff_can_view_pdf(self):
PdfFileMerger.merge = MagicMock
HTML.write_pdf = MagicMock
staff_user = blend_user(user_params={'is_staff': True})
self.client.force_login(staff_user)
self.client.force_login(staff_user)
app = mixer.blend(ScienceApplication,
status=ScienceApplication.DRAFT,
submitter=self.user,
call=self.call)
response = self.client.get(
reverse('sciapplications:pdf', kwargs={'pk': app.id}))
self.assertTrue(PdfFileMerger.merge.called)
self.assertTrue(HTML.write_pdf.called)
self.assertEqual(response.status_code, 200)
def setUp(self):
self.semester = mixer.blend(Semester,
start=timezone.now() + timedelta(days=1),
end=timezone.now() + timedelta(days=365))
self.user = blend_user()
self.client.force_login(self.user)
self.call = mixer.blend(Call,
semester=self.semester,
deadline=timezone.now() + timedelta(days=7),
proposal_type=Call.SCI_PROPOSAL)
self.instrument = mixer.blend(Instrument, call=self.call)
self.app = mixer.blend(ScienceApplication,
status=ScienceApplication.DRAFT,
submitter=self.user,
call=self.call)
tr = mixer.blend(TimeRequest, science_application=self.app)
coi = mixer.blend(CoInvestigator, science_application=self.app)
self.data = {
'call': self.call.id,
'title': 'updates',
'status': 'DRAFT',
'timerequest_set-TOTAL_FORMS': 1,
'timerequest_set-INITIAL_FORMS': 1,
'timerequest_set-MIN_NUM_FORMS': 1,
'timerequest_set-MAX_NUM_FORMS': 1000,
'timerequest_set-0-id': tr.id,
'timerequest_set-0-instrument': self.instrument.id,
'timerequest_set-0-std_time': tr.std_time,
'timerequest_set-0-too_time': tr.too_time,
'timerequest_set-0-crt_time': tr.crt_time,
'coinvestigator_set-TOTAL_FORMS': 1,
'coinvestigator_set-INITIAL_FORMS': 1,
'coinvestigator_set-MIN_NUM_FORMS': 1,
'coinvestigator_set-MAX_NUM_FORMS': 1000,
'coinvestigator_set-0-id': coi.id,
'coinvestigator_set-0-email': coi.email,
'coinvestigator_set-0-first_name': coi.first_name,
'coinvestigator_set-0-last_name': coi.last_name,
'coinvestigator_set-0-institution': coi.institution
}
def test_userrequest_admin_staff_view_enabled(self):
user = blend_user(user_params={'is_staff': True}, profile_params={'staff_view': True})
self.client.force_login(user)
response = self.client.get(reverse('userrequests:list'))
for ur in self.userrequests:
self.assertContains(response, ur.group_id)
def setUp(self):
self.proposal = mixer.blend(Proposal)
self.pi_user = blend_user()
self.ci_user = blend_user()
Membership.objects.create(user=self.pi_user, proposal=self.proposal, role=Membership.PI, time_limit=0)
Membership.objects.create(user=self.ci_user, proposal=self.proposal, role=Membership.CI, time_limit=0)
def test_proposal_detail_as_staff(self):
user = blend_user(user_params={'is_staff': True})
self.client.force_login(user)
response = self.client.get(reverse('proposals:detail', kwargs={'pk': self.proposal.id}))
self.assertContains(response, self.proposal.id)
def setUp(self):
self.user = blend_user(user_params={'is_staff': True})
self.proposal = mixer.blend(Proposal)
self.semester = mixer.blend(Semester)
self.ta = mixer.blend(TimeAllocation, semester=self.semester, proposal=self.proposal)
def setUp(self):
self.user = blend_user()
self.proposal = mixer.blend(Proposal)
mixer.blend(Membership, user=self.user, proposal=self.proposal)
self.client.force_login(self.user)
def setUp(self):
self.pi_user = blend_user()
self.ci_user = blend_user()
self.proposal = mixer.blend(Proposal)
mixer.blend(Membership, user=self.pi_user, role=Membership.PI, proposal=self.proposal)
self.cim = mixer.blend(Membership, user=self.ci_user, role=Membership.CI, proposal=self.proposal)
def test_no_proposals(self):
user = blend_user()
self.client.force_login(user)
response = self.client.get(reverse('proposals:list'))
self.assertContains(response, 'You are not a member of any proposals')
self.assertNotContains(response, 'Admin only')
def setUp(self):
self.user = blend_user()
self.proposals = mixer.cycle(5).blend(Proposal)
for proposal in self.proposals:
mixer.blend(Membership, user=self.user, proposal=proposal)
def setUp(self):
super().setUp()
self.user = blend_user()
self.client.force_login(self.user)
