def get_metaschemas(*args, **kwargs):
"""
List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.
:return: serialized metaschemas
:rtype: dict
"""
count = request.args.get('count', 100)
include = request.args.get('include', 'latest')
meta_schemas = []
if include == 'latest':
schema_names = list(MetaSchema.objects.all().values_list('name', flat=True).distinct())
for name in schema_names:
meta_schema_set = MetaSchema.find(
Q('name', 'eq', name) &
Q('schema_version', 'eq', 2)
)
meta_schemas = meta_schemas + [s for s in meta_schema_set]
else:
meta_schemas = MetaSchema.find()
meta_schemas = [
schema
for schema in meta_schemas
if schema.active
]
meta_schemas.sort(key=lambda a: METASCHEMA_ORDERING.index(a.name))
return {
'meta_schemas': [
serialize_meta_schema(ms) for ms in meta_schemas[:count]
]
}, http.OK
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_ensure_schemas(self):
# Should be zero MetaSchema records to begin with
MetaSchema.remove()
assert_equal(
MetaSchema.find().count(),
0
)
ensure_schemas()
assert_equal(
MetaSchema.find().count(),
len(OSF_META_SCHEMAS)
)
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_update_draft_registration(self):
metadata = {
'summary': {
'value': 'updated',
'comments': []
}
}
assert_not_equal(metadata, self.draft.registration_metadata)
payload = {
'schema_data': metadata,
'schema_name': 'OSF-Standard Pre-Data Collection Registration',
'schema_version': 1
}
url = self.node.api_url_for('update_draft_registration', draft_id=self.draft._id)
res = self.app.put_json(url, payload, auth=self.user.auth)
assert_equal(res.status_code, http.OK)
open_ended_schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', 1)
)
self.draft.reload()
assert_equal(open_ended_schema, self.draft.registration_schema)
assert_equal(metadata, self.draft.registration_metadata)
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")
def setUp(self):
super(TestDraftPreregChallengeRegistrationMetadataValidation, self).setUp()
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 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_on_complete_immediate_creates_registration_for_draft_initiator(self, mock_enquque):
user = factories.UserFactory()
project = factories.ProjectFactory(creator=user)
registration_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
draft = factories.DraftRegistrationFactory(
branched_from=project,
registration_schema=registration_schema,
)
approval = DraftRegistrationApproval(
meta={
'registration_choice': 'immediate'
}
)
approval.save()
draft.approval = approval
draft.save()
approval._on_complete(user)
draft.reload()
registered_node = draft.registered_node
assert registered_node is not None
assert registered_node.is_pending_registration
assert registered_node.registered_user == draft.initiator
def test_approval_after_initiator_is_merged_into_another_user(self, mock_enqueue):
approver = factories.UserFactory()
approver.add_system_tag(settings.PREREG_ADMIN_TAG)
mergee = factories.UserFactory(fullname='Manny Mergee')
merger = factories.UserFactory(fullname='Merve Merger')
project = factories.ProjectFactory(creator=mergee)
registration_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
draft = factories.DraftRegistrationFactory(
branched_from=project,
registration_schema=registration_schema,
)
merger.merge_user(mergee)
approval = DraftRegistrationApproval(
meta={
'registration_choice': 'immediate'
}
)
approval.save()
draft.approval = approval
draft.save()
approval.approve(approver)
draft.reload()
registered_node = draft.registered_node
assert registered_node.registered_user == merger
def test_on_complete_embargo_creates_registration_for_draft_initiator(self, mock_enquque):
user = factories.UserFactory()
end_date = timezone.now() + datetime.timedelta(days=366) # <- leap year
approval = DraftRegistrationApproval(
meta={
'registration_choice': 'embargo',
'embargo_end_date': end_date.isoformat()
}
)
approval.save()
project = factories.ProjectFactory(creator=user)
registration_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
draft = factories.DraftRegistrationFactory(
branched_from=project,
registration_schema=registration_schema,
)
draft.approval = approval
draft.save()
approval._on_complete(user)
draft.reload()
registered_node = draft.registered_node
assert registered_node is not None
assert registered_node.is_pending_embargo
assert registered_node.registered_user == draft.initiator
def get_prereg_schema(campaign='prereg'):
from osf.models import MetaSchema
if campaign not in PREREG_CAMPAIGNS:
raise ValueError('campaign must be one of: {}'.format(', '.join(PREREG_CAMPAIGNS.keys())))
schema_name = PREREG_CAMPAIGNS[campaign]
return MetaSchema.find_one(
Q('name', 'eq', schema_name) &
Q('schema_version', 'eq', 2)
)
def test_registration_metadata_question_values_must_be_dictionaries(self):
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.payload['data']['attributes']['registration_supplement'] = self.schema._id
self.payload['data']['attributes']['registration_metadata'] = {}
self.payload['data']['attributes']['registration_metadata']['datacompletion'] = 'No, data collection has not begun'
res = self.app.post_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 _notify_initiator(self):
DraftRegistration = apps.get_model('osf.DraftRegistration')
registration = self._get_registration()
prereg_schema = MetaSchema.get_prereg_schema()
draft = DraftRegistration.objects.get(registered_node=registration)
if registration.registered_schema.filter(id=prereg_schema.id).exists():
mails.send_mail(draft.initiator.username,
mails.PREREG_CHALLENGE_ACCEPTED,
user=draft.initiator,
registration_url=registration.absolute_url,
mimetype='html')
def node_register_template_page(auth, node, metaschema_id, **kwargs):
if node.is_registration and bool(node.registered_schema):
try:
meta_schema = MetaSchema.find_one(
Q('_id', 'eq', metaschema_id)
)
except NoResultsFound:
# backwards compatability for old urls, lookup by name
try:
meta_schema = MetaSchema.find(
Q('name', 'eq', _id_to_name(metaschema_id))
).order_by('-schema_version').first()
except IndexError:
raise HTTPError(http.NOT_FOUND, data={
'message_short': 'Invalid schema name',
'message_long': 'No registration schema with that name could be found.'
})
if not node.registered_schema.filter(id=meta_schema.id).exists():
raise HTTPError(http.BAD_REQUEST, data={
'message_short': 'Invalid schema',
'message_long': 'This registration has no registration supplment with that name.'
})
ret = _view_project(node, auth, primary=True)
my_meta = serialize_meta_schema(meta_schema)
if has_anonymous_link(node, auth):
for indx, schema_page in enumerate(my_meta['schema']['pages']):
for idx, schema_question in enumerate(schema_page['questions']):
if schema_question['title'] in settings.ANONYMIZED_TITLES:
del my_meta['schema']['pages'][indx]['questions'][idx]
ret['node']['registered_schema'] = serialize_meta_schema(meta_schema)
return ret
else:
status.push_status_message(
'You have been redirected to the project\'s registrations page. From here you can initiate a new Draft Registration to complete the registration process',
trust=False
)
return redirect(node.web_url_for('node_registrations', view=kwargs.get('template')))
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 _email_template_context(self,
user,
node,
is_authorizer=False,
urls=None):
registration = self._get_registration()
prereg_schema = MetaSchema.get_prereg_schema()
if registration.registered_schema.filter(pk=prereg_schema.pk).exists():
return {
'custom_message':
' as part of the Preregistration Challenge (https://cos.io/prereg)'
}
else:
return {}
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 = MetaSchema.find_one(
Q('name', 'eq', 'Open-Ended Registration') &
Q('schema_version', 'eq', 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 = {
u'embargoEndDate': unicode(valid_date.strftime('%a, %d, %B %Y %H:%M:%S')) + u' GMT',
u'registrationChoice': 'embargo'
}
self.invalid_embargo_date_payload = {
u'embargoEndDate': u"Thu, 01 {month} {year} 05:00:00 GMT".format(
month=current_month,
year=str(int(current_year) - 1)
),
u'registrationChoice': 'embargo'
}
self.immediate_payload = {
'registrationChoice': 'immediate'
}
self.invalid_payload = {
'registrationChoice': 'foobar'
}
def test_question_in_registration_metadata_must_be_in_schema(self):
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.payload['data']['attributes']['registration_supplement'] = self.schema._id
self.payload['data']['attributes']['registration_metadata'] = {}
self.payload['data']['attributes']['registration_metadata']['q11'] = {
"value": "No, data collection has not begun"
}
res = self.app.post_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 setUp(self):
super(TestSearchSerializer, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user, is_public=True)
self.component = NodeFactory(parent=self.project, creator=self.user, is_public=True)
self.file = utils.create_test_file(self.component, self.user)
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'Replication Recipe (Brandt et al., 2013): Post-Completion') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
with mock_archive(self.project, autocomplete=True, autoapprove=True, schema=self.schema) as registration:
self.registration = registration
def test_create_from_node(self):
proj = NodeFactory()
user = proj.creator
schema = MetaSchema.find()[0]
data = {'some': 'data'}
draft = DraftRegistration.create_from_node(
proj,
user=user,
schema=schema,
data=data,
)
assert user == draft.initiator
assert schema == draft.registration_schema
assert data == draft.registration_metadata
assert proj == draft.branched_from
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(TestDraftRegistrationCreate, self).setUp()
self.url = '/{}nodes/{}/draft_registrations/'.format(API_BASE, self.public_project._id)
self.open_ended_metaschema = MetaSchema.find_one(
Q('name', 'eq', 'Open-Ended Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.payload = {
"data": {
"type": "draft_registrations",
"attributes": {
"registration_supplement": self.open_ended_metaschema._id
}
}
}
def test_registration_supplement_must_be_most_recent_metaschema(self):
schema = MetaSchema.find_one(
Q('name', 'eq', 'Open-Ended Registration') &
Q('schema_version', 'eq', 1)
)
draft_data = {
"data": {
"type": "draft_registrations",
"attributes": {
"registration_supplement": schema._id
}
}
}
res = self.app.post_json_api(self.url, draft_data, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'Registration supplement must be an active schema.')
def test_drafts_for_user_omits_registered(self):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') & Q('schema_version', 'eq', 2))
d1 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d2 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d3 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d1.registered_node = factories.RegistrationFactory()
d1.save()
drafts = drafts_for_user(self.user, 'prereg')
for d in drafts:
assert_in(d._id, (d2._id, d3._id))
assert_not_equal(d._id, d1._id)
def test_multiple_choice_question_value_must_match_value_in_schema(self):
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
self.payload['data']['attributes']['registration_supplement'] = self.schema._id
self.payload['data']['attributes']['registration_metadata'] = {}
self.payload['data']['attributes']['registration_metadata']['datacompletion'] = {
"value": "Nope, data collection has not begun"
}
res = self.app.post_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_on_reject(self, mock_send_mail):
user = factories.UserFactory()
approval = DraftRegistrationApproval(
meta={'registration_choice': 'immediate'})
approval.save()
project = factories.ProjectFactory(creator=user)
registration_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') & Q('schema_version', 'eq', 2))
draft = factories.DraftRegistrationFactory(
branched_from=project,
registration_schema=registration_schema,
)
draft.approval = approval
draft.save()
approval._on_reject(user)
assert approval.meta == {}
assert mock_send_mail.call_count == 1
def test_has_project_and_draft_registration(self):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge')
)
factories.DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema
)
assert_equal(
landing_page(user=self.user),
{
'has_projects': True,
'has_draft_registrations': True,
'campaign_long': 'Prereg Challenge',
'campaign_short': 'prereg',
}
)
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 = MetaSchema.find_one(
Q('name', 'eq', 'Open-Ended Registration')
& Q('schema_version', 'eq', 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 = {
u'embargoEndDate':
unicode(valid_date.strftime('%a, %d, %B %Y %H:%M:%S')) + u' GMT',
u'registrationChoice':
'embargo'
}
self.invalid_embargo_date_payload = {
u'embargoEndDate':
u"Thu, 01 {month} {year} 05:00:00 GMT".format(
month=current_month, year=str(int(current_year) - 1)),
u'registrationChoice':
'embargo'
}
self.immediate_payload = {'registrationChoice': 'immediate'}
self.invalid_payload = {'registrationChoice': 'foobar'}
def _create(cls, *args, **kwargs):
branched_from = kwargs.get('branched_from')
initiator = kwargs.get('initiator')
registration_schema = kwargs.get('registration_schema')
registration_metadata = kwargs.get('registration_metadata')
if not branched_from:
project_params = {}
if initiator:
project_params['creator'] = initiator
branched_from = ProjectFactory(**project_params)
initiator = branched_from.creator
registration_schema = registration_schema or MetaSchema.find()[0]
registration_metadata = registration_metadata or {}
draft = DraftRegistration.create_from_node(
branched_from,
user=initiator,
schema=registration_schema,
data=registration_metadata,
)
return draft
def test_update_draft_registration(self):
metadata = {'summary': {'value': 'updated', 'comments': []}}
assert_not_equal(metadata, self.draft.registration_metadata)
payload = {
'schema_data': metadata,
'schema_name': 'OSF-Standard Pre-Data Collection Registration',
'schema_version': 1
}
url = self.node.api_url_for('update_draft_registration',
draft_id=self.draft._id)
res = self.app.put_json(url, payload, auth=self.user.auth)
assert_equal(res.status_code, http.OK)
open_ended_schema = MetaSchema.find_one(
Q('name', 'eq', 'OSF-Standard Pre-Data Collection Registration')
& Q('schema_version', 'eq', 1))
self.draft.reload()
assert_equal(open_ended_schema, self.draft.registration_schema)
assert_equal(metadata, self.draft.registration_metadata)
def _create(cls, *args, **kwargs):
branched_from = kwargs.get('branched_from')
initiator = kwargs.get('initiator')
registration_schema = kwargs.get('registration_schema')
registration_metadata = kwargs.get('registration_metadata')
if not branched_from:
project_params = {}
if initiator:
project_params['creator'] = initiator
branched_from = ProjectFactory(**project_params)
initiator = branched_from.creator
registration_schema = registration_schema or MetaSchema.find()[0]
registration_metadata = registration_metadata or {}
draft = DraftRegistration.create_from_node(
branched_from,
user=initiator,
schema=registration_schema,
data=registration_metadata,
)
return draft
def test_factory(self):
draft = factories.DraftRegistrationFactory()
assert draft.branched_from is not None
assert draft.initiator is not None
assert draft.registration_schema is not None
user = factories.UserFactory()
draft = factories.DraftRegistrationFactory(initiator=user)
assert draft.initiator == user
node = factories.ProjectFactory()
draft = factories.DraftRegistrationFactory(branched_from=node)
assert draft.branched_from == node
assert draft.initiator == node.creator
# Pick an arbitrary v2 schema
schema = MetaSchema.find(Q('schema_version', 'eq', 2))[0]
data = {'some': 'data'}
draft = factories.DraftRegistrationFactory(registration_schema=schema,
registration_metadata=data)
assert draft.registration_schema == schema
assert draft.registration_metadata == data
def setUp(self):
super(TestCheckPreregAuth, self).setUp()
self.prereg_challenge_admin_user = AuthUserFactory()
self.prereg_challenge_admin_user.add_system_tag(settings.PREREG_ADMIN_TAG)
self.prereg_challenge_admin_user.save()
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
self.user = AuthUserFactory()
self.node = factories.ProjectFactory(creator=self.user)
self.parent = factories.ProjectFactory()
self.child = factories.NodeFactory(parent=self.parent)
self.draft_registration = factories.DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.parent
)
def setUp(self):
super(TestCheckPreregAuth, self).setUp()
self.prereg_challenge_admin_user = AuthUserFactory()
self.prereg_challenge_admin_user.add_system_tag(settings.PREREG_ADMIN_TAG)
self.prereg_challenge_admin_user.save()
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
self.user = AuthUserFactory()
self.node = factories.ProjectFactory(creator=self.user)
self.parent = factories.ProjectFactory()
self.child = factories.NodeFactory(parent=self.parent)
self.draft_registration = factories.DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema,
branched_from=self.parent
)
def test_on_complete_immediate_creates_registration_for_draft_initiator(
self, mock_enquque):
user = factories.UserFactory()
project = factories.ProjectFactory(creator=user)
registration_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') & Q('schema_version', 'eq', 2))
draft = factories.DraftRegistrationFactory(
branched_from=project,
registration_schema=registration_schema,
)
approval = DraftRegistrationApproval(
meta={'registration_choice': 'immediate'})
approval.save()
draft.approval = approval
draft.save()
approval._on_complete(user)
draft.reload()
registered_node = draft.registered_node
assert registered_node is not None
assert registered_node.is_pending_registration
assert registered_node.registered_user == draft.initiator
def test_on_reject(self, mock_send_mail):
user = factories.UserFactory()
approval = DraftRegistrationApproval(
meta={
'registration_choice': 'immediate'
}
)
approval.save()
project = factories.ProjectFactory(creator=user)
registration_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
draft = factories.DraftRegistrationFactory(
branched_from=project,
registration_schema=registration_schema,
)
draft.approval = approval
draft.save()
approval._on_reject(user)
assert approval.meta == {}
assert mock_send_mail.call_count == 1
def test_factory(self):
draft = factories.DraftRegistrationFactory()
assert draft.branched_from is not None
assert draft.initiator is not None
assert draft.registration_schema is not None
user = factories.UserFactory()
draft = factories.DraftRegistrationFactory(initiator=user)
assert draft.initiator == user
node = factories.ProjectFactory()
draft = factories.DraftRegistrationFactory(branched_from=node)
assert draft.branched_from == node
assert draft.initiator == node.creator
# Pick an arbitrary v2 schema
schema = MetaSchema.find(
Q('schema_version', 'eq', 2)
)[0]
data = {'some': 'data'}
draft = factories.DraftRegistrationFactory(registration_schema=schema, registration_metadata=data)
assert draft.registration_schema == schema
assert draft.registration_metadata == data
def test_drafts_for_user_omits_registered(self):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
d1 = factories.DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema
)
d2 = factories.DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema
)
d3 = factories.DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema
)
d1.registered_node = factories.RegistrationFactory()
d1.save()
drafts = drafts_for_user(self.user, 'prereg')
for d in drafts:
assert_in(d._id, (d2._id, d3._id))
assert_not_equal(d._id, d1._id)
def check_access(node, auth, action, cas_resp):
"""Verify that user can perform requested action on resource. Raise appropriate
error code if action cannot proceed.
"""
permission = permission_map.get(action, None)
if permission is None:
raise HTTPError(httplib.BAD_REQUEST)
if cas_resp:
if permission == 'read':
if node.is_public:
return True
required_scope = oauth_scopes.CoreScopes.NODE_FILE_READ
else:
required_scope = oauth_scopes.CoreScopes.NODE_FILE_WRITE
if not cas_resp.authenticated \
or required_scope not in oauth_scopes.normalize_scopes(cas_resp.attributes['accessTokenScope']):
raise HTTPError(httplib.FORBIDDEN)
if permission == 'read':
if node.can_view(auth):
return True
# The user may have admin privileges on a parent node, in which
# case they should have read permissions
if node.is_registration and node.registered_from.can_view(auth):
return True
if permission == 'write' and node.can_edit(auth):
return True
# Users attempting to register projects with components might not have
# `write` permissions for all components. This will result in a 403 for
# all `copyto` actions as well as `copyfrom` actions if the component
# in question is not public. To get around this, we have to recursively
# check the node's parent node to determine if they have `write`
# permissions up the stack.
# TODO(hrybacki): is there a way to tell if this is for a registration?
# All nodes being registered that receive the `copyto` action will have
# `node.is_registration` == True. However, we have no way of telling if
# `copyfrom` actions are originating from a node being registered.
# TODO This is raise UNAUTHORIZED for registrations that have not been archived yet
if action == 'copyfrom' or (action == 'copyto' and node.is_registration):
parent = node.parent_node
while parent:
if parent.can_edit(auth):
return True
parent = parent.parent_node
# Users with the PREREG_ADMIN_TAG should be allowed to download files
# from prereg challenge draft registrations.
try:
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') & Q('schema_version', 'eq', 2))
allowed_nodes = [node] + node.parents
prereg_draft_registration = DraftRegistration.find(
Q('branched_from', 'in', [n for n in allowed_nodes])
& Q('registration_schema', 'eq', prereg_schema))
if action == 'download' and \
auth.user is not None and \
prereg_draft_registration.count() > 0 and \
settings.PREREG_ADMIN_TAG in auth.user.system_tags:
return True
except NoResultsFound:
pass
raise HTTPError(httplib.FORBIDDEN if auth.user else httplib.UNAUTHORIZED)
def test_metaschema_is_fine_with_same_name_but_different_version(self):
MetaSchema(name='foo', schema={'foo': 42}, schema_version=1).save()
MetaSchema(name='foo', schema={'foo': 42}, schema_version=2).save()
assert_equal(MetaSchema.objects.filter(name='foo').count(), 2)
def get_default_metaschema():
"""This needs to be a method so it gets called after the test database is set up"""
return MetaSchema.find()[0]
def draft_reg_util():
DraftRegistration.remove()
return MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') & Q('schema_version', 'eq', 2))
