Beispiel #1
0
def test_scriptinfo(test_apps, monkeypatch):
    """Test of ScriptInfo."""
    obj = ScriptInfo(app_import_path="cliapp.app:testapp")
    assert obj.load_app().name == "testapp"
    assert obj.load_app().name == "testapp"

    def create_app(info):
        return Flask("createapp")

    obj = ScriptInfo(create_app=create_app)
    app = obj.load_app()
    assert app.name == "createapp"
    assert obj.load_app() == app

    obj = ScriptInfo()
    pytest.raises(NoAppException, obj.load_app)

    # import app from wsgi.py in current directory
    monkeypatch.chdir(os.path.abspath(os.path.join(
        os.path.dirname(__file__), 'test_apps', 'helloworld'
    )))
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == 'hello'

    # import app from app.py in current directory
    monkeypatch.chdir(os.path.abspath(os.path.join(
        os.path.dirname(__file__), 'test_apps', 'cliapp'
    )))
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == 'testapp'
Beispiel #2
0
 def main(self, *args, **kwargs):
     '''
     Instanciate ScriptInfo before parent does
     to ensure the `settings` parameters is available to `create_app
     '''
     obj = kwargs.get('obj')
     if obj is None:
         obj = ScriptInfo(create_app=self.create_app)
     # This is the import line: allows create_app to access the settings
     obj.settings = kwargs.pop('settings', 'udata.settings.Defaults')
     kwargs['obj'] = obj
     return super(UdataGroup, self).main(*args, **kwargs)
Beispiel #3
0
def test_scriptinfo(test_apps):
    """Test of ScriptInfo."""
    obj = ScriptInfo(app_import_path="cliapp.app:testapp")
    assert obj.load_app().name == "testapp"
    assert obj.load_app().name == "testapp"

    def create_app(info):
        return Flask("createapp")

    obj = ScriptInfo(create_app=create_app)
    app = obj.load_app()
    assert app.name == "createapp"
    assert obj.load_app() == app
def webassets(app):
    """Flask application fixture with assets."""
    initial_dir = os.getcwd()
    os.chdir(app.instance_path)

    script_info = ScriptInfo(create_app=lambda info: app)
    script_info._loaded_app = app

    runner = CliRunner()
    runner.invoke(npm, obj=script_info)

    subprocess.call(['npm', 'install'])
    runner.invoke(collect, ['-v'], obj=script_info)
    runner.invoke(assets, ['build'], obj=script_info)

    yield app

    os.chdir(initial_dir)
Beispiel #5
0
class FlaskJob(Job):
    """
    The RQ Job class that is capable to running with a Flask app
    context. This requires setting the ``FLASK_APP`` environment
    variable.
    """
    def __init__(self, *args, **kwargs):
        super(FlaskJob, self).__init__(*args, **kwargs)
        self.script_info = ScriptInfo()

    def load_app(self):
        if current_app:
            app = current_app
        else:
            app = self.script_info.load_app()
        return app

    def perform(self):
        app = self.load_app()
        with app.app_context():
            return super(FlaskJob, self).perform()
