Python api.Deposit类代码示例

def test_deposit_index(db, es):
    """Test update embargoed records."""
    deposit_index_name = 'deposits-records-record-v1.0.0'
    rec1 = Record.create({
        'title': 'One',
        '_deposit': {
            'status': 'published',
            'pid': {
                'type': 'recid',
                'value': '1'
            }
        }
    })
    PersistentIdentifier.create(pid_type='recid', pid_value='1',
                                status=PIDStatus.REGISTERED,
                                object_uuid=rec1.id, object_type='rec')
    Deposit.create({
        '_deposit': {
            'status': 'published',
            'pid': {
                'type': 'recid',
                'value': '1'
            }
        }
    })
    db.session.commit()
    current_search.flush_and_refresh(deposit_index_name)
    res = current_search.client.search(index=deposit_index_name)
    # Make sure the 'title' was indexed from record
    assert res['hits']['hits'][0]['_source']['title'] == 'One'

def test_schemas(app, db, fake_schemas):
    """Test schema URL transformations."""
    deposit = Deposit.create({})
    assert "http://localhost/schemas/deposits/deposit-v1.0.0.json" == deposit["$schema"]

    assert "http://localhost/schemas/deposit-v1.0.0.json" == deposit.record_schema

    assert "http://localhost/schemas/deposits/test-v1.0.0.json" == deposit.build_deposit_schema(
        {"$schema": "http://localhost/schemas/test-v1.0.0.json"}
    )

    with pytest.raises(RefResolutionError):
        Deposit.create({"$schema": "http://localhost/schemas/deposits/invalid.json"})

def test_created_by_population(app, db, users):
    """Test created_by gets populated correctly."""
    record = {
        'title': 'fuu'
    }

    deposit = Deposit.create(record)
    assert 'created_by' not in deposit['_deposit']

    with app.test_request_context():
        login_user(users[0])
        deposit = Deposit.create(record)
        assert deposit['_deposit']['created_by'] == users[0].id

def test_created_by_population(api, users):
    """Test created_by gets populated correctly."""
    record = {
        'title': 'fuu'
    }

    deposit = Deposit.create(record)
    assert 'created_by' not in deposit['_deposit']

    with api.test_request_context():
        datastore = api.extensions['security'].datastore
        login_user(datastore.find_user(email=users[0]['email']))
        deposit = Deposit.create(record)
        assert deposit['_deposit']['created_by'] == users[0]['id']

def test_delete(app, db, fake_schemas):
    """Test simple delete."""
    deposit = Deposit.create({})
    pid = deposit.pid
    assert deposit['_deposit']['id']
    assert 'draft' == deposit['_deposit']['status']
    assert 0 == deposit.revision_id

    deposit.delete()

    with pytest.raises(NoResultFound):
        Deposit.get_record(deposit.id)

    with pytest.raises(PIDInvalidAction):
        deposit.publish(pid=pid)

def test_delete(app, db, fake_schemas, location):
    """Test simple delete."""
    deposit = Deposit.create({})
    pid = deposit.pid
    assert deposit["_deposit"]["id"]
    assert "draft" == deposit.status
    assert 0 == deposit.revision_id

    deposit.delete()

    with pytest.raises(NoResultFound):
        Deposit.get_record(deposit.id)

    with pytest.raises(PIDInvalidAction):
        deposit.publish(pid=pid)

def test_file_put_oauth2(api, deposit, files, users,
                         write_token_user_1):
    """PUT a deposit file with oauth2."""
    with api.test_request_context():
        with api.test_client() as client:
            old_file_id = files[0].file_id
            old_filename = files[0].key
            new_filename = '{0}-new-name'.format(old_filename)
            # test rename file
            res = client.put(
                url_for('invenio_deposit_rest.depid_file',
                        pid_value=deposit['_deposit']['id'],
                        key=old_filename),
                data=json.dumps({'filename': new_filename}),
                headers=[
                    ('Authorization',
                     'Bearer {0}'.format(write_token_user_1.access_token))
                ]
            )
            deposit_id = deposit.id
            db.session.expunge(deposit.model)
            deposit = Deposit.get_record(deposit_id)
            files = list(deposit.files)
            assert res.status_code == 200
            assert new_filename == files[0].key
            assert old_file_id == files[0].file_id
            data = json.loads(res.data.decode('utf-8'))
            obj = files[0]
            assert data['filename'] == obj.key
            assert data['checksum'] == obj.file.checksum
            assert data['id'] == str(obj.file.id)

