def test_required_third_level_questions_must_be_answered_on_draft(
self, mock_enqueue, app, user, project_public,
prereg_metadata, url_registrations):
prereg_schema = MetaSchema.objects.get(
name='Prereg Challenge',
schema_version=LATEST_SCHEMA_VERSION)
prereg_draft_registration = DraftRegistrationFactory(
initiator=user,
registration_schema=prereg_schema,
branched_from=project_public
)
registration_metadata = prereg_metadata(prereg_draft_registration)
registration_metadata['q11'] = {'value': {"question": {}}}
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
'data': {
'type': 'registrations',
'attributes': {
'registration_choice': 'immediate',
'draft_registration': prereg_draft_registration._id,
}
}
}
res = app.post_json_api(
url_registrations, payload,
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
assert res.json['errors'][0]['detail'] == '\'value\' is a required property'
def setUp(self, mock_archive):
super(TestDraftListView, self).setUp()
self.user = AuthUserFactory()
self.schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr2 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr2.submit_for_review(self.user, {}, save=True)
# Simply here to NOT be returned when get_queryset is called
self.unsubmitted_prereg = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
self.unsubmitted_prereg.register(Auth(self.user), save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftListView
self.view = setup_view(self.plain_view(), self.request)
self.url = reverse('pre_reg:prereg')
class TestCommentUpdateView(AdminTestCase):
def setUp(self):
super(TestCommentUpdateView, self).setUp()
self.user = AuthUserFactory()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=utils.draft_reg_util(),
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().post('/fake_path', data={'blah': 'arg'})
self.request.user = UserFactory()
self.plain_view = CommentUpdateView
self.view = setup_view(self.plain_view(), self.request, draft_pk=self.dr1._id)
self.url = reverse('pre_reg:comment', kwargs={'draft_pk': self.dr1._id})
@mock.patch('admin.pre_reg.views.json.loads')
@mock.patch('admin.pre_reg.views.DraftRegistration.update_metadata')
def test_post_comments(self, mock_json, mock_meta):
count = AdminLogEntry.objects.count()
self.view.post(self.request)
nt.assert_equal(AdminLogEntry.objects.count(), count + 1)
def test_no_user_permissions_raises_error(self):
request = RequestFactory().get(self.url)
request.user = self.user
with nt.assert_raises(PermissionDenied):
self.plain_view.as_view()(request, draft_pk=self.dr1._id)
def test_required_metaschema_questions_not_required_on_post(self):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.public_project
)
url = '/{}nodes/{}/draft_registrations/?embed=initiator&embed=branched_from'.format(API_BASE, self.public_project._id)
registration_metadata = self.prereg_metadata(prereg_draft_registration)
del registration_metadata['q1']
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
"data": {
"type": "draft_registrations",
"attributes": {
"registration_supplement": prereg_schema._id,
"registration_metadata": registration_metadata
}
}
}
res = self.app.post_json_api(url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 201)
data = res.json['data']
assert_equal(res.json['data']['attributes']['registration_metadata']['q2']['value'], 'Test response')
assert_equal(data['attributes']['registration_supplement'], prereg_schema._id)
assert_equal(data['embeds']['branched_from']['data']['id'], self.public_project._id)
assert_equal(data['embeds']['initiator']['data']['id'], self.user._id)
def test_required_third_level_questions_must_be_answered_on_draft(self, mock_enqueue):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.public_project
)
registration_metadata = self.prereg_metadata(prereg_draft_registration)
registration_metadata['q11'] = {'value': {"question": {}}}
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": prereg_draft_registration._id,
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "'value' is a required property")
class TestDraftRegistrationDelete(DraftRegistrationTestCase):
def setUp(self):
super(TestDraftRegistrationDelete, self).setUp()
schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
branched_from=self.public_project
)
self.other_project = ProjectFactory(creator=self.user)
self.url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.draft_registration._id)
def test_admin_can_delete_draft(self):
res = self.app.delete_json_api(self.url, auth=self.user.auth)
assert_equal(res.status_code, 204)
def test_read_only_contributor_cannot_delete_draft(self):
res = self.app.delete_json_api(self.url, auth=self.read_only_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_read_write_contributor_cannot_delete_draft(self):
res = self.app.delete_json_api(self.url, auth=self.read_write_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_logged_in_non_contributor_cannot_delete_draft(self):
res = self.app.delete_json_api(self.url, auth=self.non_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_unauthenticated_user_cannot_delete_draft(self):
res = self.app.delete_json_api(self.url, expect_errors=True)
assert_equal(res.status_code, 401)
def test_draft_that_has_been_registered_cannot_be_deleted(self):
reg = RegistrationFactory(project=self.public_project)
self.draft_registration.registered_node = reg
self.draft_registration.save()
res = self.app.delete_json_api(self.url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'This draft has already been registered and cannot be modified.')
def test_reviewer_cannot_delete_draft_registration(self):
user = AuthUserFactory()
user.add_system_tag(PREREG_ADMIN_TAG)
user.save()
res = self.app.delete_json_api(self.url, auth=user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'You do not have permission to perform this action.')
class TestDraftListView(AdminTestCase):
def setUp(self):
super(TestDraftListView, self).setUp()
self.user = AuthUserFactory()
schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr2 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr2.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftListView
self.view = setup_view(self.plain_view(), self.request)
self.url = reverse('pre_reg:prereg')
def test_get_queryset(self):
res = list(self.view.get_queryset())
nt.assert_equal(len(res), 2)
nt.assert_is_instance(res[0], DraftRegistration)
def test_get_context_data(self):
self.view.object_list = self.view.get_queryset()
res = self.view.get_context_data()
nt.assert_is_instance(res, dict)
nt.assert_is_instance(res['drafts'], list)
nt.assert_equal(len(res['drafts']), 2)
def test_no_user_permissions_raises_error(self):
request = RequestFactory().get(self.url)
request.user = self.user
with nt.assert_raises(PermissionDenied):
self.plain_view.as_view()(request)
def test_correct_view_permissions(self):
view_permission = Permission.objects.get(codename='view_prereg')
self.user.user_permissions.add(view_permission)
self.user.save()
request = RequestFactory().get(self.url)
request.user = self.user
response = self.plain_view.as_view()(request)
nt.assert_equal(response.status_code, 200)
def test_required_metaschema_questions_not_required_on_post(
self, app, user, provider, project_public, prereg_metadata):
prereg_schema = RegistrationSchema.objects.get(
name='Prereg Challenge',
schema_version=LATEST_SCHEMA_VERSION)
prereg_draft_registration = DraftRegistrationFactory(
initiator=user,
registration_schema=prereg_schema,
branched_from=project_public
)
url = '/{}nodes/{}/draft_registrations/?embed=initiator&embed=branched_from'.format(
API_BASE, project_public._id)
registration_metadata = prereg_metadata(prereg_draft_registration)
del registration_metadata['q1']
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
'data': {
'type': 'draft_registrations',
'attributes': {
'registration_metadata': registration_metadata
},
'relationships': {
'registration_schema': {
'data': {
'type': 'registration_schema',
'id': prereg_schema._id
}
},
'provider': {
'data': {
'type': 'registration-providers',
'id': provider._id,
}
}
}
}
}
res = app.post_json_api(
url, payload, auth=user.auth,
expect_errors=True)
assert res.status_code == 201
data = res.json['data']
assert res.json['data']['attributes']['registration_metadata']['q2']['value'] == 'Test response'
assert prereg_schema._id in data['relationships']['registration_schema']['links']['related']['href']
assert data['embeds']['branched_from']['data']['id'] == project_public._id
assert data['embeds']['initiator']['data']['id'] == user._id
def setUp(self):
super(TestCommentUpdateView, self).setUp()
self.user = AuthUserFactory()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=utils.draft_reg_util(),
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().post('/fake_path', data={'blah': 'arg'})
self.request.user = UserFactory()
self.plain_view = CommentUpdateView
self.view = setup_view(self.plain_view(), self.request, draft_pk=self.dr1._id)
self.url = reverse('pre_reg:comment', kwargs={'draft_pk': self.dr1._id})
def setUp(self):
super(TestDraftDetailView, self).setUp()
self.user = AuthUserFactory()
schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftDetailView
self.view = setup_view(self.plain_view(), self.request, draft_pk=self.dr1._id)
self.url = reverse('pre_reg:view_draft', kwargs={'draft_pk': self.dr1._id})
def setUp(self):
super(TestDraftRegistrationUpdate, self).setUp()
ensure_schemas()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration')
& Q('schema_version', 'eq', LATEST_SCHEMA_VERSION))
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project)
self.prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge')
& Q('schema_version', 'eq', LATEST_SCHEMA_VERSION))
self.prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.prereg_schema,
branched_from=self.public_project)
self.registration_metadata = self.prereg_metadata(
self.prereg_draft_registration)
self.other_project = ProjectFactory(creator=self.user)
self.url = '/{}nodes/{}/draft_registrations/{}/'.format(
API_BASE, self.public_project._id, self.draft_registration._id)
self.payload = {
"data": {
"id": self.draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
"datacompletion": {
"value": "No, data collection has not begun"
},
"looked": {
"value": "No"
},
"comments": {
"value": "This is my first registration."
}
}
}
}
}
def test_factory(user, project):
# Create a registration with kwargs
registration1 = factories.RegistrationFactory(
title='t1', description='d1', creator=user,
)
assert registration1.title == 't1'
assert registration1.description == 'd1'
assert registration1.contributors.count() == 1
assert user in registration1.contributors.all()
assert registration1.registered_user == user
assert registration1.private_links.count() == 0
# Create a registration from a project
user2 = factories.UserFactory()
project.add_contributor(user2)
data = {'some': 'data'}
draft_reg = DraftRegistrationFactory(registration_metadata=data, branched_from=project)
registration2 = factories.RegistrationFactory(
project=project,
user=user2,
draft_registration=draft_reg,
)
assert registration2.registered_from == project
assert registration2.registered_user == user2
def setUp(self):
super(RegistrationEmbargoViewsTestCase, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.draft = DraftRegistrationFactory(branched_from=self.project)
self.registration = RegistrationFactory(project=self.project, creator=self.user)
current_month = timezone.now().strftime('%B')
current_year = timezone.now().strftime('%Y')
self.valid_make_public_payload = json.dumps({
u'embargoEndDate': u'Fri, 01, {month} {year} 00:00:00 GMT'.format(
month=current_month,
year=current_year
),
u'registrationChoice': 'immediate',
u'summary': unicode(fake.sentence())
})
valid_date = timezone.now() + datetime.timedelta(days=180)
self.valid_embargo_payload = json.dumps({
u'embargoEndDate': unicode(valid_date.strftime('%a, %d, %B %Y %H:%M:%S')) + u' GMT',
u'registrationChoice': 'embargo',
u'summary': unicode(fake.sentence())
})
self.invalid_embargo_date_payload = json.dumps({
u'embargoEndDate': u"Thu, 01 {month} {year} 05:00:00 GMT".format(
month=current_month,
year=str(int(current_year) - 1)
),
u'registrationChoice': 'embargo',
u'summary': unicode(fake.sentence())
})
def setUp(self):
super(TestDraftPreregChallengeRegistrationMetadataValidation,
self).setUp()
ensure_schemas()
self.prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge')
& Q('schema_version', 'eq', LATEST_SCHEMA_VERSION))
self.prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.prereg_schema,
branched_from=self.public_project)
self.other_project = ProjectFactory(creator=self.user)
self.url = '/{}nodes/{}/draft_registrations/{}/'.format(
API_BASE, self.public_project._id,
self.prereg_draft_registration._id)
self.payload = {
"data": {
"id": self.prereg_draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {}
}
}
}
def setUp(self):
super(TestRegistrationCreate, self).setUp()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'Replication Recipe (Brandt et al., 2013): Post-Completion') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project,
registration_metadata = {
'item29': {'value': 'Yes'},
'item33': {'value': 'success'}
}
)
self.url = '/{}nodes/{}/registrations/'.format(API_BASE, self.public_project._id)
self.payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "immediate"
}
}
}
def test_does_not_get_copied_to_registrations(self, mock_errors, mock_archive):
registration = self.node.register_node(
schema=get_default_metaschema(),
auth=Auth(user=self.node.creator),
draft_registration=DraftRegistrationFactory(branched_from=self.node)
)
assert_false(registration.has_addon('figshare'))
def test_detail_view_returns_editable_fields_no_specified_node(
self, app, user):
draft_registration = DraftRegistrationFactory(initiator=user,
branched_from=None)
url = '/{}draft_registrations/{}/'.format(API_BASE,
draft_registration._id)
res = app.get(url, auth=user.auth, expect_errors=True)
attributes = res.json['data']['attributes']
assert attributes['title'] == 'Untitled'
assert attributes['description'] == ''
assert attributes['category'] == ''
assert attributes['node_license'] is None
assert not attributes['has_project']
res.json['data']['links']['self'] == url
relationships = res.json['data']['relationships']
assert 'affiliated_institutions' in relationships
assert 'subjects' in relationships
assert 'contributors' in relationships
draft_node_link = relationships['branched_from']['links']['related'][
'href']
res = app.get(draft_node_link, auth=user.auth)
assert DraftNode.load(
res.json['data']['id']) == draft_registration.branched_from
def test_multiple_choice_in_registration_schema_must_match_one_of_choices(
self, mock_enqueue):
draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project,
registration_metadata={
'item29': {
'value': 'Yes'
},
'item33': {
'value': 'success!'
}
})
self.payload['data']['attributes'][
'draft_registration'] = draft_registration._id
res = self.app.post_json_api(self.url,
self.payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
"u'success!' is not one of [u'success', u'informative failure to replicate',"
" u'practical failure to replicate', u'inconclusive']")
def test_registration_draft_must_be_draft_of_current_node(
self, mock_enqueue):
new_project = ProjectFactory(creator=self.user)
draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=new_project,
registration_metadata={
'item29': {
'value': 'Yes'
},
'item33': {
'value': 'success'
}
})
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": draft_registration._id
}
}
}
res = self.app.post_json_api(self.url,
payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'This draft registration is not created from the given node.')
def setUp(self):
super(TestDraftNodeStorageProviderDetail, self).setUp()
self.user = AuthUserFactory()
self.draft_reg = DraftRegistrationFactory(initiator=self.user)
self.draft_node = self.draft_reg.branched_from
self.private_url = '/{}draft_nodes/{}/files/providers/osfstorage/'.format(
API_BASE, self.draft_node._id)
def test_regions_stay_after_registration(self, user,
project_with_different_regions):
"""
Registering a project with components of different regions should keep those regions after registration.
:param user:
:param project_with_different_regions:
:return:
"""
schema = RegistrationSchema.objects.first()
draft_reg = DraftRegistrationFactory(
branched_from=project_with_different_regions)
project_with_different_regions.register_node(schema, Auth(user=user),
draft_reg)
regs = Registration.objects.all()
# Sanity check all regions are different from each other
assert regs.count() == len(
{reg.get_addon('osfstorage').region._id
for reg in regs})
# All registrations should have the same region as the node they are registered from.
assert all(
reg.registered_from.get_addon('osfstorage').region ==
reg.get_addon('osfstorage').region for reg in regs)
def draft_registration(self, user, user_read_contrib, user_write_contrib,
project_public, schema):
draft_registration = DraftRegistrationFactory(
initiator=user, registration_schema=schema, branched_from=None)
draft_registration.add_contributor(user_write_contrib,
permissions=WRITE)
draft_registration.add_contributor(user_read_contrib, permissions=READ)
draft_registration.save()
return draft_registration
def test_required_metaschema_questions_not_required_on_post(
self, app, user, project_public, prereg_metadata):
prereg_schema = RegistrationSchema.objects.get(
name='Prereg Challenge', schema_version=LATEST_SCHEMA_VERSION)
prereg_draft_registration = DraftRegistrationFactory(
initiator=user,
registration_schema=prereg_schema,
branched_from=project_public)
url = '/{}nodes/{}/draft_registrations/?embed=initiator&embed=branched_from'.format(
API_BASE, project_public._id)
registration_metadata = prereg_metadata(prereg_draft_registration)
del registration_metadata['q1']
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
'data': {
'type': 'draft_registrations',
'attributes': {
'registration_metadata': registration_metadata
},
'relationships': {
'registration_schema': {
'data': {
'type': 'registration_schema',
'id': prereg_schema._id
}
}
}
}
}
res = app.post_json_api(url,
payload,
auth=user.auth,
expect_errors=True)
assert res.status_code == 201
data = res.json['data']
assert res.json['data']['attributes']['registration_metadata']['q2'][
'value'] == 'Test response'
assert prereg_schema._id in data['relationships'][
'registration_schema']['links']['related']['href']
assert data['embeds']['branched_from']['data'][
'id'] == project_public._id
assert data['embeds']['initiator']['data']['id'] == user._id
def setUp(self):
super(RegistrationsTestBase, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(self.user)
self.node = ProjectFactory(creator=self.user)
self.non_admin = AuthUserFactory()
self.node.add_contributor(
self.non_admin,
permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS,
auth=self.auth,
save=True
)
self.non_contrib = AuthUserFactory()
self.meta_schema = RegistrationSchema.objects.get(name='Open-Ended Registration', schema_version=2)
self.draft = DraftRegistrationFactory(
initiator=self.user,
branched_from=self.node,
registration_schema=self.meta_schema,
registration_metadata={
'summary': {'value': 'Some airy'}
}
)
current_month = timezone.now().strftime('%B')
current_year = timezone.now().strftime('%Y')
valid_date = timezone.now() + dt.timedelta(days=180)
self.embargo_payload = {
'data': {
'attributes': {
'children': [self.node._id],
'draft_registration': self.draft._id,
'lift_embargo': unicode(valid_date.strftime('%a, %d, %B %Y %H:%M:%S')) + u' GMT',
'registration_choice': 'embargo',
},
'type': 'registrations',
},
}
self.invalid_embargo_date_payload = copy.deepcopy(self.embargo_payload)
self.invalid_embargo_date_payload['data']['attributes']['lift_embargo'] = u'Thu, 01 {month} {year} 05:00:00 GMT'.format(
month=current_month,
year=str(int(current_year) - 1)
)
self.immediate_payload = {
'data': {
'attributes': {
'children': [self.node._id],
'draft_registration': self.draft._id,
'registration_choice': 'immediate',
},
'type': 'registrations',
},
}
self.invalid_payload = copy.deepcopy(self.immediate_payload)
self.invalid_payload['data']['attributes']['registration_choice'] = 'foobar'
def setUp(self):
super(TestPreregFiles, self).setUp()
self.prereg_user = AuthUserFactory()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
prereg_schema = get_prereg_schema()
self.d_of_qs = {
'q7': OsfStorageFileNode(node=self.node, name='7'),
'q11': OsfStorageFileNode(node=self.node, name='11'),
'q16': OsfStorageFileNode(node=self.node, name='16'),
'q12': OsfStorageFileNode(node=self.node, name='12'),
'q13': OsfStorageFileNode(node=self.node, name='13'),
'q19': OsfStorageFileNode(node=self.node, name='19'),
'q26': OsfStorageFileNode(node=self.node, name='26')
}
data = {}
for q, f in self.d_of_qs.iteritems():
guid = f.get_guid(create=True)._id
f.save()
if q == 'q26':
data[q] = {
'comments': [],
'value': '26',
'extra': [
{
'data': {
'provider': 'osfstorage',
'path': f.path,
},
'fileId': guid,
'nodeId': self.node._id,
}
]
}
continue
data[q] = {
'value': {
'uploader': {
'extra': [
{
'data': {
'provider': 'osfstorage',
'path': f.path,
},
'fileId': guid,
'nodeId': self.node._id,
}
]
}
}
}
self.draft = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
registration_metadata=data
)
self.prereg_user.save()
self.admin_user = UserFactory()
def setUp(self):
super(TestDraftListView, self).setUp()
self.user = AuthUserFactory()
schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr2 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA)
self.dr2.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().get('/fake_path')
self.view = DraftListView()
self.view = setup_view(self.view, self.request)
def test_node_register_page_registration(self, mock_archive):
draft_reg = DraftRegistrationFactory(branched_from=self.node,
user=self.node.creator)
reg = self.node.register_node(get_default_metaschema(), self.auth,
draft_reg, None)
url = reg.web_url_for('node_register_page')
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, http_status.HTTP_200_OK)
def test_does_not_get_copied_to_registrations(self, mock_archive):
registration = self.project.register_node(
schema=get_default_metaschema(),
auth=Auth(user=self.project.creator),
draft_registration=DraftRegistrationFactory(
branched_from=self.project),
)
assert_false(registration.has_addon('github'))
def project_public(self, user, title, description, category):
# Overrides NodeCRUDTestCase - just going to make a "public project"
# be a draft branched from a public project.
project = ProjectFactory(creator=user, is_public=True)
return DraftRegistrationFactory(title=title,
description=description,
category=category,
initiator=user,
branched_from=project)
def setUp(self):
super(TestNodeFilesList, self).setUp()
self.user = AuthUserFactory()
self.draft_reg = DraftRegistrationFactory(creator=self.user)
self.draft_node = self.draft_reg.branched_from
self.private_url = '/{}draft_nodes/{}/files/'.format(
API_BASE, self.draft_node._id)
self.user_two = AuthUserFactory()
class TestDraftDetailView(AdminTestCase):
def setUp(self):
super(TestDraftDetailView, self).setUp()
self.user = AuthUserFactory()
schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().get('/fake_path')
self.view = DraftDetailView()
self.view = setup_view(self.view, self.request, draft_pk=self.dr1._id)
@mock.patch('admin.pre_reg.views.DraftDetailView.checkout_files')
def test_get_object(self, mock_files):
res = self.view.get_object()
nt.assert_is_instance(res, dict)
nt.assert_equal(res['pk'], self.dr1._id)
def draft_registration(self, user, project_public, schema):
return DraftRegistrationFactory(
initiator=user,
registration_schema=schema,
branched_from=project_public,
registration_metadata = {
'item29': {'value': 'Yes'},
'item33': {'value': 'success'}
}
)
def setUp(self):
super(RegistrationEmbargoModelsTestCase, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.draft = DraftRegistrationFactory(branched_from=self.project,
initiator=self.user)
self.registration = RegistrationFactory(project=self.project)
self.embargo = EmbargoFactory(user=self.user)
self.valid_embargo_end_date = timezone.now() + datetime.timedelta(
days=3)
class TestDraftDetailView(AdminTestCase):
def setUp(self):
super(TestDraftDetailView, self).setUp()
self.user = AuthUserFactory()
schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftDetailView
self.view = setup_view(self.plain_view(),
self.request,
draft_pk=self.dr1._id)
self.url = reverse('pre_reg:view_draft',
kwargs={'draft_pk': self.dr1._id})
@mock.patch('admin.pre_reg.views.DraftDetailView.checkout_files')
def test_get_object(self, mock_files):
res = self.view.get_object()
nt.assert_is_instance(res, dict)
nt.assert_equal(res['pk'], self.dr1._id)
def test_no_user_permissions_raises_error(self):
request = RequestFactory().get(self.url)
request.user = self.user
with nt.assert_raises(PermissionDenied):
self.plain_view.as_view()(request, draft_pk=self.dr1._id)
@mock.patch('admin.pre_reg.views.DraftDetailView.checkout_files')
def test_correct_view_permissions(self, mock_files):
view_permission = Permission.objects.get(codename='view_prereg')
self.user.user_permissions.add(view_permission)
self.user.save()
request = RequestFactory().get(self.url)
request.user = self.user
response = self.plain_view.as_view()(request, draft_pk=self.dr1._id)
nt.assert_equal(response.status_code, 200)
def setUp(self):
super(TestDraftFormView, self).setUp()
self.user = AuthUserFactory()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=utils.draft_reg_util(),
registration_metadata=utils.SCHEMA_DATA)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr1.flags # sets flags if there aren't any yet.
self.request = RequestFactory().get('/fake_path')
self.view = DraftFormView()
self.view = setup_view(self.view, self.request, draft_pk=self.dr1._id)
self.post = RequestFactory().post('/fake_path')
self.post.user = UserFactory()
self.post_view = DraftFormView()
self.form_data = {
'notes': 'Far between',
'proof_of_publication': 'approved',
}
class TestDraftDetailView(AdminTestCase):
def setUp(self):
super(TestDraftDetailView, self).setUp()
self.user = AuthUserFactory()
schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftDetailView
self.view = setup_view(self.plain_view(), self.request, draft_pk=self.dr1._id)
self.url = reverse('pre_reg:view_draft', kwargs={'draft_pk': self.dr1._id})
@mock.patch('admin.pre_reg.views.DraftDetailView.checkout_files')
def test_get_object(self, mock_files):
res = self.view.get_object()
nt.assert_is_instance(res, dict)
nt.assert_equal(res['pk'], self.dr1._id)
def test_no_user_permissions_raises_error(self):
request = RequestFactory().get(self.url)
request.user = self.user
with nt.assert_raises(PermissionDenied):
self.plain_view.as_view()(request, draft_pk=self.dr1._id)
@mock.patch('admin.pre_reg.views.DraftDetailView.checkout_files')
def test_correct_view_permissions(self, mock_files):
view_permission = Permission.objects.get(codename='view_prereg')
self.user.user_permissions.add(view_permission)
self.user.save()
request = RequestFactory().get(self.url)
request.user = self.user
response = self.plain_view.as_view()(request, draft_pk=self.dr1._id)
nt.assert_equal(response.status_code, 200)
def test_required_metaschema_questions_not_required_on_post(self):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge')
& Q('schema_version', 'eq', LATEST_SCHEMA_VERSION))
prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.public_project)
url = '/{}nodes/{}/draft_registrations/?embed=initiator&embed=branched_from'.format(
API_BASE, self.public_project._id)
registration_metadata = self.prereg_metadata(prereg_draft_registration)
del registration_metadata['q1']
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
"data": {
"type": "draft_registrations",
"attributes": {
"registration_supplement": prereg_schema._id,
"registration_metadata": registration_metadata
}
}
}
res = self.app.post_json_api(url,
payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 201)
data = res.json['data']
assert_equal(
res.json['data']['attributes']['registration_metadata']['q2']
['value'], 'Test response')
assert_equal(data['attributes']['registration_supplement'],
prereg_schema._id)
assert_equal(data['embeds']['branched_from']['data']['id'],
self.public_project._id)
assert_equal(data['embeds']['initiator']['data']['id'], self.user._id)
def test_s3_set_bucket_registered(self):
registration = self.project.register_node(
get_default_metaschema(), Auth(self.user), DraftRegistrationFactory(branched_from=self.project), ''
)
url = registration.api_url_for('s3_set_config')
res = self.app.put_json(
url, {'s3_bucket': 'hammertofall'}, auth=self.user.auth,
expect_errors=True,
)
assert_equal(res.status_code, http_status.HTTP_400_BAD_REQUEST)
def project_public(self, user, title, description, category):
# Defining "project public" as a draft reg, overriding TestContributorDetail
project = ProjectFactory(title=title,
description=description,
category=category,
is_public=True,
creator=user)
draft = DraftRegistrationFactory(
initiator=user,
branched_from=project,
)
return draft
def setUp(self):
super(TestDraftListView, self).setUp()
self.user = AuthUserFactory()
schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr2 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr2.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftListView
self.view = setup_view(self.plain_view(), self.request)
self.url = reverse('pre_reg:prereg')
class TestCommentUpdateView(AdminTestCase):
def setUp(self):
super(TestCommentUpdateView, self).setUp()
self.user = AuthUserFactory()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=utils.draft_reg_util(),
registration_metadata=utils.SCHEMA_DATA)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().post('/fake_path',
data={'blah': 'arg'})
self.request.user = UserFactory()
self.view = CommentUpdateView()
self.view = setup_view(self.view, self.request, draft_pk=self.dr1._id)
@mock.patch('admin.pre_reg.views.json.loads')
@mock.patch('admin.pre_reg.views.DraftRegistration.update_metadata')
def test_post_comments(self, mock_json, mock_meta):
count = AdminLogEntry.objects.count()
self.view.post(self.request)
nt.assert_equal(AdminLogEntry.objects.count(), count + 1)
def setUp(self, mock_archive):
super(TestDraftListView, self).setUp()
self.user = AuthUserFactory()
self.schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr2 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA)
self.dr2.submit_for_review(self.user, {}, save=True)
# Simply here to NOT be returned when get_queryset is called
self.unsubmitted_prereg = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA)
self.unsubmitted_prereg.register(Auth(self.user), save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftListView
self.view = setup_view(self.plain_view(), self.request)
self.url = reverse('pre_reg:prereg')
def setUp(self):
super(TestDraftRegistrationList, self).setUp()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'Open-Ended Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project
)
self.url = '/{}nodes/{}/draft_registrations/'.format(API_BASE, self.public_project._id)
def setUp(self):
super(TestDraftRegistrationUpdate, self).setUp()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project
)
self.prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.prereg_schema,
branched_from=self.public_project
)
self.registration_metadata = self.prereg_metadata(self.prereg_draft_registration)
self.other_project = ProjectFactory(creator=self.user)
self.url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.draft_registration._id)
self.payload = {
"data": {
"id": self.draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
"datacompletion": {
"value": "No, data collection has not begun"
},
"looked": {
"value": "No"
},
"comments": {
"value": "This is my first registration."
}
}
}
}
}
def setUp(self):
super(TestCommentUpdateView, self).setUp()
self.user = AuthUserFactory()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=utils.draft_reg_util(),
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.request = RequestFactory().post('/fake_path', data={'blah': 'arg'})
self.request.user = UserFactory()
self.plain_view = CommentUpdateView
self.view = setup_view(self.plain_view(), self.request, draft_pk=self.dr1._id)
self.url = reverse('pre_reg:comment', kwargs={'draft_pk': self.dr1._id})
def setUp(self):
super(TestDraftRegistrationDelete, self).setUp()
schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=schema,
branched_from=self.public_project
)
self.other_project = ProjectFactory(creator=self.user)
self.url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.draft_registration._id)
def setUp(self):
super(TestDraftFormView, self).setUp()
self.user = AuthUserFactory()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=utils.draft_reg_util(),
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr1.flags # sets flags if there aren't any yet.
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftFormView
self.view = setup_view(self.plain_view(), self.request, draft_pk=self.dr1._id)
self.post = RequestFactory().post('/fake_path')
self.post.user = UserFactory()
self.post_view = DraftFormView()
self.form_data = {
'notes': 'Far between',
'proof_of_publication': 'approved',
}
self.url = reverse('pre_reg:view_draft', kwargs={'draft_pk': self.dr1._id})
def test_queryset_returns_in_order_date_submitted(self):
created_first_submitted_second = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
created_second_submitted_first = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
nt.assert_greater(created_second_submitted_first.datetime_initiated, created_first_submitted_second.datetime_initiated)
created_second_submitted_first.submit_for_review(self.user, {}, save=True)
created_first_submitted_second.submit_for_review(self.user, {}, save=True)
created_second_submitted_first.datetime_updated = created_first_submitted_second.datetime_updated + datetime.timedelta(1)
assert created_second_submitted_first.datetime_updated > created_first_submitted_second.datetime_updated
res = list(self.view.get_queryset())
nt.assert_true(res[0] == created_first_submitted_second)
class TestPreregFiles(AdminTestCase):
def setUp(self):
super(TestPreregFiles, self).setUp()
self.prereg_user = AuthUserFactory()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
prereg_schema = get_prereg_schema()
self.d_of_qs = {
'q7': OsfStorageFileNode(node=self.node, name='7'),
'q11': OsfStorageFileNode(node=self.node, name='11'),
'q16': OsfStorageFileNode(node=self.node, name='16'),
'q12': OsfStorageFileNode(node=self.node, name='12'),
'q13': OsfStorageFileNode(node=self.node, name='13'),
'q19': OsfStorageFileNode(node=self.node, name='19'),
'q26': OsfStorageFileNode(node=self.node, name='26')
}
data = {}
for q, f in self.d_of_qs.iteritems():
guid = f.get_guid(create=True)._id
f.save()
if q == 'q26':
data[q] = {
'comments': [],
'value': '26',
'extra': [
{
'data': {
'provider': 'osfstorage',
'path': f.path,
},
'fileId': guid,
'nodeId': self.node._id,
}
]
}
continue
data[q] = {
'value': {
'uploader': {
'extra': [
{
'data': {
'provider': 'osfstorage',
'path': f.path,
},
'fileId': guid,
'nodeId': self.node._id,
}
]
}
}
}
self.draft = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
registration_metadata=data
)
self.prereg_user.save()
self.admin_user = UserFactory()
def test_checkout_files(self):
self.draft.submit_for_review(self.user, {}, save=True)
request = RequestFactory().get('/fake_path')
view = DraftDetailView()
view = setup_user_view(view, request, self.admin_user,
draft_pk=self.draft._id)
view.checkout_files(self.draft)
for q, f in self.d_of_qs.iteritems():
f.refresh_from_db()
nt.assert_equal(self.admin_user, f.checkout)
def test_checkin_files(self):
self.draft.submit_for_review(self.user, {}, save=True)
request = RequestFactory().get('/fake_path')
view = DraftDetailView()
view = setup_user_view(view, request, self.admin_user,
draft_pk=self.draft._id)
view.checkout_files(self.draft)
view2 = DraftFormView()
view2 = setup_view(view2, request, draft_pk=self.draft._id)
view2.checkin_files(self.draft)
for q, f in self.d_of_qs.iteritems():
nt.assert_equal(None, f.checkout)
def test_get_meta_data_files(self):
for item in get_metadata_files(self.draft):
nt.assert_in(type(item), [OsfStorageFile, OsfStorageFileNode])
def test_get_file_questions(self):
questions = get_file_questions('prereg-prize.json')
nt.assert_equal(7, len(questions))
nt.assert_list_equal(
[
(u'q7', u'Data collection procedures'),
(u'q11', u'Manipulated variables'),
(u'q12', u'Measured variables'),
(u'q13', u'Indices'),
(u'q16', u'Study design'),
(u'q19', u'Statistical models'),
(u'q26', u'Upload an analysis script with clear comments')
],
questions
)
def test_file_id_missing(self):
data = self.draft.registration_metadata
data['q7']['value']['uploader']['extra'][0].pop('fileId')
self.draft.update_metadata(data)
for item in get_metadata_files(self.draft):
nt.assert_in(type(item), [OsfStorageFile, OsfStorageFileNode])
def test_file_id_missing_odd(self):
data = self.draft.registration_metadata
data['q26']['extra'][0].pop('fileId')
self.draft.update_metadata(data)
for item in get_metadata_files(self.draft):
nt.assert_in(type(item), [OsfStorageFile, OsfStorageFileNode])
def test_wrong_provider(self):
data = self.draft.registration_metadata
data['q7']['value']['uploader']['extra'][0]['data']['provider'] = 'box'
self.draft.update_metadata(data)
with nt.assert_raises(Http404):
for item in get_metadata_files(self.draft):
pass
def test_wrong_provider_odd(self):
data = self.draft.registration_metadata
data['q26']['extra'][0]['data']['provider'] = 'box'
self.draft.update_metadata(data)
with nt.assert_raises(Http404):
for item in get_metadata_files(self.draft):
pass
class TestDraftRegistrationList(DraftRegistrationTestCase):
def setUp(self):
super(TestDraftRegistrationList, self).setUp()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'Open-Ended Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project
)
self.url = '/{}nodes/{}/draft_registrations/'.format(API_BASE, self.public_project._id)
def test_admin_can_view_draft_list(self):
res = self.app.get(self.url, auth=self.user.auth)
assert_equal(res.status_code, 200)
data = res.json['data']
assert_equal(len(data), 1)
assert_equal(data[0]['attributes']['registration_supplement'], self.schema._id)
assert_equal(data[0]['id'], self.draft_registration._id)
assert_equal(data[0]['attributes']['registration_metadata'], {})
def test_read_only_contributor_cannot_view_draft_list(self):
res = self.app.get(self.url, auth=self.read_only_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_read_write_contributor_cannot_view_draft_list(self):
res = self.app.get(self.url, auth=self.read_write_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_logged_in_non_contributor_cannot_view_draft_list(self):
res = self.app.get(self.url, auth=self.non_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_unauthenticated_user_cannot_view_draft_list(self):
res = self.app.get(self.url, expect_errors=True)
assert_equal(res.status_code, 401)
def test_draft_with_registered_node_does_not_show_up_in_draft_list(self):
reg = RegistrationFactory(project = self.public_project)
self.draft_registration.registered_node = reg
self.draft_registration.save()
res = self.app.get(self.url, auth=self.user.auth)
assert_equal(res.status_code, 200)
data = res.json['data']
assert_equal(len(data), 0)
def test_draft_with_deleted_registered_node_shows_up_in_draft_list(self):
reg = RegistrationFactory(project=self.public_project)
self.draft_registration.registered_node = reg
self.draft_registration.save()
reg.is_deleted = True
reg.save()
res = self.app.get(self.url, auth=self.user.auth)
assert_equal(res.status_code, 200)
data = res.json['data']
assert_equal(len(data), 1)
assert_equal(data[0]['attributes']['registration_supplement'], self.schema._id)
assert_equal(data[0]['id'], self.draft_registration._id)
assert_equal(data[0]['attributes']['registration_metadata'], {})
class TestDraftRegistrationUpdate(DraftRegistrationTestCase):
def setUp(self):
super(TestDraftRegistrationUpdate, self).setUp()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project
)
self.prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.prereg_schema,
branched_from=self.public_project
)
self.registration_metadata = self.prereg_metadata(self.prereg_draft_registration)
self.other_project = ProjectFactory(creator=self.user)
self.url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.draft_registration._id)
self.payload = {
"data": {
"id": self.draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
"datacompletion": {
"value": "No, data collection has not begun"
},
"looked": {
"value": "No"
},
"comments": {
"value": "This is my first registration."
}
}
}
}
}
def test_id_required_in_payload(self):
payload = {
"data": {
"type": "draft_registrations",
"attributes": {
"registration_metadata": {}
}
}
}
res = self.app.put_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
errors = res.json['errors'][0]
assert_equal(errors['source']['pointer'], '/data/id')
assert_equal(errors['detail'], 'This field may not be null.')
def test_admin_can_update_draft(self):
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth)
assert_equal(res.status_code, 200)
data = res.json['data']
assert_equal(data['attributes']['registration_supplement'], self.schema._id)
assert_equal(data['attributes']['registration_metadata'], self.payload['data']['attributes']['registration_metadata'])
def test_draft_must_be_branched_from_node(self):
url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.other_project._id, self.draft_registration._id)
res = self.app.put_json_api(url, self.payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
errors = res.json['errors'][0]
assert_equal(errors['detail'], 'This draft registration is not created from the given node.')
def test_read_only_contributor_cannot_update_draft(self):
res = self.app.put_json_api(self.url, self.payload, auth=self.read_only_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_read_write_contributor_cannot_update_draft(self):
res = self.app.put_json_api(self.url, self.payload, auth=self.read_write_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_logged_in_non_contributor_cannot_update_draft(self):
res = self.app.put_json_api(self.url, self.payload, auth=self.non_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_unauthenticated_user_cannot_update_draft(self):
res = self.app.put_json_api(self.url, self.payload, expect_errors=True)
assert_equal(res.status_code, 401)
def test_registration_metadata_must_be_supplied(self):
self.payload['data']['attributes'] = {}
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
errors = res.json['errors'][0]
assert_equal(res.status_code, 400)
assert_equal(errors['source']['pointer'], '/data/attributes/registration_metadata')
assert_equal(errors['detail'], 'This field is required.')
def test_registration_metadata_must_be_a_dictionary(self):
self.payload['data']['attributes']['registration_metadata'] = 'Registration data'
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
errors = res.json['errors'][0]
assert_equal(res.status_code, 400)
assert_equal(errors['source']['pointer'], '/data/attributes/registration_metadata')
assert_equal(errors['detail'], 'Expected a dictionary of items but got type "unicode".')
def test_registration_metadata_question_values_must_be_dictionaries(self):
self.payload['data']['attributes']['registration_metadata']['datacompletion'] = 'No, data collection has not begun'
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
errors = res.json['errors'][0]
assert_equal(res.status_code, 400)
assert_equal(errors['detail'], "u'No, data collection has not begun' is not of type 'object'")
def test_registration_metadata_question_keys_must_be_value(self):
self.payload['data']['attributes']['registration_metadata']['datacompletion'] = {
"incorrect_key": "No, data collection has not begun"
}
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
errors = res.json['errors'][0]
assert_equal(res.status_code, 400)
assert_equal(errors['detail'], "Additional properties are not allowed (u'incorrect_key' was unexpected)")
def test_question_in_registration_metadata_must_be_in_schema(self):
self.payload['data']['attributes']['registration_metadata']['q11'] = {
"value": "No, data collection has not begun"
}
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
errors = res.json['errors'][0]
assert_equal(res.status_code, 400)
assert_equal(errors['detail'], "Additional properties are not allowed (u'q11' was unexpected)")
def test_multiple_choice_question_value_must_match_value_in_schema(self):
self.payload['data']['attributes']['registration_metadata']['datacompletion'] = {
"value": "Nope, data collection has not begun"
}
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
errors = res.json['errors'][0]
assert_equal(res.status_code, 400)
assert_equal(errors['detail'], "u'Nope, data collection has not begun' is not one of [u'No, data collection has not begun', u'Yes, data collection is underway or complete']")
def test_cannot_update_registration_schema(self):
self.payload['data']['attributes']['registration_supplement'] = self.prereg_schema._id
res = self.app.put_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['attributes']['registration_supplement'], self.schema._id)
def test_required_metaschema_questions_not_required_on_update(self):
url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.prereg_draft_registration._id)
del self.registration_metadata['q1']
self.prereg_draft_registration.registration_metadata = self.registration_metadata
self.prereg_draft_registration.save()
payload = {
"data": {
"id": self.prereg_draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
'q2': {
'value': 'New response'
}
}
}
}
}
res = self.app.put_json_api(url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['attributes']['registration_metadata']['q2']['value'], 'New response')
assert_not_in('q1', res.json['data']['attributes']['registration_metadata'])
def test_reviewer_can_update_draft_registration(self):
user = AuthUserFactory()
user.add_system_tag(PREREG_ADMIN_TAG)
user.save()
payload = {
"data": {
"id": self.prereg_draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
'q2': {
'comments': [{'value': 'This is incomplete.'}]
}
}
}
}
}
url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.prereg_draft_registration._id)
res = self.app.put_json_api(url, payload, auth=user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['attributes']['registration_metadata']['q2']['comments'][0]['value'], 'This is incomplete.')
assert_not_in('q1', res.json['data']['attributes']['registration_metadata'])
def test_reviewer_can_only_update_comment_fields_draft_registration(self):
user = AuthUserFactory()
user.add_system_tag(PREREG_ADMIN_TAG)
user.save()
payload = {
"data": {
"id": self.prereg_draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
'q2': {
'value': 'Test response'
}
}
}
}
}
url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.prereg_draft_registration._id)
res = self.app.put_json_api(url, payload, auth=user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "Additional properties are not allowed (u'value' was unexpected)")
def test_reviewer_can_update_nested_comment_fields_draft_registration(self):
user = AuthUserFactory()
user.add_system_tag(PREREG_ADMIN_TAG)
user.save()
payload = {
"data": {
"id": self.prereg_draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
'q7': {
'value': {
'question': {
'comments': [{'value': 'Add some clarity here.'}]
}
}
}
}
}
}
}
url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.prereg_draft_registration._id)
res = self.app.put_json_api(url, payload, auth=user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['attributes']['registration_metadata']['q7']['value']['question']['comments'][0]['value'], 'Add some clarity here.')
def test_reviewer_cannot_update_nested_value_fields_draft_registration(self):
user = AuthUserFactory()
user.add_system_tag(PREREG_ADMIN_TAG)
user.save()
payload = {
"data": {
"id": self.prereg_draft_registration._id,
"type": "draft_registrations",
"attributes": {
"registration_metadata": {
'q7': {
'value': {
'question': {
'value': 'This is the answer'
}
}
}
}
}
}
}
url = '/{}nodes/{}/draft_registrations/{}/'.format(API_BASE, self.public_project._id, self.prereg_draft_registration._id)
res = self.app.put_json_api(url, payload, auth=user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "Additional properties are not allowed (u'value' was unexpected)")
class TestRegistrationCreate(DraftRegistrationTestCase):
def setUp(self):
super(TestRegistrationCreate, self).setUp()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'Replication Recipe (Brandt et al., 2013): Post-Completion') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project,
registration_metadata = {
'item29': {'value': 'Yes'},
'item33': {'value': 'success'}
}
)
self.url = '/{}nodes/{}/registrations/'.format(API_BASE, self.public_project._id)
self.payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "immediate"
}
}
}
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_admin_can_create_registration(self, mock_enqueue):
res = self.app.post_json_api(self.url, self.payload, auth=self.user.auth)
data = res.json['data']['attributes']
assert_equal(res.status_code, 201)
assert_equal(data['registration'], True)
assert_equal(data['pending_registration_approval'], True)
assert_equal(data['public'], False)
def test_write_only_contributor_cannot_create_registration(self):
res = self.app.post_json_api(self.url, self.payload, auth=self.read_write_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_read_only_contributor_cannot_create_registration(self):
res = self.app.post_json_api(self.url, self.payload, auth=self.read_only_user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
def test_non_authenticated_user_cannot_create_registration(self):
res = self.app.post_json_api(self.url, self.payload, expect_errors=True)
assert_equal(res.status_code, 401)
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_registration_draft_must_be_specified(self, mock_enqueue):
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate"
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['source']['pointer'], '/data/attributes/draft_registration')
assert_equal(res.json['errors'][0]['detail'], 'This field is required.')
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_registration_draft_must_be_valid(self, mock_enqueue):
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": "12345"
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 404)
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_registration_draft_must_be_draft_of_current_node(self, mock_enqueue):
new_project = ProjectFactory(creator=self.user)
draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=new_project,
registration_metadata = {
'item29': {'value': 'Yes'},
'item33': {'value': 'success'}
}
)
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": draft_registration._id
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'This draft registration is not created from the given node.')
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_required_top_level_questions_must_be_answered_on_draft(self, mock_enqueue):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.public_project
)
registration_metadata = self.prereg_metadata(prereg_draft_registration)
del registration_metadata['q1']
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": prereg_draft_registration._id,
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "u'q1' is a required property")
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_required_top_level_questions_must_be_answered_on_draft(self, mock_enqueue):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.public_project
)
registration_metadata = self.prereg_metadata(prereg_draft_registration)
del registration_metadata['q1']
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": prereg_draft_registration._id,
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "u'q1' is a required property")
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_required_second_level_questions_must_be_answered_on_draft(self, mock_enqueue):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.public_project
)
registration_metadata = self.prereg_metadata(prereg_draft_registration)
registration_metadata['q11'] = {'value': {}}
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": prereg_draft_registration._id,
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "u'question' is a required property")
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_required_third_level_questions_must_be_answered_on_draft(self, mock_enqueue):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
prereg_draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.public_project
)
registration_metadata = self.prereg_metadata(prereg_draft_registration)
registration_metadata['q11'] = {'value': {"question": {}}}
prereg_draft_registration.registration_metadata = registration_metadata
prereg_draft_registration.save()
payload = {
"data": {
"type": "registrations",
"attributes": {
"registration_choice": "immediate",
"draft_registration": prereg_draft_registration._id,
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "'value' is a required property")
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_multiple_choice_in_registration_schema_must_match_one_of_choices(self, mock_enqueue):
draft_registration = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
branched_from=self.public_project,
registration_metadata = {
'item29': {'value': 'Yes'},
'item33': {'value': 'success!'}
}
)
self.payload['data']['attributes']['draft_registration'] = draft_registration._id
res = self.app.post_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], "u'success!' is not one of [u'success', u'informative failure to replicate',"
" u'practical failure to replicate', u'inconclusive']")
def test_invalid_registration_choice(self):
self.payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "tomorrow"
}
}
}
res = self.app.post_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['source']['pointer'], '/data/attributes/registration_choice')
assert_equal(res.json['errors'][0]['detail'], '"tomorrow" is not a valid choice.')
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_embargo_end_date_provided_if_registration_choice_is_embargo(self, mock_enqueue):
payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "embargo"
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'lift_embargo must be specified.')
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_embargo_must_be_less_than_four_years(self, mock_enqueue):
today = timezone.now()
five_years = (today + dateutil.relativedelta.relativedelta(years=5)).strftime('%Y-%m-%dT%H:%M:%S')
payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "embargo",
"lift_embargo": five_years
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'Registrations can only be embargoed for up to four years.')
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_embargo_registration(self, mock_enqueue):
today = timezone.now()
next_week = (today + dateutil.relativedelta.relativedelta(months=1)).strftime('%Y-%m-%dT%H:%M:%S')
payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "embargo",
"lift_embargo": next_week
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 201)
data = res.json['data']['attributes']
assert_equal(data['registration'], True)
assert_equal(data['pending_embargo_approval'], True)
def test_embargo_end_date_must_be_in_the_future(self):
today = timezone.now().strftime('%Y-%m-%dT%H:%M:%S')
payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "embargo",
"lift_embargo": today
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'Embargo end date must be at least three days in the future.')
def test_invalid_embargo_end_date_format(self):
today = timezone.now().isoformat()
payload = {
"data": {
"type": "registrations",
"attributes": {
"draft_registration": self.draft_registration._id,
"registration_choice": "embargo",
"lift_embargo": today
}
}
}
res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm:ss.')
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_cannot_register_draft_that_has_already_been_registered(self, mock_enqueue):
self.draft_registration.register(auth=Auth(self.user), save=True)
res = self.app.post_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'This draft has already been registered and cannot be modified.')
@mock.patch('framework.celery_tasks.handlers.enqueue_task')
def test_cannot_register_draft_that_is_pending_review(self, mock_enqueue):
with mock.patch.object(DraftRegistration, 'is_pending_review', mock.PropertyMock(return_value=True)):
res = self.app.post_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'This draft is pending review and cannot be modified.')
def test_cannot_register_draft_that_has_already_been_approved(self):
with mock.patch.object(DraftRegistration, 'requires_approval', mock.PropertyMock(return_value=True)), mock.patch.object(DraftRegistration, 'is_approved', mock.PropertyMock(return_value=True)):
res = self.app.post_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'This draft has already been approved and cannot be modified.')
class TestDraftFormView(AdminTestCase):
def setUp(self):
super(TestDraftFormView, self).setUp()
self.user = AuthUserFactory()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=utils.draft_reg_util(),
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr1.flags # sets flags if there aren't any yet.
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftFormView
self.view = setup_view(self.plain_view(), self.request, draft_pk=self.dr1._id)
self.post = RequestFactory().post('/fake_path')
self.post.user = UserFactory()
self.post_view = DraftFormView()
self.form_data = {
'notes': 'Far between',
'proof_of_publication': 'approved',
}
self.url = reverse('pre_reg:view_draft', kwargs={'draft_pk': self.dr1._id})
def test_dispatch_raise_404(self):
view = setup_view(DraftFormView(), self.request, draft_pk='wrong')
with nt.assert_raises(Http404):
view.dispatch(self.request)
def test_get_initial(self):
self.view.draft = self.dr1
self.view.get_initial()
res = self.view.initial
nt.assert_is_instance(res, dict)
nt.assert_equal(res['notes'], self.dr1.notes)
nt.assert_equal(res['assignee'], self.dr1.flags['assignee'])
nt.assert_equal(res['payment_sent'], self.dr1.flags['payment_sent'])
nt.assert_equal(res['proof_of_publication'],
self.dr1.flags['proof_of_publication'])
def test_get_context_data(self):
self.view.draft = self.dr1
res = self.view.get_context_data()
nt.assert_is_instance(res, dict)
nt.assert_in('draft', res)
nt.assert_is_instance(res['draft'], dict)
nt.assert_in('IMMEDIATE', res)
def test_form_valid_notes(self):
form = DraftRegistrationForm(data=self.form_data)
nt.assert_true(form.is_valid())
view = setup_form_view(self.post_view, self.post, form,
draft_pk=self.dr1._id)
view.draft = self.dr1
count = AdminLogEntry.objects.count()
with transaction.atomic():
view.form_valid(form)
nt.assert_equal(count, AdminLogEntry.objects.count())
self.dr1.reload()
nt.assert_equal(self.dr1.notes, self.form_data['notes'])
@mock.patch('admin.pre_reg.views.DraftFormView.checkin_files')
@mock.patch('admin.pre_reg.views.DraftRegistration.approve')
def test_form_valid_approve(self, mock_approve, mock_files):
self.form_data.update(approve_reject='approve')
form = DraftRegistrationForm(data=self.form_data)
nt.assert_true(form.is_valid())
view = setup_form_view(self.post_view, self.post, form,
draft_pk=self.dr1._id)
view.draft = self.dr1
count = AdminLogEntry.objects.count()
with transaction.atomic():
view.form_valid(form)
nt.assert_true(mock_approve.called)
nt.assert_equal(count + 1, AdminLogEntry.objects.count())
@mock.patch('admin.pre_reg.views.DraftFormView.checkin_files')
@mock.patch('admin.pre_reg.views.DraftRegistration.reject')
def test_form_valid_reject(self, mock_reject, mock_files):
self.form_data.update(approve_reject='reject')
form = DraftRegistrationForm(data=self.form_data)
nt.assert_true(form.is_valid())
view = setup_form_view(self.post_view, self.post, form,
draft_pk=self.dr1._id)
view.draft = self.dr1
count = AdminLogEntry.objects.count()
with transaction.atomic():
view.form_valid(form)
nt.assert_true(mock_reject.called)
nt.assert_equal(count + 1, AdminLogEntry.objects.count())
def test_no_user_permissions_raises_error(self):
request = RequestFactory().get(self.url)
request.user = self.user
with nt.assert_raises(PermissionDenied):
self.plain_view.as_view()(request, draft_pk=self.dr1._id)
def test_get_correct_view_permissions(self):
view_permission = Permission.objects.get(codename='view_prereg')
self.user.user_permissions.add(view_permission)
self.user.save()
request = RequestFactory().get(self.url)
request.user = self.user
response = self.plain_view.as_view()(request, draft_pk=self.dr1._id)
nt.assert_equal(response.status_code, 200)
def test_post_correct_view_permissions(self):
view_permission = Permission.objects.get(codename='view_prereg')
self.user.user_permissions.add(view_permission)
self.user.save()
request = RequestFactory().get(self.url)
request.user = self.user
response = self.plain_view.as_view()(request, draft_pk=self.dr1._id)
nt.assert_equal(response.status_code, 200)
class TestPreregFiles(AdminTestCase):
def setUp(self):
super(TestPreregFiles, self).setUp()
self.prereg_user = AuthUserFactory()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
prereg_schema = get_prereg_schema()
self.d_of_qs = {
'q7': OsfStorageFile(target=self.node, name='7'),
'q11': OsfStorageFile(target=self.node, name='11'),
'q16': OsfStorageFile(target=self.node, name='16'),
'q12': OsfStorageFile(target=self.node, name='12'),
'q13': OsfStorageFile(target=self.node, name='13'),
'q19': OsfStorageFile(target=self.node, name='19'),
'q26': OsfStorageFile(target=self.node, name='26')
}
data = {}
for q, f in self.d_of_qs.iteritems():
guid = f.get_guid(create=True)._id
f.save()
if q == 'q26':
data[q] = {
'comments': [],
'value': '26',
'extra': [
{
'data': {
'provider': 'osfstorage',
'path': f.path,
},
'fileId': guid,
'nodeId': self.node._id,
}
]
}
continue
data[q] = {
'value': {
'uploader': {
'extra': [
{
'data': {
'provider': 'osfstorage',
'path': f.path,
},
'fileId': guid,
'nodeId': self.node._id,
}
]
}
}
}
self.draft = DraftRegistrationFactory(
initiator=self.user,
branched_from=self.node,
registration_schema=prereg_schema,
registration_metadata=data
)
self.prereg_user.save()
self.admin_user = UserFactory()
self.admin_user.is_superuser = True
self.admin_user.groups.add(Group.objects.get(name='prereg_admin'))
self.admin_user.groups.add(Group.objects.get(name='prereg_view'))
self.admin_user.save()
def test_checkout_checkin_files(self):
self.draft.submit_for_review(self.user, {}, save=True)
request = RequestFactory().get('/fake_path')
view = DraftDetailView()
view = setup_user_view(view, request, self.admin_user,
draft_pk=self.draft._id)
view.checkout_files(self.draft)
for q, f in self.d_of_qs.iteritems():
f.refresh_from_db()
nt.assert_equal(self.admin_user, f.checkout)
# test user attempt force checkin
with nt.assert_raises(file_exceptions.FileNodeCheckedOutError):
self.d_of_qs['q7'].check_in_or_out(self.user, self.admin_user)
# test delete draft returns files
utils.checkin_files(self.draft)
view2 = DraftFormView()
view2 = setup_view(view2, request, draft_pk=self.draft._id)
view2.checkin_files(self.draft)
for q, f in self.d_of_qs.iteritems():
f.refresh_from_db()
nt.assert_equal(None, f.checkout)
def test_rejected_approved_checkouts(self):
self.draft.submit_for_review(self.user, {}, save=True)
# Test rejected does not checkout files
self.draft.approval.state = 'rejected'
self.draft.approval.save()
request = RequestFactory().get('/fake_path')
view = DraftDetailView()
view = setup_user_view(view, request, self.admin_user,
draft_pk=self.draft._id)
view.checkout_files(self.draft)
for q, f in self.d_of_qs.iteritems():
f.refresh_from_db()
nt.assert_equal(None, f.checkout)
# Test approved does not checkout files
self.draft.approval.state = 'approved'
self.draft.approval.save()
request = RequestFactory().get('/fake_path')
view = DraftDetailView()
view = setup_user_view(view, request, self.admin_user,
draft_pk=self.draft._id)
view.checkout_files(self.draft)
for q, f in self.d_of_qs.iteritems():
f.refresh_from_db()
nt.assert_equal(None, f.checkout)
def test_rejected_does_not_checkout_files(self):
self.draft.submit_for_review(self.user, {}, save=True)
self.draft.approval.state = 'rejected'
self.draft.approval.save()
request = RequestFactory().get('/fake_path')
view = DraftDetailView()
view = setup_user_view(view, request, self.admin_user,
draft_pk=self.draft._id)
view.checkout_files(self.draft)
for q, f in self.d_of_qs.iteritems():
f.refresh_from_db()
nt.assert_equal(None, f.checkout)
def test_checkout_checkup(self):
self.draft.submit_for_review(self.user, {}, save=True)
request = RequestFactory().get('/fake_path')
# Test Approved removes checkout
self.draft.approval.state = 'approved'
self.draft.approval.save()
file_q7 = self.d_of_qs['q7']
file_q7.checkout = self.admin_user
file_q7.save()
view = CheckoutCheckupView()
view = setup_user_view(view, request, user=self.admin_user)
view.delete(request, user=self.admin_user)
file_q7.refresh_from_db()
assert file_q7.checkout is None
# Test Rejected removes checkout
self.draft.approval.state = 'rejected'
self.draft.approval.save()
file_q7 = self.d_of_qs['q7']
file_q7.checkout = self.admin_user
file_q7.save()
view = CheckoutCheckupView()
view = setup_user_view(view, request, user=self.admin_user)
view.delete(request, user=self.admin_user)
file_q7.refresh_from_db()
assert file_q7.checkout is None
# Test Unapprove does not remove checkout
self.draft.approval.state = 'unapproved'
self.draft.approval.save()
file_q7 = self.d_of_qs['q7']
file_q7.checkout = self.admin_user
file_q7.save()
view = CheckoutCheckupView()
view = setup_user_view(view, request, user=self.admin_user)
view.delete(request, user=self.admin_user)
file_q7.refresh_from_db()
assert file_q7.checkout == self.admin_user
def test_get_meta_data_files(self):
for item in get_metadata_files(self.draft):
nt.assert_in(type(item), [OsfStorageFile, OsfStorageFileNode])
def test_get_file_questions(self):
questions = get_file_questions('prereg-prize.json')
nt.assert_equal(7, len(questions))
nt.assert_list_equal(
[
(u'q7', u'Data collection procedures'),
(u'q11', u'Manipulated variables'),
(u'q12', u'Measured variables'),
(u'q13', u'Indices'),
(u'q16', u'Study design'),
(u'q19', u'Statistical models'),
(u'q26', u'Upload an analysis script with clear comments')
],
questions
)
def test_file_id_missing(self):
data = self.draft.registration_metadata
data['q7']['value']['uploader']['extra'][0].pop('fileId')
self.draft.update_metadata(data)
for item in get_metadata_files(self.draft):
nt.assert_in(type(item), [OsfStorageFile, OsfStorageFileNode])
def test_file_id_missing_odd(self):
data = self.draft.registration_metadata
data['q26']['extra'][0].pop('fileId')
self.draft.update_metadata(data)
for item in get_metadata_files(self.draft):
nt.assert_in(type(item), [OsfStorageFile, OsfStorageFileNode])
def test_wrong_provider(self):
data = self.draft.registration_metadata
data['q7']['value']['uploader']['extra'][0]['data']['provider'] = 'box'
self.draft.update_metadata(data)
with nt.assert_raises(Http404):
for item in get_metadata_files(self.draft):
pass
def test_wrong_provider_odd(self):
data = self.draft.registration_metadata
data['q26']['extra'][0]['data']['provider'] = 'box'
self.draft.update_metadata(data)
with nt.assert_raises(Http404):
for item in get_metadata_files(self.draft):
pass
def test_delete_pre_submit_draft_does_not_change_checkouts(self):
file_q7 = self.d_of_qs['q7']
file_q7.checkout = self.user
file_q7.save()
utils.checkin_files(self.draft)
file_q7.refresh_from_db()
nt.assert_equal(file_q7.checkout, self.user)
class TestDraftListView(AdminTestCase):
@mock.patch('website.archiver.tasks.archive')
def setUp(self, mock_archive):
super(TestDraftListView, self).setUp()
self.user = AuthUserFactory()
self.schema = utils.draft_reg_util()
self.dr1 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr1.submit_for_review(self.user, {}, save=True)
self.dr2 = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
self.dr2.submit_for_review(self.user, {}, save=True)
# Simply here to NOT be returned when get_queryset is called
self.unsubmitted_prereg = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
self.unsubmitted_prereg.register(Auth(self.user), save=True)
self.request = RequestFactory().get('/fake_path')
self.plain_view = DraftListView
self.view = setup_view(self.plain_view(), self.request)
self.url = reverse('pre_reg:prereg')
def test_get_queryset(self):
res = list(self.view.get_queryset())
nt.assert_equal(len(res), 2)
nt.assert_false(self.unsubmitted_prereg in res)
nt.assert_is_instance(res[0], DraftRegistration)
def test_queryset_returns_in_order_date_submitted(self):
created_first_submitted_second = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
created_second_submitted_first = DraftRegistrationFactory(
initiator=self.user,
registration_schema=self.schema,
registration_metadata=utils.SCHEMA_DATA
)
nt.assert_greater(created_second_submitted_first.datetime_initiated, created_first_submitted_second.datetime_initiated)
created_second_submitted_first.submit_for_review(self.user, {}, save=True)
created_first_submitted_second.submit_for_review(self.user, {}, save=True)
created_second_submitted_first.datetime_updated = created_first_submitted_second.datetime_updated + datetime.timedelta(1)
assert created_second_submitted_first.datetime_updated > created_first_submitted_second.datetime_updated
res = list(self.view.get_queryset())
nt.assert_true(res[0] == created_first_submitted_second)
def test_get_context_data(self):
self.view.object_list = self.view.get_queryset()
res = self.view.get_context_data()
nt.assert_is_instance(res, dict)
nt.assert_is_instance(res['drafts'], list)
nt.assert_equal(len(res['drafts']), 2)
def test_no_user_permissions_raises_error(self):
request = RequestFactory().get(self.url)
request.user = self.user
with nt.assert_raises(PermissionDenied):
self.plain_view.as_view()(request)
def test_correct_view_permissions(self):
view_permission = Permission.objects.get(codename='view_prereg')
self.user.user_permissions.add(view_permission)
self.user.save()
request = RequestFactory().get(self.url)
request.user = self.user
response = self.plain_view.as_view()(request)
nt.assert_equal(response.status_code, 200)
