Python factories.PreprintFactory类代码示例

    def test_read_write_user_already_a_preprint(self):
        assert_in(self.other_user, self.public_project.contributors)

        preprint = PreprintFactory(creator=self.user)
        preprint.add_contributor(self.other_user, permissions=[permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS], save=True)
        file_one_preprint = test_utils.create_test_file(preprint, self.user, 'openupthatwindow.pdf')

        already_preprint_payload = build_preprint_create_payload(preprint._id, self.subject._id, file_one_preprint._id)
        res = self.app.post_json_api(self.url, already_preprint_payload, auth=self.other_user.auth, expect_errors=True)

        assert_equal(res.status_code, 403)

class TestPreprintFactory(OsfTestCase):
    def setUp(self):
        super(TestPreprintFactory, self).setUp()

        self.user = AuthUserFactory()
        self.auth = Auth(user=self.user)
        self.preprint = PreprintFactory(creator=self.user)
        self.preprint.save()

    def test_is_preprint(self):
        assert_true(self.preprint.node.is_preprint)

    def test_preprint_is_public(self):
        assert_true(self.preprint.node.is_public)

    def setUp(self):
        super(TestSetPreprintFile, self).setUp()

        self.user = AuthUserFactory()
        self.auth = Auth(user=self.user)
        self.read_write_user = AuthUserFactory()
        self.read_write_user_auth = Auth(user=self.read_write_user)

        self.project = ProjectFactory(creator=self.user)
        self.file = OsfStorageFile.create(
            is_file=True,
            node=self.project,
            path='/panda.txt',
            name='panda.txt',
            materialized_path='/panda.txt')
        self.file.save()

        self.file_two = OsfStorageFile.create(
            is_file=True,
            node=self.project,
            path='/pandapanda.txt',
            name='pandapanda.txt',
            materialized_path='/pandapanda.txt')
        self.file_two.save()

        self.project.add_contributor(self.read_write_user, permissions=[permissions.WRITE])
        self.project.save()

        self.preprint = PreprintFactory(project=self.project, finish=False)

    def setUp(self):
        super(TestPreprintUpdateLicense, self).setUp()

        ensure_licenses()

        self.admin_contributor = AuthUserFactory()
        self.rw_contributor = AuthUserFactory()
        self.read_contributor = AuthUserFactory()
        self.non_contributor = AuthUserFactory()

        self.preprint_provider = PreprintProviderFactory()
        self.preprint = PreprintFactory(creator=self.admin_contributor, provider=self.preprint_provider)

        self.preprint.node.add_contributor(self.rw_contributor, auth=Auth(self.admin_contributor))
        self.preprint.node.add_contributor(self.read_contributor, auth=Auth(self.admin_contributor), permissions=['read'])
        self.preprint.node.save()

        self.cc0_license = NodeLicense.find_one(Q('name', 'eq', 'CC0 1.0 Universal'))
        self.mit_license = NodeLicense.find_one(Q('name', 'eq', 'MIT License'))
        self.no_license = NodeLicense.find_one(Q('name', 'eq', 'No license'))

        self.preprint_provider.licenses_acceptable = [self.cc0_license, self.no_license]
        self.preprint_provider.save()

        self.url = '/{}preprints/{}/'.format(API_BASE, self.preprint._id)

    def setUp(self):
        super(TestNodePreprintList, self).setUp()

        self.user = AuthUserFactory()
        self.auth = Auth(self.user)
        self.preprint = PreprintFactory(creator=self.user, is_published=False)

        self.url = '/{}nodes/{}/preprints/'.format(API_BASE, self.preprint.node._id)

    def setUp(self):
        super(TestPreprintUpdate, self).setUp()
        self.user = AuthUserFactory()

        self.preprint = PreprintFactory(creator=self.user)
        self.url = '/{}preprints/{}/'.format(API_BASE, self.preprint._id)

        self.subject = SubjectFactory()

