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