def test_get_draft_registrations_only_gets_drafts_for_that_node(self): dummy = NodeFactory() # Drafts for dummy node for i in range(5): d = DraftRegistrationFactory(initiator=self.user, branched_from=dummy, meta_schema=self.meta_schema, schema_data={}) found = [self.draft] # Drafts for self.node for i in range(3): d = DraftRegistrationFactory(initiator=self.user, branched_from=self.node, meta_schema=self.meta_schema, schema_data={}) found.append(d) url = self.node.api_url_for('get_draft_registrations') res = self.app.get(url, auth=self.user.auth) assert_equal(res.status_code, http.OK) # 3 new, 1 from setUp assert_equal(len(res.json['drafts']), 4) for draft in res.json['drafts']: assert_in(draft['pk'], [f._id for f in found])
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(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(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(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 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(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_multiple_choice_in_registration_schema_must_match_one_of_choices( self, mock_enqueue): draft_registration = DraftRegistrationFactory( initiator=self.user, registration_schema=self.schema, branched_from=self.public_project, registration_metadata={ 'item29': { 'value': 'Yes' }, 'item33': { 'value': 'success!' } }) self.payload['data']['attributes'][ 'draft_registration'] = draft_registration._id res = self.app.post_json_api(self.url, self.payload, auth=self.user.auth, expect_errors=True) assert_equal(res.status_code, 400) assert_equal( res.json['errors'][0]['detail'], "u'success!' is not one of [u'success', u'informative failure to replicate'," " u'practical failure to replicate', u'inconclusive']")
def test_registration_draft_must_be_draft_of_current_node( self, mock_enqueue): new_project = ProjectFactory(creator=self.user) draft_registration = DraftRegistrationFactory( initiator=self.user, registration_schema=self.schema, branched_from=new_project, registration_metadata={ 'item29': { 'value': 'Yes' }, 'item33': { 'value': 'success' } }) payload = { "data": { "type": "registrations", "attributes": { "registration_choice": "immediate", "draft_registration": draft_registration._id } } } res = self.app.post_json_api(self.url, payload, auth=self.user.auth, expect_errors=True) assert_equal(res.status_code, 400) assert_equal( res.json['errors'][0]['detail'], 'This draft registration is not created from the given node.')
def setUp(self): super(TestDraftListView, self).setUp() self.user = AuthUserFactory() schema = utils.draft_reg_util() self.dr1 = DraftRegistrationFactory( initiator=self.user, registration_schema=schema, registration_metadata=utils.SCHEMA_DATA) self.dr1.submit_for_review(self.user, {}, save=True) self.dr2 = DraftRegistrationFactory( initiator=self.user, registration_schema=schema, registration_metadata=utils.SCHEMA_DATA) self.dr2.submit_for_review(self.user, {}, save=True) self.request = RequestFactory().get('/fake_path') self.view = DraftListView() self.view = setup_view(self.view, self.request)
def setUp(self): super(RegistrationEmbargoModelsTestCase, self).setUp() self.user = UserFactory() self.project = ProjectFactory(creator=self.user) self.draft = DraftRegistrationFactory(branched_from=self.project, initiator=self.user) self.registration = RegistrationFactory(project=self.project) self.embargo = EmbargoFactory(user=self.user) self.valid_embargo_end_date = datetime.datetime.utcnow( ) + datetime.timedelta(days=3)
def setUp(self): super(TestCommentUpdateView, self).setUp() self.user = AuthUserFactory() self.dr1 = DraftRegistrationFactory( initiator=self.user, registration_schema=utils.draft_reg_util(), registration_metadata=utils.SCHEMA_DATA) self.dr1.submit_for_review(self.user, {}, save=True) self.request = RequestFactory().post('/fake_path', data={'blah': 'arg'}) self.request.user = UserFactory() self.view = CommentUpdateView() self.view = setup_view(self.view, self.request, draft_pk=self.dr1._id)
def test_factory(self): draft = DraftRegistrationFactory() assert_is_not_none(draft.branched_from) assert_is_not_none(draft.initiator) assert_is_not_none(draft.registration_schema) user = AuthUserFactory() draft = DraftRegistrationFactory(initiator=user) assert_equal(draft.initiator, user) node = ProjectFactory() draft = DraftRegistrationFactory(branched_from=node) assert_equal(draft.branched_from, node) assert_equal(draft.initiator, node.creator) # Pick an arbitrary v2 schema schema = MetaSchema.find(Q('schema_version', 'eq', 2))[0] data = {'some': 'data'} draft = DraftRegistrationFactory(registration_schema=schema, registration_metadata=data) assert_equal(draft.registration_schema, schema) assert_equal(draft.registration_metadata, data)
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 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(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 setUp(self): super(TestDraftFormView, self).setUp() self.user = AuthUserFactory() self.dr1 = DraftRegistrationFactory( initiator=self.user, registration_schema=utils.draft_reg_util(), registration_metadata=utils.SCHEMA_DATA) self.dr1.submit_for_review(self.user, {}, save=True) self.dr1.flags # sets flags if there aren't any yet. self.request = RequestFactory().get('/fake_path') self.view = DraftFormView() self.view = setup_view(self.view, self.request, draft_pk=self.dr1._id) self.post = RequestFactory().post('/fake_path') self.post.user = UserFactory() self.post_view = DraftFormView() self.form_data = { 'notes': 'Far between', 'proof_of_publication': 'approved', }
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._id, 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 setUp(self): super(TestMigrateRegistrationExtra, self).setUp() self.user = UserFactory() self.node = ProjectFactory(creator=self.user) self.file = self._get_test_file() MetaSchema.remove() self.file_ans = { 'file': { 'data':{ 'kind':'file', 'extra':{ 'checkout': None, 'hashes':{ 'sha256':'1fffe6116ecfa778f9938060d5caab923ba4b8db60bd2dd57f16a72e5ef06292' }, 'downloads':0, 'version':1 }, 'modified':'2016-04-15T18:10:48', 'name':'file.txt', 'provider':'osfstorage', } } } self.complex_metadata = { 'q1': { 'value': 'Answer 1', 'extra': [] }, 'q2': { 'value': 'Answer 2', 'extra': {} }, 'q3': { 'value': 'Answer 3', 'extra': self.file_ans }, 'q4': { 'value': { 'question': { 'value': 'Answer 4', 'extra': {} }, 'uploader': { 'value': '', 'extra': {} } }, }, 'q5': { 'value': 'Answer 5', 'extra': [ { 'viewUrl': '/project/abcdef/files/osfstorage/5723787136b74e1a953d9612/', 'hasSelectedFile': True, 'selectedFileName': 'file.txt' } ] } } self.simple_metadata = { 'Summary': 'Some airy' } self.schema = get_prereg_schema() self.draft1 = DraftRegistrationFactory( registration_metadata=self.complex_metadata, registration_schema=self.schema, approval=None, registered_node=None ) self.draft2 = DraftRegistrationFactory( registration_metadata=self.simple_metadata )