class TestNodePreprintList(ApiTestCase):
    def setUp(self):
        super(TestNodePreprintList, self).setUp()

        self.user = AuthUserFactory()
        self.auth = Auth(self.user)
        self.preprint = PreprintFactory(creator=self.user, is_published=False)

        self.url = '/{}nodes/{}/preprints/'.format(API_BASE, self.preprint.node._id)

    def test_user_can_see_own_unpublished_preprint(self):
        res = self.app.get(self.url, auth=self.user.auth, expect_errors=True)

        assert_equal(res.status_code, 200)
        assert_equal(res.json['data'][0]['id'], self.preprint._id)

    def test_other_user_can_see_unpublished_preprint_on_public_node(self):
        noncontrib = AuthUserFactory()
        self.preprint.node.set_privacy('public')
        res = self.app.get(self.url, auth=noncontrib.auth)

        assert_equal(res.status_code, 200)
        assert_equal(res.json['data'][0]['id'], self.preprint._id)

    def test_other_user_cannot_see_unpublished_preprint_on_private_node(self):
        noncontrib = AuthUserFactory()
        res = self.app.get(self.url, auth=noncontrib.auth, expect_errors=True)

        assert_equal(res.status_code, 403)

    def test_user_can_see_own_published_preprint(self):
        self.preprint.set_published(True, auth=self.auth)
        res = self.app.get(self.url, auth=self.user.auth)

        assert_equal(res.status_code, 200)
        assert_equal(res.json['data'][0]['id'], self.preprint._id)

    def test_other_user_can_see_published_preprint_on_public_node(self):
        self.preprint.set_published(True, auth=self.auth)
        noncontrib = AuthUserFactory()
        res = self.app.get(self.url, auth=noncontrib.auth)

        assert_equal(res.status_code, 200)
        assert_equal(res.json['data'][0]['id'], self.preprint._id)

    def setUp(self):
        super(TestPreprintFiltering, self).setUp()
        self.user = AuthUserFactory()
        self.provider = PreprintProviderFactory(name='wwe')
        self.preprint = PreprintFactory(creator=self.user, providers=[self.provider])

        self.preprint.add_tag('nature boy', Auth(self.user), save=False)
        self.preprint.add_tag('ric flair', Auth(self.user), save=False)
        self.preprint.save()

        self.provider_two = PreprintProviderFactory(name='wcw')
        self.preprint_two = PreprintFactory(creator=self.user, filename='woo.txt', providers=[self.provider_two])
        self.preprint_two.add_tag('nature boy', Auth(self.user), save=False)
        self.preprint_two.add_tag('woo', Auth(self.user), save=False)
        self.preprint_two.save()

        self.preprint_three = PreprintFactory(creator=self.user, filename='stonecold.txt', providers=[self.provider])
        self.preprint_three.add_tag('stone', Auth(self.user), save=False)
        self.preprint_two.add_tag('cold', Auth(self.user), save=False)
        self.preprint_three.save()

class TestOnPreprintUpdatedTask(OsfTestCase):
    def setUp(self):
        super(TestOnPreprintUpdatedTask, self).setUp()
        self.preprint = PreprintFactory()

    def test_format_preprint(self):
        res = format_preprint(self.preprint)
        types = [gn['@type'] for gn in res]
        subject_names = [x['text'] for hier in self.preprint.get_subjects() for x in hier]
        contribs = {}
        for i, user in enumerate(self.preprint.node.contributors):
            contribs.update({i: user})

        for type_ in ['throughlinks', 'throughsubjects', 'throughidentifiers', 'preprint', 'subject', 'person', 'link', 'contributor', 'identifier', 'person']:
            assert type_ in types

        for graph_node in res:
            if graph_node['@type'] == 'throughlinks':
                assert_equal(set(graph_node.keys()), set(['@id', '@type', 'creative_work', 'link']))
            if graph_node['@type'] == 'throughsubjects':
                assert_equal(set(graph_node.keys()), set(['@id', '@type', 'creative_work', 'subject']))
            if graph_node['@type'] == 'throughidentifiers':
                assert_equal(set(graph_node.keys()), set(['@id', '@type', 'identifier', 'person']))
            if graph_node['@type'] == 'preprint':
                assert_equal(set(graph_node.keys()), set([
                    '@id', '@type', 'contributors', 'title', 'tags',
                    'date_published', 'date_updated', 'description',
                    'institutions', 'is_deleted', 'links', 'subjects',
                ]))
                assert_equal(graph_node['date_published'], self.preprint.date_published.isoformat())
                assert_equal(graph_node['date_updated'], self.preprint.date_modified.isoformat())
                assert_equal(graph_node['description'], self.preprint.node.description)
                assert_equal(graph_node['is_deleted'], self.preprint.node.is_deleted)
                assert_equal(graph_node['title'], self.preprint.node.title)
            if graph_node['@type'] == 'subject':
                assert_equal(set(graph_node.keys()), set(['@id', '@type', 'name']))
                assert_in(graph_node['name'], subject_names)
            if graph_node['@type'] == 'person':
                assert_equal(set(graph_node.keys()), set([
                    '@id', '@type', 'additional_name', 'affiliations',
                    'family_name', 'given_name', 'identifiers', 'suffix'
                ]))
            if graph_node['@type'] == 'link':
                assert_equal(set(graph_node.keys()), set(['@id', '@type', 'type', 'url']))
            if graph_node['@type'] == 'contributor':
                assert_equal(set(graph_node.keys()), set([
                    '@id', '@type',  'bibliographic', 'cited_name',
                    'creative_work', 'order_cited', 'person'
                ]))
                user = contribs[graph_node['order_cited']]
                assert_equal(graph_node['cited_name'], user.fullname)
                assert_equal(graph_node['bibliographic'], bool(user._id in self.preprint.node.visible_contributor_ids))
            if graph_node['@type'] == 'identifier':
                assert_equal(set(graph_node.keys()), set(['@id', '@type', 'base_url', 'url']))

    def setUp(self):
        super(TestPreprintRelationshipPreprintProvider, self).setUp()
        self.user = AuthUserFactory()
        self.read_write_user = AuthUserFactory()

        self.preprint = PreprintFactory(creator=self.user, providers=None)
        self.preprint.add_contributor(self.read_write_user)
        self.preprint.save()

        self.preprint_provider_one = PreprintProviderFactory()
        self.preprint_provider_two = PreprintProviderFactory()

        self.preprint_preprint_providers_url = self.create_url(self.preprint._id)

    def setUp(self):
        super(TestOnPreprintUpdatedTask, self).setUp()
        self.user = AuthUserFactory()
        self.auth = Auth(user=self.user)
        self.preprint = PreprintFactory()

        self.preprint.node.add_tag('preprint', self.auth, save=False)
        self.preprint.node.add_tag('spoderman', self.auth, save=False)
        self.preprint.node.add_unregistered_contributor('BoJack Horseman', '[email protected]', Auth(self.preprint.node.creator))
        self.preprint.node.add_contributor(self.user, visible=False)
        self.preprint.node.save()

        self.preprint.node.creator.given_name = 'ZZYZ'
        self.preprint.node.creator.save()

        self.preprint.set_subjects([[SubjectFactory()._id]], auth=Auth(self.preprint.node.creator), save=False)

