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