def test_publish_revision_changed_not_mergeable(app, location,
                                                fake_schemas):
    """Try to Publish and someone change the deposit in the while."""
    # create a deposit
    deposit = Deposit.create({"metadata": {
        "title": "title-1",
    }})
    deposit.commit()
    db.session.commit()
    # publish
    deposit.publish()
    db.session.commit()
    # edit
    deposit = deposit.edit()
    db.session.commit()
    # simulate a externally modification
    rid, record = deposit.fetch_published()
    rev_id = record.revision_id
    record.update({'metadata': {
        "title": "title-2.1",
    }})
    record.commit()
    db.session.commit()
    assert rev_id != record.revision_id
    # edit again and check the merging
    deposit.update({"metadata": {
        "title": "title-2.2",
    }})
    deposit.commit()
    with pytest.raises(MergeConflict):
        deposit.publish()

def test_publish_revision_changed_mergeable(app, db, location, fake_schemas):
    """Try to Publish and someone change the deposit in the while."""
    # create a deposit
    deposit = Deposit.create({"metadata": {"title": "title-1"}})
    deposit.commit()
    db.session.commit()
    # publish
    deposit.publish()
    db.session.commit()
    # edit
    deposit = deposit.edit()
    db.session.commit()
    # simulate a externally modification
    rid, record = deposit.fetch_published()
    rev_id = record.revision_id
    # try to change metadata
    record.update({"metadata": {"title": "title-1", "poster": "myposter"}})
    record.commit()
    db.session.commit()
    assert rev_id != record.revision_id
    # edit again and check the merging
    deposit.update({"metadata": {"title": "title-1", "description": "mydesc"}})
    deposit.commit()
    deposit.publish()
    db.session.commit()
    # check if is properly merged
    did, deposit = deposit.fetch_published()
    assert deposit["metadata"]["title"] == "title-1"
    assert deposit["metadata"]["poster"] == "myposter"
    assert deposit["metadata"]["description"] == "mydesc"
    assert deposit["$schema"] == "http://localhost/schemas/deposit-v1.0.0.json"

def records():
    """Load records."""
    import pkg_resources
    import uuid
    from flask_login import login_user, logout_user
    from dojson.contrib.marc21 import marc21
    from dojson.contrib.marc21.utils import create_record, split_blob
    from invenio_accounts.models import User
    from invenio_deposit.api import Deposit

    users = User.query.all()

    # pkg resources the demodata
    data_path = pkg_resources.resource_filename(
        'invenio_records', 'data/marc21/bibliographic.xml'
    )
    with open(data_path) as source:
        with current_app.test_request_context():
            indexer = RecordIndexer()
            with db.session.begin_nested():
                for index, data in enumerate(split_blob(source.read()),
                                             start=1):
                    login_user(users[index % len(users)])
                    # do translate
                    record = marc21.do(create_record(data))
                    # create record
                    indexer.index(Deposit.create(record))
                    logout_user()
            db.session.commit()

def test_files_put_oauth2(app, db, deposit, files, users, write_token_user_1):
    """Test put deposito files with oauth2."""
    with app.test_request_context():
        with app.test_client() as client:
            # fixture
            content = b'### Testing textfile 2 ###'
            stream = BytesIO(content)
            key = 'world.txt'
            deposit.files[key] = stream
            deposit.commit()
            db.session.commit()
            deposit_id = deposit.id
            db.session.expunge(deposit.model)
            deposit = Deposit.get_record(deposit_id)
            key0 = files[0].key
            files = list(deposit.files)
            assert files[0]['key'] == str(key0)
            assert files[1]['key'] == str(key)
            # order files
            res = client.put(
                url_for('invenio_deposit_rest.dep_files',
                        pid_value=deposit['_deposit']['id']),
                data=json.dumps([
                    {'id': key},
                    {'id': key0}
                ]),
                headers=[
                    ('Authorization',
                     'Bearer {0}'.format(write_token_user_1.access_token))
                ]
            )
            assert res.status_code == 200
            data = json.loads(res.data.decode('utf-8'))
            assert data[0]['filename'] == str(key)
            assert data[1]['filename'] == str(key0)

def test_file_delete(api, deposit, files, users):
    """Test delete file."""
    with api.test_request_context():
        # the user is the owner
        with api.test_client() as client:
            deposit_id = deposit.id
            res = client.delete(url_for(
                'invenio_deposit_rest.depid_file',
                pid_value=deposit['_deposit']['id'],
                key=files[0].key
            ))
            assert res.status_code == 401
            db.session.expunge(deposit.model)
            deposit = Deposit.get_record(deposit_id)
            assert files[0].key in deposit.files
            assert deposit.files[files[0].key] is not None
            # login
            res = client.post(url_for_security('login'), data=dict(
                email=users[0]['email'],
                password="tester"
            ))
            # delete resource
            res = client.delete(url_for(
                'invenio_deposit_rest.depid_file',
                pid_value=deposit['_deposit']['id'],
                key=files[0].key
            ))
            assert res.status_code == 204
            assert res.data == b''
            db.session.expunge(deposit.model)
            deposit = Deposit.get_record(deposit_id)
            assert files[0].key not in deposit.files

        # the user is NOT the owner
        with api.test_client() as client:
            # login
            res = client.post(url_for_security('login'), data=dict(
                email=users[1]['email'],
                password="tester2"
            ))
            # delete resource
            res = client.delete(url_for(
                'invenio_deposit_rest.depid_file',
                pid_value=deposit['_deposit']['id'],
                key=files[0].key
            ))
            assert res.status_code == 403