class TestPreprintProviders(OsfTestCase):
    def setUp(self):
        super(TestPreprintProviders, self).setUp()
        self.preprint = PreprintFactory(providers=[])
        self.provider = PreprintProviderFactory(name='WWEArxiv')

    def test_add_provider(self):
        assert_not_equal(self.preprint.provider, self.provider)

        self.preprint.provider = self.provider
        self.preprint.save()
        self.preprint.reload()

        assert_equal(self.preprint.provider, self.provider)

    def test_remove_provider(self):
        self.preprint.provider = None
        self.preprint.save()
        self.preprint.reload()

        assert_equal(self.preprint.provider, None)

class TestPreprintProviders(OsfTestCase):
    def setUp(self):
        super(TestPreprintProviders, self).setUp()
        self.preprint = PreprintFactory(providers=[])
        self.provider = PreprintProviderFactory(name='WWEArxiv')

    def test_add_provider(self):
        assert_equal(self.preprint.preprint_providers, [])

        self.preprint.add_preprint_provider(self.provider, user=self.preprint.creator, save=True)

        assert_items_equal(self.preprint.preprint_providers, [self.provider])

    def test_remove_provider(self):
        self.preprint.add_preprint_provider(self.provider, user=self.preprint.creator, save=True)

        assert_items_equal(self.preprint.preprint_providers, [self.provider])

        self.preprint.remove_preprint_provider(self.provider, user=self.preprint.creator, save=True)

        assert_equal(self.preprint.preprint_providers, [])