Beispiel #6
0
def test_scriptinfo(test_apps, monkeypatch):
    """Test of ScriptInfo."""
    obj = ScriptInfo(app_import_path="cliapp.app:testapp")
    assert obj.load_app().name == "testapp"
    assert obj.load_app().name == "testapp"

    def create_app(info):
        return Flask("createapp")

    obj = ScriptInfo(create_app=create_app)
    app = obj.load_app()
    assert app.name == "createapp"
    assert obj.load_app() == app

    obj = ScriptInfo()
    pytest.raises(NoAppException, obj.load_app)

    # import app from wsgi.py in current directory
    monkeypatch.chdir(
        os.path.abspath(
            os.path.join(os.path.dirname(__file__), 'test_apps',
                         'helloworld')))
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == 'hello'

    # import app from app.py in current directory
    monkeypatch.chdir(
        os.path.abspath(
            os.path.join(os.path.dirname(__file__), 'test_apps', 'cliapp')))
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == 'testapp'
Beispiel #7
0
def test_pid_unassign(app, db):
    """Test pid object unassignment."""
    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    with runner.isolated_filesystem():
        rec_uuid = uuid.uuid4()
        # Assigned object
        result = runner.invoke(
            cmd, ['create', 'recid', '101', '-t', 'rec', '-i',
                  str(rec_uuid)],
            obj=script_info)
        assert 0 == result.exit_code

        result = runner.invoke(cmd, [
            'get',
            'recid',
            '101',
        ], obj=script_info)
        assert 0 == result.exit_code
        assert 'rec {0} N\n'.format(str(rec_uuid)) == result.output

        result = runner.invoke(cmd, [
            'dereference',
            'rec',
            str(rec_uuid),
        ],
                               obj=script_info)
        assert 0 == result.exit_code
        assert 'recid 101 None\n' == result.output

        result = runner.invoke(cmd, [
            'dereference',
            'rec',
            str(rec_uuid),
            '-s',
            'NEW',
        ],
                               obj=script_info)
        assert 0 == result.exit_code
        assert 'recid 101 None\n' == result.output

        with app.app_context():
            pid = PersistentIdentifier.get('recid', '101')
            assert pid.has_object()
            assert pid.get_assigned_object() == rec_uuid
            assert pid.get_assigned_object('rec') == rec_uuid

        # Unassign the object
        result = runner.invoke(cmd, [
            'unassign',
            'recid',
            '101',
        ],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            pid = PersistentIdentifier.get('recid', '101')
            assert not pid.has_object()
            assert pid.get_assigned_object() is None
            assert pid.get_assigned_object('rec') is None
Beispiel #8
0
def test_pid_assign(app, db):
    """Test pid object assignment."""
    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    with runner.isolated_filesystem():
        # No assigned object
        result = runner.invoke(cmd, ['create', 'doi', '10.1234/foo'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            pid = PersistentIdentifier.get('doi', '10.1234/foo')
            assert not pid.has_object()
            assert pid.get_assigned_object() is None
            assert pid.get_assigned_object('rec') is None

        # Assign object
        rec_uuid = uuid.uuid4()
        result = runner.invoke(
            cmd,
            ['assign', 'doi', '10.1234/foo', '-t', 'rec', '-i',
             str(rec_uuid)],
            obj=script_info)
        assert 0 == result.exit_code
        with app.app_context():
            pid = PersistentIdentifier.get('doi', '10.1234/foo')
            assert pid.has_object()
            assert pid.get_assigned_object() == rec_uuid
            assert pid.get_assigned_object('rec') == rec_uuid
            assert pid.get_assigned_object('oth') is None

        # Doesnt' raise
        result = runner.invoke(
            cmd,
            ['assign', 'doi', '10.1234/foo', '-t', 'rec', '-i',
             str(rec_uuid)],
            obj=script_info)
        assert 0 == result.exit_code

        # Missing type or uuid:
        result = runner.invoke(cmd, [
            'assign',
            'doi',
            '10.1234/foo',
        ],
                               obj=script_info)
        assert 2 == result.exit_code

        result = runner.invoke(cmd, [
            'assign',
            'doi',
            '10.1234/foo',
            '-t',
            'rec',
        ],
                               obj=script_info)
        assert 2 == result.exit_code

        result = runner.invoke(cmd, [
            'assign',
            'doi',
            '10.1234/foo',
            '-i',
            str(rec_uuid),
        ],
                               obj=script_info)
        assert 2 == result.exit_code

        # Assign without overwrite (uuid as str and uuid)
        new_uuid = uuid.uuid4()
        result = runner.invoke(
            cmd,
            ['assign', 'doi', '10.1234/foo', '-t', 'rec', '-i',
             str(new_uuid)],
            obj=script_info)
        assert -1 == result.exit_code

        # Assign with overwrite
        result = runner.invoke(cmd, [
            'assign', 'doi', '10.1234/foo', '-s', 'REGISTERED', '-t', 'rec',
            '-i',
            str(new_uuid), '--overwrite'
        ],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            pid = PersistentIdentifier.get('doi', '10.1234/foo')
            assert pid.has_object()
            assert pid.status == PIDStatus.REGISTERED
            assert pid.get_assigned_object() == new_uuid
            assert pid.get_assigned_object('rec') == new_uuid
            assert pid.get_assigned_object('oth') is None
def test_scriptinfo(test_apps, monkeypatch):
    obj = ScriptInfo(app_import_path="cliapp.app:testapp")
    app = obj.load_app()
    assert app.name == "testapp"
    assert obj.load_app() is app

    # import app with module's absolute path
    cli_app_path = str(test_path / "cliapp" / "app.py")

    obj = ScriptInfo(app_import_path=cli_app_path)
    app = obj.load_app()
    assert app.name == "testapp"
    assert obj.load_app() is app
    obj = ScriptInfo(app_import_path=f"{cli_app_path}:testapp")
    app = obj.load_app()
    assert app.name == "testapp"
    assert obj.load_app() is app

    def create_app():
        return Flask("createapp")

    obj = ScriptInfo(create_app=create_app)
    app = obj.load_app()
    assert app.name == "createapp"
    assert obj.load_app() is app

    obj = ScriptInfo()
    pytest.raises(NoAppException, obj.load_app)

    # import app from wsgi.py in current directory
    monkeypatch.chdir(test_path / "helloworld")
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == "hello"

    # import app from app.py in current directory
    monkeypatch.chdir(test_path / "cliapp")
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == "testapp"
Beispiel #10
0
def test_init(app, template_entrypoints):
    """Run client initialization."""
    suffix = '-abc'
    search = app.extensions['invenio-search']
    search._current_suffix = suffix
    search.register_mappings('records', 'mock_module.mappings')

    assert 'records' in search.aliases
    assert set(search.aliases['records']) == {
        'records-authorities', 'records-bibliographic',
        'records-default-v1.0.0'
    }
    assert set(search.aliases['records']['records-authorities']) == {
        'records-authorities-authority-v1.0.0',
    }
    assert set(search.aliases['records']['records-bibliographic']) == {
        'records-bibliographic-bibliographic-v1.0.0',
    }
    assert set(search.mappings.keys()) == {
        'records-authorities-authority-v1.0.0',
        'records-bibliographic-bibliographic-v1.0.0', 'records-default-v1.0.0'
    }
    assert 3 == len(search.mappings)

    with patch('invenio_search.ext.iter_entry_points',
               return_value=template_entrypoints('invenio_search.templates')):
        if ES_VERSION[0] == 2:
            assert len(search.templates.keys()) == 2
            assert 'record-view-v1' in search.templates
            assert 'subdirectory-file-download-v1' in search.templates
        else:
            assert len(search.templates.keys()) == 1
            assert 'record-view-v{}'.format(ES_VERSION[0]) in search.templates

    current_search_client.indices.delete_alias('_all',
                                               '_all',
                                               ignore=[400, 404])
    current_search_client.indices.delete('*')
    aliases = current_search_client.indices.get_alias()
    assert 0 == len(aliases)

    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    with runner.isolated_filesystem():
        result = runner.invoke(cmd, ['init', '--force'], obj=script_info)
        assert result.exit_code == 0
        if ES_VERSION[0] == 2:
            assert current_search_client.indices.exists_template(
                'subdirectory-file-download-v1')
            assert current_search_client.indices.exists_template(
                'record-view-v1')
        else:
            assert current_search_client.indices.exists_template(
                'record-view-v{}'.format(ES_VERSION[0]))
        assert 0 == result.exit_code

    aliases = current_search_client.indices.get_alias()
    assert 8 == sum(len(idx.get('aliases', {})) for idx in aliases.values())

    assert current_search_client.indices.exists(list(search.mappings.keys()))

    # Clean-up:
    result = runner.invoke(cmd, ['destroy'], obj=script_info)
    assert 1 == result.exit_code

    result = runner.invoke(cmd, ['destroy', '--yes-i-know'], obj=script_info)
    assert 0 == result.exit_code

    aliases = current_search_client.indices.get_alias()
    assert 0 == len(aliases)
Beispiel #11
0
def test_communities_list(app, test_communities):
    with app.app_context():
        runner = CliRunner()
        script_info = ScriptInfo(create_app=lambda info: app)
        result = runner.invoke(communities_cmd, ["list"], obj=script_info)
        assert len(result.output) > 0
def test_locate_app(test_apps, iname, aname, result):
    info = ScriptInfo()
    assert locate_app(info, iname, aname).name == result
 def runner(command, args=""):
     obj = ScriptInfo(app_import_path="tests/integration/app.py")
     return CliRunner().invoke(command, args=args, obj=obj)
Beispiel #14
0
 def __init__(self, *args, **kwargs):
     super(FlaskJob, self).__init__(*args, **kwargs)
     self.script_info = ScriptInfo()
def test_cli(app, db):
    """Test CLI."""
    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    assert 'records_metadata' in db.metadata.tables
    assert 'records_metadata_version' in db.metadata.tables
    assert 'transaction' in db.metadata.tables

    from invenio_records.models import RecordMetadata as RM
    from invenio_pidstore.models import PersistentIdentifier, PIDStatus

    # Test merging a base another file.
    with runner.isolated_filesystem():
        with open('record.json', 'wb') as f:
            f.write(
                json.dumps({
                    'title': 'Test'
                }, ensure_ascii=False).encode('utf-8'))

        with open('records.json', 'wb') as f:
            f.write(
                json.dumps([{
                    'title': 'Test1'
                }, {
                    'title': 'Test2'
                }],
                           ensure_ascii=False).encode('utf-8'))

        with open('record.patch', 'wb') as f:
            f.write(
                json.dumps([{
                    'op': 'replace',
                    'path': '/title',
                    'value': 'Patched Test'
                }],
                           ensure_ascii=False).encode('utf-8'))

        result = runner.invoke(cli.records, [], obj=script_info)
        assert result.exit_code == 0

        with app.app_context():
            assert RM.query.count() == 0

        result = runner.invoke(
            cli.records, ['create', 'record.json', '--pid-minter', 'recid'],
            obj=script_info)
        assert result.exit_code == 0
        recid = result.output.split('\n')[0]

        with app.app_context():
            assert RM.query.count() == 1
            record = RM.query.first()
            assert recid
            assert recid == str(record.id)
            assert "1" == record.json['control_number']
            pid = PersistentIdentifier.query.filter_by(
                object_uuid=record.id).one()
            assert pid.status == PIDStatus.REGISTERED
            assert pid.pid_value

        result = runner.invoke(cli.records,
                               ['patch', 'record.patch', '-i', recid],
                               obj=script_info)
        assert result.exit_code == 0

        with app.app_context():
            record = Record.get_record(recid)
            assert record['title'] == 'Patched Test'
            assert record.model.version_id == 2

        # Test generated UUIDs
        recid1 = uuid.uuid4()
        recid2 = uuid.uuid4()
        assert recid1 != recid2

        # More ids than records.
        result = runner.invoke(
            cli.records,
            ['create', 'record.json', '-i', recid1, '--id', recid2],
            obj=script_info)
        assert result.exit_code == -1

        result = runner.invoke(cli.records,
                               ['create', 'record.json', '-i', recid],
                               obj=script_info)
        assert result.exit_code == 2

        result = runner.invoke(
            cli.records, ['create', 'record.json', '-i', recid, '--force'],
            obj=script_info)
        assert result.exit_code == 0

        with app.app_context():
            record = Record.get_record(recid)
            assert record.model.version_id == 3

        result = runner.invoke(cli.records,
                               ['create', 'records.json', '-i', recid1],
                               obj=script_info)
        assert result.exit_code == -1

        result = runner.invoke(
            cli.records,
            ['create', 'records.json', '-i', recid1, '-i', recid2],
            obj=script_info)
        assert result.exit_code == 0
        with app.app_context():
            assert 3 == RM.query.count()

        # Check metadata after force insert.
        result = runner.invoke(
            cli.records, ['create', 'record.json', '-i', recid1, '--force'],
            obj=script_info)
        assert result.exit_code == 0
        with app.app_context():
            record = Record.get_record(recid1)
            assert 'Test' == record['title']
            assert 'Test1' == record.revisions[0]['title']

        # More modifications of record 1.
        result = runner.invoke(cli.records, [
            'create', 'records.json', '-i', recid1, '--id', recid2, '--force'
        ],
                               obj=script_info)
        assert result.exit_code == 0
        with app.app_context():
            record = Record.get_record(recid1)
            assert 'Test1' == record['title']
            assert 'Test' == record.revisions[1]['title']
            assert 'Test1' == record.revisions[0]['title']

        # Delete records.
        result = runner.invoke(cli.records, ['delete', '-i', recid1],
                               obj=script_info)
        assert result.exit_code == 0
        with app.app_context():
            assert RM.query.get(recid1).json is None

        result = runner.invoke(cli.records,
                               ['delete', '-i', recid1, '--force'],
                               obj=script_info)
        assert result.exit_code == 0
        with app.app_context():
            assert RM.query.get(recid1) is None

        result = runner.invoke(cli.records,
                               ['delete', '-i', recid2, '--force'],
                               obj=script_info)
        assert result.exit_code == 0
        with app.app_context():
            assert RM.query.get(recid2) is None
            assert RM.query.get(recid) is not None
Beispiel #16
0
 def run(args=None, config=None, **kwargs):
     app = make_app(config=config or {})
     obj = ScriptInfo(create_app=lambda info: app)
     return runner.invoke(cli, args or [], obj=obj, **kwargs)
Beispiel #17
0
def test_update_expired_embargo(app, test_communities, login_user, cli_cmd):
    """Test record embargo update."""

    uploaded_files = {'myfile1.dat': b'contents1', 'myfile2.dat': b'contents2'}
    with app.app_context():
        creator = create_user('creator')
        non_creator = create_user('non-creator')

        # create a record with a finishing embargo
        released_record_data = generate_record_data(
            open_access=False,
            embargo_date=datetime.utcnow().isoformat(),
        )
        _, _, released_record = create_record(released_record_data,
                                              creator,
                                              files=uploaded_files)
        released_record_id = released_record.id

        # create a record with anot finished embargo
        closed_record_data = generate_record_data(
            open_access=False,
            # embargo finishes tomorrow
            embargo_date=(datetime.utcnow() + timedelta(days=1)).isoformat(),
        )
        _, _, closed_record = create_record(closed_record_data,
                                            creator,
                                            files=uploaded_files)
        closed_record_id = closed_record.id

        db.session.commit()
        # refresh index to make records searchable
        current_search._client.indices.refresh()

    def check_embargo(record_id, is_embargoed):
        with app.app_context():
            with app.test_client() as client:
                login_user(non_creator, client)
                # test open_access field in record's metadata
                record = Record.get_record(record_id)
                assert record['open_access'] != is_embargoed
                # test record's file access
                subtest_file_bucket_permissions(
                    client,
                    record.files.bucket,
                    access_level=None if is_embargoed else 'read',
                    is_authenticated=True)

    # check that both records are under embargo
    check_embargo(released_record_id, is_embargoed=True)
    check_embargo(closed_record_id, is_embargoed=True)

    with app.app_context():
        if not cli_cmd:
            update_expired_embargoes.delay()
        else:
            script_info = ScriptInfo(create_app=lambda info: app)
            runner = CliRunner()
            result = runner.invoke(b2records, ['update_expired_embargoes'],
                                   obj=script_info)
            assert result.exit_code == 0

        # refresh index to make records searchable
        current_search._client.indices.refresh()

    # check that only the released record is not under embargo
    check_embargo(released_record_id, is_embargoed=False)
    check_embargo(closed_record_id, is_embargoed=True)
Beispiel #18
0
 def create_app(self):
     script_info = ScriptInfo(create_app=create_app)
     script_info.data['APP_SETTINGS'] = 'config.TestingConfig'
     return script_info.load_app()
def script_info(app):
    """CLI object."""
    with app.app_context():
        yield ScriptInfo(create_app=lambda info: app)
Beispiel #20
0
def test_find_best_app(test_apps):
    """Test if `find_best_app` behaves as expected with different combinations of input."""
    script_info = ScriptInfo()

    class Module:
        app = Flask('appname')

    assert find_best_app(script_info, Module) == Module.app

    class Module:
        application = Flask('appname')

    assert find_best_app(script_info, Module) == Module.application

    class Module:
        myapp = Flask('appname')

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        @staticmethod
        def create_app():
            return Flask('appname')

    assert isinstance(find_best_app(script_info, Module), Flask)
    assert find_best_app(script_info, Module).name == 'appname'

    class Module:
        @staticmethod
        def create_app(foo):
            return Flask('appname')

    assert isinstance(find_best_app(script_info, Module), Flask)
    assert find_best_app(script_info, Module).name == 'appname'

    class Module:
        @staticmethod
        def create_app(foo=None, script_info=None):
            return Flask('appname')

    assert isinstance(find_best_app(script_info, Module), Flask)
    assert find_best_app(script_info, Module).name == 'appname'

    class Module:
        @staticmethod
        def make_app():
            return Flask('appname')

    assert isinstance(find_best_app(script_info, Module), Flask)
    assert find_best_app(script_info, Module).name == 'appname'

    class Module:
        myapp = Flask('appname1')

        @staticmethod
        def create_app():
            return Flask('appname2')

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        myapp = Flask('appname1')

        @staticmethod
        def create_app():
            return Flask('appname2')

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        pass

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        myapp1 = Flask('appname1')
        myapp2 = Flask('appname2')

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app(foo, bar):
            return Flask('appname2')

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app():
            raise TypeError('bad bad factory!')

    pytest.raises(TypeError, find_best_app, script_info, Module)
"""Shortcut for flask interactive shell."""

# Example:
# >>> from eyetuner_flask.models import Fcuser
# >>> Fcuser
# <class 'eyetuner_flask.models.Fcuser'>
# >>> Fcuser.query.all()
# []

if __name__ == '__main__':
    import code
    import sys
    from flask.cli import ScriptInfo
    from eyetuner_flask.app import create_app
    globals().update(
        ScriptInfo(create_app=create_app).load_app().make_shell_context())
    app = globals().get('app')
    app.app_context().push()
    code.interact(banner="Python %s on %s\nApp: %s [%s]\nInstance: %s" %
                  (sys.version, sys.platform, app.import_name, app.env,
                   app.instance_path),
                  local=globals())
Beispiel #22
0
def script_info(app):
    """Get ScriptInfo object for testing CLI."""
    return ScriptInfo(create_app=lambda info: app)
Beispiel #23
0
def test_scriptinfo(test_apps, monkeypatch):
    """Test of ScriptInfo."""
    obj = ScriptInfo(app_import_path="cliapp.app:testapp")
    app = obj.load_app()
    assert app.name == "testapp"
    assert obj.load_app() is app

    # import app with module's absolute path
    cli_app_path = os.path.abspath(
        os.path.join(os.path.dirname(__file__), "test_apps", "cliapp",
                     "app.py"))
    obj = ScriptInfo(app_import_path=cli_app_path)
    app = obj.load_app()
    assert app.name == "testapp"
    assert obj.load_app() is app
    obj = ScriptInfo(app_import_path=f"{cli_app_path}:testapp")
    app = obj.load_app()
    assert app.name == "testapp"
    assert obj.load_app() is app

    def create_app():
        return Flask("createapp")

    obj = ScriptInfo(create_app=create_app)
    app = obj.load_app()
    assert app.name == "createapp"
    assert obj.load_app() is app

    obj = ScriptInfo()
    pytest.raises(NoAppException, obj.load_app)

    # import app from wsgi.py in current directory
    monkeypatch.chdir(
        os.path.abspath(
            os.path.join(os.path.dirname(__file__), "test_apps",
                         "helloworld")))
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == "hello"

    # import app from app.py in current directory
    monkeypatch.chdir(
        os.path.abspath(
            os.path.join(os.path.dirname(__file__), "test_apps", "cliapp")))
    obj = ScriptInfo()
    app = obj.load_app()
    assert app.name == "testapp"
Beispiel #24
0
def test_create_community2(app, test_communities):
    with app.app_context():
        runner = CliRunner()
        script_info = ScriptInfo(create_app=lambda info: app)
        result = runner.invoke(communities_cmd, ["create"], obj=script_info)
        assert result.exit_code != 0
Beispiel #25
0
def test_delete(tmpdir):
    flaskapp.root_path = str(tmpdir)
    obj = ScriptInfo(create_app=lambda info: flaskapp)
    result = runner.invoke(flask_command, ['delete'], obj=obj)
    assert result.exit_code == 1
def test_locate_app_raises(test_apps, iname, aname):
    info = ScriptInfo()

    with pytest.raises(NoAppException):
        locate_app(info, iname, aname)
Beispiel #27
0
 def __init__(self, *args, **kwargs):
     super(FlaskJob, self).__init__(*args, **kwargs)
     self.script_info = ScriptInfo()
def test_find_best_app(test_apps):
    script_info = ScriptInfo()

    class Module:
        app = Flask("appname")

    assert find_best_app(script_info, Module) == Module.app

    class Module:
        application = Flask("appname")

    assert find_best_app(script_info, Module) == Module.application

    class Module:
        myapp = Flask("appname")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        @staticmethod
        def create_app():
            return Flask("appname")

    app = find_best_app(script_info, Module)
    assert isinstance(app, Flask)
    assert app.name == "appname"

    class Module:
        @staticmethod
        def create_app(foo):
            return Flask("appname")

    with pytest.deprecated_call(match="Script info"):
        app = find_best_app(script_info, Module)

    assert isinstance(app, Flask)
    assert app.name == "appname"

    class Module:
        @staticmethod
        def create_app(foo=None, script_info=None):
            return Flask("appname")

    with pytest.deprecated_call(match="script_info"):
        app = find_best_app(script_info, Module)

    assert isinstance(app, Flask)
    assert app.name == "appname"

    class Module:
        @staticmethod
        def make_app():
            return Flask("appname")

    app = find_best_app(script_info, Module)
    assert isinstance(app, Flask)
    assert app.name == "appname"

    class Module:
        myapp = Flask("appname1")

        @staticmethod
        def create_app():
            return Flask("appname2")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        myapp = Flask("appname1")

        @staticmethod
        def create_app():
            return Flask("appname2")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        pass

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        myapp1 = Flask("appname1")
        myapp2 = Flask("appname2")

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app(foo, bar):
            return Flask("appname2")

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app():
            raise TypeError("bad bad factory!")

    pytest.raises(TypeError, find_best_app, script_info, Module)
Beispiel #29
0
def test_locate_app(test_apps, iname, aname, result):
    info = ScriptInfo()
    info.data['test'] = 'spam'
    assert locate_app(info, iname, aname).name == result
def script(app):
    return ScriptInfo(create_app=lambda info: app)
Beispiel #31
0
def test_pid_creation(app, db):
    """Test pid creation."""
    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    with runner.isolated_filesystem():
        with app.app_context():
            assert PersistentIdentifier.query.count() == 0

        result = runner.invoke(cmd, ['create', 'doi', '10.1234/foo'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            assert PersistentIdentifier.query.count() == 1
            pid = PersistentIdentifier.get('doi', '10.1234/foo')
            assert pid.pid_type == 'doi'
            assert pid.pid_value == '10.1234/foo'
            assert pid.pid_provider is None
            assert pid.status == PIDStatus.NEW
            assert pid.object_type is None
            assert pid.object_uuid is None

        rec_uuid = uuid.uuid4()

        # Bad parameter status:
        result = runner.invoke(cmd, [
            'create',
            'recid',
            '2',
            '--status',
            'BADPARAMETER',
            '--type',
            'rec',
            '--uuid',
            str(rec_uuid),
        ],
                               obj=script_info)
        assert 2 == result.exit_code

        # Any or both type and uuid must be defined:
        result = runner.invoke(cmd, [
            'create',
            'recid',
            '2',
            '--type',
            'rec',
        ],
                               obj=script_info)
        assert 2 == result.exit_code

        result = runner.invoke(cmd, [
            'create',
            'recid',
            '2',
            '--uuid',
            str(rec_uuid),
        ],
                               obj=script_info)
        assert 2 == result.exit_code

        # Everything should be fine now:
        result = runner.invoke(cmd, [
            'create',
            'recid',
            '2',
            '--status',
            'REGISTERED',
            '--type',
            'rec',
            '--uuid',
            str(rec_uuid),
        ],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            assert PersistentIdentifier.query.count() == 2
            pid = PersistentIdentifier.get('recid', '2')
            assert pid.pid_type == 'recid'
            assert pid.pid_value == '2'
            assert pid.pid_provider is None
            assert pid.status == PIDStatus.REGISTERED
            assert pid.object_type == 'rec'
            assert pid.object_uuid == rec_uuid

        # Can't duplicate existing persistent identifier
        result = runner.invoke(cmd, [
            'create',
            'recid',
            '2',
        ],
                               obj=script_info)
        assert -1 == result.exit_code
Beispiel #32
0
def test_cli(app):
    """Test CLI."""
    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    # Test collection creation.
    with runner.isolated_filesystem():
        result = runner.invoke(cmd, ['create', 'Root'], obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            root = Collection.query.filter_by(name='Root').one()
            assert 1 == root.id
            assert root.dbquery is None

        result = runner.invoke(cmd, ['create', 'Root'], obj=script_info)
        assert 0 != result.exit_code

        result = runner.invoke(cmd, ['create', 'CollCycle', '-p', 'CollCycle'],
                               obj=script_info)
        assert 0 != result.exit_code

        result = runner.invoke(cmd, ['create', 'Coll', '-p', 'not-exist'],
                               obj=script_info)
        assert 0 != result.exit_code

        result = runner.invoke(cmd, ['create', 'verbose', '-v'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            first = Collection.query.filter_by(name='verbose').one()

        result = runner.invoke(cmd, ['create', 'First', '--parent', 'Root'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            first = Collection.query.filter_by(name='First').one()
            assert root.id == first.parent_id

        result = runner.invoke(cmd, ['create', 'Second'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            second = Collection.query.filter_by(name='Second').one()
            assert second.parent_id is None

        result = runner.invoke(cmd, ['create', 'Third', '-q', 'title:Fuu',
                                     '--parent', 'Root'], obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            third = Collection.query.filter_by(name='Third').one()
            assert root.id == third.parent_id
            assert 'title:Fuu' == third.dbquery

        result = runner.invoke(cmd, ['attach', 'Second'],
                               obj=script_info)
        assert 0 != result.exit_code

        result = runner.invoke(cmd, ['attach', 'Second', 'Root'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            second = Collection.query.filter_by(name='Second').one()
            assert root.id == second.parent_id
            assert root.id == second.tree_id

        result = runner.invoke(cmd, ['attach', 'verbose', 'Root', '-v'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            verbose = Collection.query.filter_by(name='verbose').one()
            assert root.id == verbose.parent_id
            assert root.id == verbose.tree_id

        result = runner.invoke(cmd, ['attach', 'Third', 'Second', '-n'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            third = Collection.query.filter_by(name='Third').one()
            assert root.id == third.parent_id
            assert root.id == third.tree_id

        result = runner.invoke(cmd, ['attach', 'Third', 'Second'],
                               obj=script_info)
        assert 0 == result.exit_code

        with app.app_context():
            second = Collection.query.filter_by(name='Second').one()
            third = Collection.query.filter_by(name='Third').one()
            assert second.id == third.parent_id
            assert root.id == third.tree_id

        result = runner.invoke(cmd, ['attach', 'Third', 'not-exist'],
                               obj=script_info)
        assert 0 != result.exit_code
Beispiel #33
0
def test_locate_app(test_apps, iname, aname, result):
    info = ScriptInfo()
    info.data['test'] = 'spam'
    assert locate_app(info, iname, aname).name == result
Beispiel #34
0
def script_info(app):
    """Ensure that the database schema is created."""
    return ScriptInfo(create_app=lambda info: app)
Beispiel #35
0
def test_simple_workflow(app, db, tmpdir):
    """Run simple workflow."""
    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    source = os.path.join(os.path.dirname(__file__), 'fixtures', 'source')

    # Create a location to use
    result = runner.invoke(
        cmd,
        ['location', 'create', 'tmp', 'file://' + tmpdir.strpath, '--default'],
        obj=script_info)
    assert 0 == result.exit_code

    # Create the same location (check idempotent)
    result = runner.invoke(
        cmd,
        ['location', 'create', 'tmp', 'file://' + tmpdir.strpath, '--default'],
        obj=script_info)
    assert 0 == result.exit_code
    assert "already exists" in result.output

    # Passing no subcommand should use default command 'create' (idempotent)
    result = runner.invoke(
        cmd, ['location', 'tmp', 'file://' + tmpdir.strpath, '--default'],
        obj=script_info)
    assert 0 == result.exit_code
    assert "already exists" in result.output

    # Create a second one as default to check tmp is not default anymore
    result = runner.invoke(
        cmd,
        ['location', 'create', 'aux', 'file://' + tmpdir.strpath, '--default'],
        obj=script_info)
    assert 0 == result.exit_code

    # List locations and check the default is correct
    result = runner.invoke(cmd, ['location', 'list'], obj=script_info)
    assert 0 == result.exit_code

    created_locations = result.output.split('\n')

    # tmp is not default
    assert "tmp" in created_locations[0]
    assert "as default False" in created_locations[0]
    # aux is default
    assert "aux" in created_locations[1]
    assert "as default True" in created_locations[1]

    # Set tmp back as default
    result = runner.invoke(cmd, ['location', 'set-default', 'tmp'],
                           obj=script_info)
    assert 0 == result.exit_code

    # List locations and check the default is correct
    result = runner.invoke(cmd, ['location', 'list'], obj=script_info)
    assert 0 == result.exit_code

    created_locations = result.output.split('\n')
    # tmp is default
    assert "tmp" in created_locations[0]
    assert "as default True" in created_locations[0]
    # aux is not default
    assert "aux" in created_locations[1]
    assert "as default False" in created_locations[1]

    ##
    # Buckets
    ##

    result = runner.invoke(cmd, ['bucket', 'touch'], obj=script_info)
    assert 0 == result.exit_code
    bucket_id = result.output.split('\n')[0]

    # Specify a directory where 2 files have same content.
    result = runner.invoke(cmd,
                           ['bucket', 'cp', source, bucket_id, '--checksum'],
                           obj=script_info)
    assert 0 == result.exit_code

    assert len(tmpdir.listdir()) == 2

    # Specify a file.
    result = runner.invoke(cmd, ['bucket', 'cp', __file__, bucket_id],
                           obj=script_info)
    assert 0 == result.exit_code

    assert len(tmpdir.listdir()) == 3

    # No new file should be created.
    result = runner.invoke(cmd,
                           ['bucket', 'cp', __file__, bucket_id, '--checksum'],
                           obj=script_info)
    assert 0 == result.exit_code

    assert len(tmpdir.listdir()) == 3
Beispiel #36
0
def script_info(app):
    """Get ScriptInfo object for testing CLI."""
    InvenioAssets(app)
    yield ScriptInfo(create_app=lambda info: app)
Beispiel #37
0
def test_delete(app):
    """Test CLI delete."""
    runner = CliRunner()
    script_info = ScriptInfo(create_app=lambda info: app)

    #                               a
    #                             (None)
    #            +------------------+--------------------+
    #            |                                       |
    #            b                                       e
    #         (None)                        (title:Test2 OR title:Test3)
    #     +------+-----+                    +------------+------------+
    #     |            |                    |            |            |
    #     c            d                    f            g            h
    # (title:Test0) (title:Test1)     (title:Test2)    (None)       (None)
    #                                                    |            |
    #                                                    i            j
    #                                             (title:Test3) (title:Test4)

    with runner.isolated_filesystem():
        with app.app_context():
            a = Collection(name="a")
            b = Collection(name="b", parent=a)
            e = Collection(
                name="e", dbquery="title:Test2 OR title:Test3", parent=a)
            c = Collection(name="c", dbquery="title:Test0", parent=b)
            d = Collection(name="d", dbquery="title:Test1", parent=b)
            f = Collection(name="f", dbquery="title:Test2", parent=e)
            g = Collection(name="g", parent=e)
            h = Collection(name="h", parent=e)
            i = Collection(name="i", dbquery="title:Test3", parent=g)
            j = Collection(name="j", dbquery="title:Test4", parent=h)

            for c in [a, b, c, d, e, f, g, h, i, j]:
                db.session.add(c)
            db.session.commit()

            result = runner.invoke(cmd, ['delete'], obj=script_info)
            assert 0 != result.exit_code

            result = runner.invoke(cmd, ['delete', 'not-exist'],
                                   obj=script_info)
            assert 0 != result.exit_code

        with app.app_context():
            result = runner.invoke(cmd, ['delete', 'a', '-n'], obj=script_info)
            assert 0 == result.exit_code
            for coll in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']:
                assert Collection.query.filter_by(
                    name=coll).first() is not None
            db.session.expunge_all()

            result = runner.invoke(cmd, ['delete', 'j'], obj=script_info)
            assert 0 == result.exit_code

            db.session.expunge_all()
            for coll in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']:
                assert Collection.query.filter_by(
                    name=coll).first() is not None
            assert Collection.query.filter_by(name='j').first() is None

            result = runner.invoke(cmd, ['delete', 'e'], obj=script_info)
            assert 0 == result.exit_code
            for coll in ['a', 'b', 'c', 'd']:
                assert Collection.query.filter_by(
                    name=coll).first() is not None
            for coll in ['e', 'f', 'g', 'h', 'i', 'j']:
                assert Collection.query.filter_by(name=coll).first() is None

            result = runner.invoke(cmd, ['delete', 'c', '-v'], obj=script_info)
            assert 0 == result.exit_code
            assert Collection.query.filter_by(name='c').first() is None