def test_schemas(app, fake_schemas):
    """Test schema URL transformations."""
    deposit = Deposit.create({})
    assert 'http://localhost/schemas/deposits/deposit-v1.0.0.json' == \
        deposit['$schema']

    assert 'http://localhost/schemas/deposit-v1.0.0.json' == \
        deposit.record_schema

    assert 'http://localhost/schemas/deposits/test-v1.0.0.json' == \
        deposit.build_deposit_schema({
            '$schema': 'http://localhost/schemas/test-v1.0.0.json',
        })

    with pytest.raises(RefResolutionError):
        Deposit.create({
            '$schema': 'http://localhost/schemas/deposits/invalid.json',
        })

def test_simple_flow(app, fake_schemas, location):
    """Test simple flow of deposit states through its lifetime."""
    deposit = Deposit.create({})
    assert deposit['_deposit']['id']
    assert 'draft' == deposit.status
    assert 0 == deposit.revision_id

    deposit.publish()
    assert 'published' == deposit.status
    assert 1 == deposit.revision_id

    with pytest.raises(PIDInvalidAction):
        deposit.delete()
    with pytest.raises(PIDInvalidAction):
        deposit.clear()
    with pytest.raises(PIDInvalidAction):
        deposit.update(title='Revision 2')
    assert 'published' == deposit.status

    deposit = deposit.edit()
    assert 'draft' == deposit.status
    assert 2 == deposit.revision_id
    assert 0 == deposit['_deposit']['pid']['revision_id']

    with pytest.raises(PIDInvalidAction):
        deposit.edit()
    assert 'draft' == deposit.status

    deposit['title'] = 'Revision 1'
    deposit.publish()
    assert 'published' == deposit.status
    assert 3 == deposit.revision_id
    assert 0 == deposit['_deposit']['pid']['revision_id']

    deposit = deposit.edit()
    assert 'draft' == deposit.status
    assert 4 == deposit.revision_id
    assert 1 == deposit['_deposit']['pid']['revision_id']

    deposit['title'] = 'Revision 2'
    deposit.commit()
    assert 5 == deposit.revision_id

    (_, record) = deposit.fetch_published()
    record_schema_before = record['$schema']
    record_json = deepcopy(record.model.json)

    deposit = deposit.discard()
    assert 'published' == deposit.status
    assert 'Revision 1' == deposit['title']
    assert 6 == deposit.revision_id

    (_, record) = deposit.fetch_published()
    record_schema_after = record['$schema']
    assert record_schema_before == record_schema_after
    assert record_json == record.model.json

def test_simple_flow(app, db, fake_schemas, location):
    """Test simple flow of deposit states through its lifetime."""
    deposit = Deposit.create({})
    assert deposit["_deposit"]["id"]
    assert "draft" == deposit.status
    assert 0 == deposit.revision_id

    deposit.publish()
    assert "published" == deposit.status
    assert 1 == deposit.revision_id

    with pytest.raises(PIDInvalidAction):
        deposit.delete()
    with pytest.raises(PIDInvalidAction):
        deposit.clear()
    with pytest.raises(PIDInvalidAction):
        deposit.update(title="Revision 2")
    assert "published" == deposit.status

    deposit = deposit.edit()
    assert "draft" == deposit.status
    assert 2 == deposit.revision_id
    assert 0 == deposit["_deposit"]["pid"]["revision_id"]

    with pytest.raises(PIDInvalidAction):
        deposit.edit()
    assert "draft" == deposit.status

    deposit["title"] = "Revision 1"
    deposit.publish()
    assert "published" == deposit.status
    assert 3 == deposit.revision_id
    assert 0 == deposit["_deposit"]["pid"]["revision_id"]

    deposit = deposit.edit()
    assert "draft" == deposit.status
    assert 4 == deposit.revision_id
    assert 1 == deposit["_deposit"]["pid"]["revision_id"]

    deposit["title"] = "Revision 2"
    deposit.commit()
    assert 5 == deposit.revision_id

    (_, record) = deposit.fetch_published()
    record_schema_before = record["$schema"]
    record_json = deepcopy(record.model.json)

    deposit = deposit.discard()
    assert "published" == deposit.status
    assert "Revision 1" == deposit["title"]
    assert 6 == deposit.revision_id

    (_, record) = deposit.fetch_published()
    record_schema_after = record["$schema"]
    assert record_schema_before == record_schema_after
    assert record_json == record.model.json