class TestPreprintFiltering(ApiTestCase):

    def setUp(self):
        super(TestPreprintFiltering, self).setUp()
        self.user = AuthUserFactory()
        self.provider = PreprintProviderFactory(name='wwe')
        self.preprint = PreprintFactory(creator=self.user, providers=[self.provider])

        self.preprint.add_tag('nature boy', Auth(self.user), save=False)
        self.preprint.add_tag('ric flair', Auth(self.user), save=False)
        self.preprint.save()

        self.provider_two = PreprintProviderFactory(name='wcw')
        self.preprint_two = PreprintFactory(creator=self.user, filename='woo.txt', providers=[self.provider_two])
        self.preprint_two.add_tag('nature boy', Auth(self.user), save=False)
        self.preprint_two.add_tag('woo', Auth(self.user), save=False)
        self.preprint_two.save()

        self.preprint_three = PreprintFactory(creator=self.user, filename='stonecold.txt', providers=[self.provider])
        self.preprint_three.add_tag('stone', Auth(self.user), save=False)
        self.preprint_two.add_tag('cold', Auth(self.user), save=False)
        self.preprint_three.save()

    def tearDown(self):
        super(TestPreprintFiltering, self).tearDown()
        Node.remove()

    def test_filtering_tags(self):
        # both preprint and preprint_two have nature boy
        url = '/{}preprints/?filter[tags]={}'.format(API_BASE, 'nature boy')

        res = self.app.get(url, auth=self.user.auth)
        reg_json = res.json['data']

        ids = [each['id'] for each in reg_json]
        assert_in(self.preprint._id, ids)
        assert_in(self.preprint_two._id, ids)
        assert_not_in(self.preprint_three._id, ids)

        # filtering two tags
        # preprint has both tags; preprint_two only has one
        url = '/{}preprints/?filter[tags]={}&filter[tags]={}'.format(API_BASE, 'nature boy', 'ric flair')

        res = self.app.get(url, auth=self.user.auth)
        reg_json = res.json['data']

        ids = [each['id'] for each in reg_json]
        assert_in(self.preprint._id, ids)
        assert_not_in(self.preprint_two._id, ids)
        assert_not_in(self.preprint_three._id, ids)

    def test_filter_by_doi(self):
        url = '/{}preprints/?filter[doi]={}'.format(API_BASE, self.preprint.preprint_doi)

        res = self.app.get(url, auth=self.user.auth)
        data = res.json['data']

        assert_equal(len(data), 1)
        for result in data:
            assert_equal(self.preprint._id, result['id'])

class TestPreprintRelationshipPreprintProvider(ApiTestCase):
    def setUp(self):
        super(TestPreprintRelationshipPreprintProvider, self).setUp()
        self.user = AuthUserFactory()
        self.read_write_user = AuthUserFactory()

        self.preprint = PreprintFactory(creator=self.user, providers=None)
        self.preprint.add_contributor(self.read_write_user)
        self.preprint.save()

        self.preprint_provider_one = PreprintProviderFactory()
        self.preprint_provider_two = PreprintProviderFactory()

        self.preprint_preprint_providers_url = self.create_url(self.preprint._id)

    def create_url(self, preprint_id):
        return '/{0}preprints/{1}/relationships/preprint_providers/'.format(API_BASE, preprint_id)

    def create_payload(self, *preprint_provider_ids):
        data = []
        for provider_id in preprint_provider_ids:
            data.append({'type': 'preprint_providers', 'id': provider_id})
        return {'data': data}

    def test_add_preprint_providers(self):
        assert_equal(self.preprint.preprint_providers, None)
        res = self.app.post_json_api(
            self.preprint_preprint_providers_url,
            self.create_payload(self.preprint_provider_one._id, self.preprint_provider_two._id),
            auth=self.user.auth
        )

        assert_equal(res.status_code, 201)

        # check the relationship
        self.preprint.reload()
        assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
        assert_in(self.preprint_provider_two, self.preprint.preprint_providers)

    def test_add_through_patch_one_provider_while_removing_other(self):
        self.preprint.preprint_providers = [self.preprint_provider_one]
        self.preprint.save()

        assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
        assert_not_in(self.preprint_provider_two, self.preprint.preprint_providers)

        res = self.app.patch_json_api(
            self.preprint_preprint_providers_url,
            self.create_payload(self.preprint_provider_two._id),
            auth=self.user.auth
        )

        assert_equal(res.status_code, 200)

        self.preprint.reload()
        assert_not_in(self.preprint_provider_one, self.preprint.preprint_providers)
        assert_in(self.preprint_provider_two, self.preprint.preprint_providers)

    def test_add_through_post_to_preprint_with_provider(self):
        self.preprint.preprint_providers = [self.preprint_provider_one]
        self.preprint.save()

        assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
        assert_not_in(self.preprint_provider_two, self.preprint.preprint_providers)

        res = self.app.post_json_api(
            self.preprint_preprint_providers_url,
            self.create_payload(self.preprint_provider_two._id),
            auth=self.user.auth
        )

        assert_equal(res.status_code, 201)

        self.preprint.reload()
        assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
        assert_in(self.preprint_provider_two, self.preprint.preprint_providers)

    def test_add_provider_with_no_permissions(self):
        new_user = AuthUserFactory()
        new_user.save()
        res = self.app.post_json_api(
            self.preprint_preprint_providers_url,
            self.create_payload(self.preprint_provider_one._id),
            auth=new_user.auth,
            expect_errors=True,
        )

        assert_equal(res.status_code, 403)

    def test_delete_nothing(self):
        res = self.app.delete_json_api(
            self.preprint_preprint_providers_url,
            self.create_payload(),
            auth=self.user.auth
        )
        assert_equal(res.status_code, 204)

    def test_remove_providers(self):
        self.preprint.preprint_providers = [self.preprint_provider_one]
        self.preprint.save()
#.........这里部分代码省略.........