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(TestPreregFiles, self).setUp()
self.prereg_user = AuthUserFactory()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
ensure_schemas()
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(TestRegistrationCreate, self).setUp()
ensure_schemas()
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 get_default_metaschema():
"""This needs to be a method so it gets called after the test database is set up"""
try:
return MetaSchema.find()[0]
except IndexError:
ensure_schemas()
return MetaSchema.find()[0]
def test_on_complete_immediate_creates_registration_for_draft_initiator(self, mock_enquque):
ensure_schemas()
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 get_default_metaschema():
"""This needs to be a method so it gets called after the test database is set up"""
try:
return MetaSchema.find()[0]
except IndexError:
ensure_schemas()
return MetaSchema.find()[0]
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)
ensure_schemas()
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 draft_reg_util():
DraftRegistration.remove()
ensure_schemas()
return MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
def test_archive_success_different_name_same_sha(self):
ensure_schemas()
file_tree = file_tree_factory(0, 0, 0)
fake_file = file_factory()
fake_file2 = file_factory(sha256=fake_file['extra']['hashes']['sha256'])
file_tree['children'] = [fake_file, fake_file2]
node = factories.NodeFactory(creator=self.user)
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
data = {
('q_' + fake_file['name']): {
'value': fake.word(),
'extra': {
'sha256': fake_file['extra']['hashes']['sha256'],
'viewUrl': '/project/{0}/files/osfstorage{1}'.format(
node._id,
fake_file['path']
),
'selectedFileName': fake_file['name'],
'nodeId': node._id
}
}
}
with test_utils.mock_archive(node, schema=prereg_schema, data=data, autocomplete=True, autoapprove=True) as registration:
with mock.patch.object(StorageAddonBase, '_get_file_tree', mock.Mock(return_value=file_tree)):
job = factories.ArchiveJobFactory()
archive_success(registration._id, job._id)
for key, question in registration.registered_meta[prereg_schema._id].items():
assert_equal(question['extra']['selectedFileName'], fake_file['name'])
def setUp(self):
super(TestRegistrationCreate, self).setUp()
ensure_schemas()
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_ensure_schemas(self):
# Should be zero MetaSchema records to begin with
assert_equal(MetaSchema.find().count(), 0)
ensure_schemas()
assert_equal(MetaSchema.find().count(), len(OSF_META_SCHEMAS))
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(RegistrationEmbargoViewsTestCase, self).setUp()
ensure_schemas()
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 = datetime.datetime.now().strftime("%B")
current_year = datetime.datetime.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 = datetime.datetime.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(PreregViewsTests, self).setUp()
ensure_schemas()
self.osf_user = factories.AuthUserFactory()
password = fake.password(),
self.user = User.objects.create(
email=fake.email(),
first_name=fake.first_name(),
last_name=fake.last_name(),
osf_id=self.osf_user._id
)
self.user.set_password(password)
self.user.save()
self.logged_in = self.client.login(username=self.user.email, password=password)
PREREG_GROUP.user_set.add(self.user)
PREREG_GROUP.save()
self.prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)
self.other_schema = MetaSchema.find(
Q('name', 'ne', 'Prereg Challenge') &
Q('schema_version', 'eq', 2)
)[0]
def setUp(self):
super(RegistrationEmbargoViewsTestCase, self).setUp()
ensure_schemas()
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 = datetime.datetime.now().strftime("%B")
current_year = datetime.datetime.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 = datetime.datetime.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(TestSearchRegistrations, self).setUp()
self.url = '/{}search/registrations/'.format(API_BASE)
ensure_schemas()
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
with mock_archive(self.project_two,
autocomplete=True,
autoapprove=True,
schema=self.schema) as registration_two:
self.registration_two = registration_two
with mock_archive(self.private_project,
autocomplete=True,
autoapprove=True,
schema=self.schema) as private_registration:
self.private_registration = private_registration
self.private_registration.is_public = False
self.private_registration.save()
def setUp(self):
super(TestPreregFiles, self).setUp()
self.prereg_user = AuthUserFactory()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
ensure_schemas()
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(osf_id=self.prereg_user.pk)
def setUp(self):
super(TestMigrateSchemas, self).setUp()
MetaSchema.remove()
ensure_schemas()
self.regular_old_node = factories.NodeFactory()
self.open_ended_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[0]) & Q('schema_version', 'eq', 1))
self.open_ended = self._make_registration(self.open_ended_schema)
self.standard_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[1]) & Q('schema_version', 'eq', 1))
self.standard = self._make_registration(self.standard_schema)
self.brandt_pre_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[2]) & Q('schema_version', 'eq', 1))
self.brandt_pre = self._make_registration(self.brandt_pre_schema)
self.brandt_post_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[3]) & Q('schema_version', 'eq', 1))
self.brandt_post = self._make_registration(self.brandt_post_schema)
self.multiple = self._make_registration(
[self.brandt_pre_schema, self.brandt_post_schema])
self.confirmatory_schema = MetaSchema.find_one(
Q('name', 'eq', 'Confirmatory - General'))
self.confirmatory = self._make_registration(self.confirmatory_schema)
self.db['node'].update({}, {'$set': {
'registered_schema': None
}},
multi=True)
def setUp(self):
super(TestMetaSchemaDetail, self).setUp()
self.user = AuthUserFactory()
ensure_schemas()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge')
& Q('schema_version', 'eq', LATEST_SCHEMA_VERSION))
self.url = '/{}metaschemas/{}/'.format(API_BASE, self.schema._id)
def test_auth_login_with_campaign_logged_in(self):
ensure_schemas()
url = web_url_for('auth_login', campaign='prereg')
user = factories.AuthUserFactory()
with self.app.app.test_request_context(url), mock_auth(user):
res = auth_views.auth_login()
assert_equal(res.status_code, http.FOUND)
assert_equal(res.location, campaigns.CAMPAIGNS['prereg']['redirect_url']())
def init_app(settings_module='website.settings',
set_backends=True,
routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
logger.info(
'Initializing the application from process {}, thread {}.'.format(
os.getpid(), thread.get_ident()))
# The settings module
settings = importlib.import_module(settings_module)
init_addons(settings, routes)
with open(
os.path.join(settings.STATIC_FOLDER, 'built',
'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
# default config for flask app, however, this does not affect setting cookie using set_cookie()
app.config['SESSION_COOKIE_SECURE'] = settings.SESSION_COOKIE_SECURE
app.config['SESSION_COOKIE_HTTPONLY'] = settings.SESSION_COOKIE_HTTPONLY
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
def test_auth_login_with_campaign_logged_in(self):
ensure_schemas()
url = web_url_for('auth_login', campaign='prereg')
user = factories.AuthUserFactory()
with self.app.app.test_request_context(url), mock_auth(user):
res = auth_views.auth_login()
assert_equal(res.status_code, http.FOUND)
assert_equal(res.location,
campaigns.CAMPAIGNS['prereg']['redirect_url']())
def main(dev=False, _db=None):
_db = _db or db
init_app(routes=False)
count = 0
skipped = 0
scripts_utils.add_file_logger(logger, __file__)
logger.info("Iterating over all registrations")
# convert registered_schema to list field
prepare_nodes()
ensure_schemas()
node_documents = _db['node'].find({'is_registration': True})
for node in node_documents:
registered_schemas = []
registered_meta = {}
schemas = node['registered_meta']
if not schemas:
logger.info(
'Node: {0} is registered but has no registered_meta'.format(
node['_id']))
continue
for schema_id, schema in schemas.iteritems():
name = _id_to_name(from_mongo(schema_id))
schema = from_json_or_fail(schema)
# append matching schema to node.registered_schema
try:
meta_schema = MetaSchema.find(Q(
'name', 'eq', name)).sort('-schema_version')[0]
except IndexError as e:
logger.error(
'No MetaSchema matching name: {0} found for node: {1}.'.
format(name, node['_id']))
# Skip over missing schemas
skipped += 1
if dev:
continue
else:
raise e
else:
registered_meta[meta_schema._id] = {
key: {
'value': value
}
for key, value in schema.items()
}
registered_schemas.append(meta_schema._id)
db['node'].update({'_id': node['_id']}, {
'$set': {
'registered_meta': registered_meta,
'registered_schema': registered_schemas
}
})
count = count + 1
logger.info('Done with {0} nodes migrated and {1} nodes skipped.'.format(
count, skipped))
def init_app(settings_module='website.settings', set_backends=True, routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
logger.info('Initializing the application from process {}, thread {}.'.format(
os.getpid(), thread.get_ident()
))
# The settings module
settings = importlib.import_module(settings_module)
init_addons(settings, routes)
with open(os.path.join(settings.STATIC_FOLDER, 'built', 'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
# default config for flask app, however, this does not affect setting cookie using set_cookie()
app.config['SESSION_COOKIE_SECURE'] = settings.SESSION_COOKIE_SECURE
app.config['SESSION_COOKIE_HTTPONLY'] = settings.SESSION_COOKIE_HTTPONLY
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
def setUp(self):
super(TestRegistrations, self).setUp()
ensure_schemas()
self.user = AuthUserFactory()
self.auth = self.user.auth
self.original = ProjectFactory(creator=self.user, is_public=True)
# A registration
self.project = RegistrationFactory(
creator=self.user,
project=self.original,
user=self.user,
)
def setUp(self):
super(TestRegistrations, self).setUp()
ensure_schemas()
self.user = AuthUserFactory()
self.auth = self.user.auth
self.original = ProjectFactory(creator=self.user, is_public=True)
# A registration
self.project = RegistrationFactory(
creator=self.user,
project=self.original,
user=self.user,
)
def setUp(self):
super(TestDraftRegistrationList, self).setUp()
ensure_schemas()
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 main(dev=False, _db=None):
_db = _db or db
init_app(routes=False)
count = 0
skipped = 0
scripts_utils.add_file_logger(logger, __file__)
logger.info("Iterating over all registrations")
# convert registered_schema to list field
prepare_nodes()
ensure_schemas()
node_documents = _db['node'].find({'is_registration': True})
for node in node_documents:
registered_schemas = []
registered_meta = {}
schemas = node['registered_meta']
if not schemas:
logger.info('Node: {0} is registered but has no registered_meta'.format(node['_id']))
continue
for schema_id, schema in schemas.iteritems():
name = _id_to_name(from_mongo(schema_id))
schema = from_json_or_fail(schema)
# append matching schema to node.registered_schema
try:
meta_schema = MetaSchema.find(
Q('name', 'eq', name)
).sort('-schema_version')[0]
except IndexError as e:
logger.error('No MetaSchema matching name: {0} found for node: {1}.'.format(name, node['_id']))
# Skip over missing schemas
skipped += 1
if dev:
continue
else:
raise e
else:
registered_meta[meta_schema._id] = {
key: {
'value': value
}
for key, value in schema.items()
}
registered_schemas.append(meta_schema._id)
db['node'].update(
{'_id': node['_id']},
{'$set': {
'registered_meta': registered_meta,
'registered_schema': registered_schemas
}}
)
count = count + 1
logger.info('Done with {0} nodes migrated and {1} nodes skipped.'.format(count, skipped))
def init_app(settings_module='website.settings',
set_backends=True,
routes=True,
mfr=False,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
build_js_config_files(settings)
app.debug = settings.DEBUG_MODE
if mfr:
init_mfr(app)
if set_backends:
logger.debug('Setting storage backends')
set_up_storage(
website.models.MODELS,
storage.MongoStorage,
addons=settings.ADDONS_AVAILABLE,
)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
apply_middlewares(app, settings)
return app
def test_ensure_schemas(self):
# Should be zero MetaSchema records to begin with
assert_equal(
MetaSchema.find().count(),
0
)
ensure_schemas()
assert_equal(
MetaSchema.find().count(),
len(OSF_META_SCHEMAS)
)
def init_app(settings_module='website.settings',
set_backends=True,
routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
with open(
os.path.join(settings.STATIC_FOLDER, 'built',
'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
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()
MetaSchema.remove()
ensure_schemas()
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 = dt.datetime.now().strftime("%B")
current_year = dt.datetime.now().strftime("%Y")
valid_date = dt.datetime.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 setUpPrereg(self):
ensure_schemas()
self.prereg_challenge_admin_user = AuthUserFactory()
self.prereg_challenge_admin_user.system_tags.append(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)
)
# import ipdb; ipdb.set_trace()
self.draft_registration = factories.DraftRegistrationFactory(
initiator=self.user,
registration_schema=prereg_schema
)
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 setUp(self):
super(TestDraftRegistrationCreate, self).setUp()
self.url = "/{}nodes/{}/draft_registrations/".format(API_BASE, self.public_project._id)
ensure_schemas()
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 setUp(self):
super(TestDraftRegistrationList, self).setUp()
ensure_schemas()
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 init_app(settings_module='website.settings', set_backends=True, routes=True, mfr=False,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
build_js_config_files(settings)
app.debug = settings.DEBUG_MODE
if mfr:
init_mfr(app)
if set_backends:
logger.debug('Setting storage backends')
set_up_storage(
website.models.MODELS,
storage.MongoStorage,
addons=settings.ADDONS_AVAILABLE,
)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
apply_middlewares(app, settings)
return app
def setUp(self):
super(TestRegistrations, self).setUp()
ensure_schemas()
self.user = UserFactory()
# Add an API key for quicker authentication
api_key = ApiKeyFactory()
self.user.api_keys.append(api_key)
self.user.save()
self.auth = ('test', api_key._primary_key)
self.original = ProjectFactory(creator=self.user, is_public=True)
# A registration
self.project = RegistrationFactory(
project=self.original,
user=self.user,
)
def setUp(self):
super(TestDraftRegistrationDelete, self).setUp()
ensure_schemas()
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_registration_metadata_question_values_must_be_dictionaries(self):
ensure_schemas()
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 setUp(self):
super(TestRegistrations, self).setUp()
ensure_schemas()
self.user = UserFactory()
# Add an API key for quicker authentication
api_key = ApiKeyFactory()
self.user.api_keys.append(api_key)
self.user.save()
self.auth = ('test', api_key._primary_key)
self.original = ProjectFactory(creator=self.user, is_public=True)
# A registration
self.project = RegistrationFactory(
creator=self.user,
project=self.original,
user=self.user,
)
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)
ensure_schemas()
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_question_in_registration_metadata_must_be_in_schema(self):
ensure_schemas()
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(TestDraftRegistrationDelete, self).setUp()
ensure_schemas()
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_create_from_node(self):
ensure_schemas()
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(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)
ensure_schemas()
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 init_app(settings_module='website.settings', set_backends=True, routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
with open(os.path.join(settings.STATIC_FOLDER, 'built', 'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
def setUp(self):
super(TestDraftRegistrationCreate, self).setUp()
self.url = '/{}nodes/{}/draft_registrations/'.format(
API_BASE, self.public_project._id)
ensure_schemas()
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 setUp(self):
super(TestCheckPreregAuth, self).setUp()
ensure_schemas()
self.prereg_challenge_admin_user = AuthUserFactory()
self.prereg_challenge_admin_user.system_tags.append(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_archive_success_same_file_in_component(self):
ensure_schemas()
file_tree = file_tree_factory(3, 3, 3)
selected = select_files_from_tree(file_tree).values()[0]
child_file_tree = file_tree_factory(0, 0, 0)
child_file_tree['children'] = [selected]
node = factories.NodeFactory(creator=self.user)
child = factories.NodeFactory(creator=self.user, parent=node)
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') & Q('schema_version', 'eq', 2))
data = {
('q_' + selected['name']): {
'value': fake.word(),
'extra': {
'sha256':
selected['extra']['hashes']['sha256'],
'viewUrl':
'/project/{0}/files/osfstorage{1}'.format(
child._id, selected['path']),
'selectedFileName':
selected['name'],
'nodeId':
child._id
}
}
}
with test_utils.mock_archive(node,
schema=prereg_schema,
data=data,
autocomplete=True,
autoapprove=True) as registration:
with mock.patch.object(StorageAddonBase, '_get_file_tree',
mock.Mock(return_value=file_tree)):
job = factories.ArchiveJobFactory()
archive_success(registration._id, job._id)
child_reg = registration.nodes[0]
for key, question in registration.registered_meta[
prereg_schema._id].items():
assert_in(child_reg._id, question['extra']['viewUrl'])
def setUp(self):
super(TestMigrateSchemas, self).setUp()
MetaSchema.remove()
ensure_schemas()
self.regular_old_node = factories.NodeFactory()
self.open_ended_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[0]) &
Q('schema_version', 'eq', 1)
)
self.open_ended = self._make_registration(self.open_ended_schema)
self.standard_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[1]) &
Q('schema_version', 'eq', 1)
)
self.standard = self._make_registration(self.standard_schema)
self.brandt_pre_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[2]) &
Q('schema_version', 'eq', 1)
)
self.brandt_pre = self._make_registration(self.brandt_pre_schema)
self.brandt_post_schema = MetaSchema.find_one(
Q('name', 'eq', SCHEMA_NAMES[3]) &
Q('schema_version', 'eq', 1)
)
self.brandt_post = self._make_registration(self.brandt_post_schema)
self.multiple = self._make_registration([
self.brandt_pre_schema,
self.brandt_post_schema
])
self.confirmatory_schema = MetaSchema.find_one(
Q('name', 'eq', 'Confirmatory - General')
)
self.confirmatory = self._make_registration(self.confirmatory_schema)
self.db['node'].update({}, {'$set': {'registered_schema': None}}, multi=True)
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
try:
registration_schema = registration_schema or MetaSchema.find()[0]
except IndexError:
ensure_schemas()
registration_metadata = registration_metadata or {}
draft = DraftRegistration.create_from_node(
branched_from, user=initiator, schema=registration_schema, data=registration_metadata
)
return draft
def test_registration_metadata_question_values_must_be_dictionaries(self):
ensure_schemas()
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 test_multiple_choice_question_value_must_match_value_in_schema(self):
ensure_schemas()
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_question_in_registration_metadata_must_be_in_schema(self):
ensure_schemas()
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(TestSearchRegistrations, self).setUp()
self.url = '/{}search/registrations/'.format(API_BASE)
ensure_schemas()
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
with mock_archive(self.project_two, autocomplete=True, autoapprove=True,
schema=self.schema) as registration_two:
self.registration_two = registration_two
with mock_archive(self.private_project, autocomplete=True, autoapprove=True,
schema=self.schema) as private_registration:
self.private_registration = private_registration
self.private_registration.is_public = False
self.private_registration.save()
