def test_alembic_and_db_create_match(clean_app):
"""Check that alembic recipes and alembic models are in sync."""
with clean_app.app_context():
ext = clean_app.extensions['invenio-db']
if db.engine.name == 'sqlite':
raise pytest.skip('Upgrades are not supported on SQLite.')
# Make sure that alembic upgrades can be run now
ext.alembic.upgrade()
constraints = get_all_constraints(clean_app)
alembic_constraint_names = [x[0] for x in constraints]
# Recreate the database with alembic only (without migrating)
db.session.remove()
drop_database(db.engine.url)
db.engine.dispose()
create_database(db.engine.url)
db.create_all()
# Check that the resulting state is in sync with alembic metaData
assert not ext.alembic.compare_metadata()
# Check that the constraints are the same. This is needed because
# alembic.compare_metadata does not check all constraints.
constraints = get_all_constraints(clean_app)
db_create_constraint_names = [x[0] for x in constraints]
assert set(alembic_constraint_names) == set(db_create_constraint_names)
def app(request):
"""Flask application fixture."""
app = create_app(
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
DEBUG_TB_ENABLED=False,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME",
MAIL_SUPPRESS_SEND=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
TESTING=True,
)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
list(current_search.create())
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
list(current_search.delete(ignore=[404]))
request.addfinalizer(teardown)
return app
def gen_app(config):
"""Generate a fresh app."""
app = Flask('testapp')
app.testing = True
app.config.update(**config)
FlaskCLI(app)
FlaskMenu(app)
Babel(app)
Mail(app)
InvenioDB(app)
InvenioAccounts(app)
FlaskOAuth(app)
InvenioOAuthClient(app)
app.register_blueprint(blueprint_client)
app.register_blueprint(blueprint_settings)
with app.app_context():
db.create_all()
app.test_request_context().push()
datastore = app.extensions['invenio-accounts'].datastore
datastore.create_user(
email="*****@*****.**", password='******', active=True)
datastore.create_user(
email="*****@*****.**", password='******', active=True)
datastore.create_user(
email="*****@*****.**", password='******', active=True)
datastore.commit()
return app
def test_db(request):
"""Test database backend."""
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite://'
)
FlaskCLI(app)
InvenioDB(app)
FlaskOAuth(app)
InvenioOAuthClient(app)
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
with app.app_context():
if str(db.engine.url) != 'sqlite://' and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
tables = list(filter(lambda table: table.startswith('oauthclient'),
db.metadata.tables.keys()))
assert len(tables) == 3
def app(request):
"""Flask application fixture."""
app = Flask("testapp")
app.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI=os.getenv("SQLALCHEMY_DATABASE_URI", "sqlite://"),
SEARCH_AUTOINDEX=[],
SERVER_NAME="localhost",
)
Babel(app)
Menu(app)
Breadcrumbs(app)
FlaskCLI(app)
InvenioDB(app)
InvenioCollections(app)
InvenioRecords(app)
app.register_blueprint(blueprint)
def teardown():
with app.app_context():
db.drop_all()
current_collections.unregister_signals()
request.addfinalizer(teardown)
with app.app_context():
db.create_all()
return app
def records_app(request):
"""Initialize InvenioRecords."""
app = Flask('records_testapp')
FlaskCLI(app)
app.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'
),
)
InvenioDB(app)
from invenio_records import InvenioRecords
from invenio_db import db
InvenioRecords(app)
InvenioSearch(app)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def script_info(request):
"""Get ScriptInfo object for testing CLI."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
ACCOUNTS_USE_CELERY=False,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI='sqlite://', # in memory db
TESTING=True,
)
FlaskCLI(app)
Babel(app)
Mail(app)
InvenioDB(app)
InvenioAccounts(app)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return ScriptInfo(create_app=lambda info: app)
def app(request):
"""Flask application fixture."""
# Set temporary instance path for sqlite
instance_path = tempfile.mkdtemp()
app = Flask("testapp", instance_path=instance_path)
InvenioDB(app)
InvenioPIDStore(app)
app.config.update(
SQLALCHEMY_DATABASE_URI=os.environ.get("SQLALCHEMY_DATABASE_URI", "sqlite:///test.db"), TESTING=True
)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def es_app(request):
"""Flask application with records fixture."""
app = Flask(__name__)
app.config.update(
JSONSCHEMAS_ENDPOINT='/',
JSONSCHEMAS_HOST='http://localhost:5000',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
)
Babel(app)
if not hasattr(app, 'cli'):
from flask_cli import FlaskCLI
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
InvenioMARC21(app)
search = InvenioSearch(app)
InvenioIndexer(app)
InvenioJSONSchemas(app)
with app.app_context():
db.create_all()
list(search.create())
sleep(10)
def teardown():
with app.app_context():
db.drop_all()
list(search.delete())
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
app = create_app()
app.config.update({"DEBUG": True})
with app.app_context():
# Imports must be local, otherwise tasks default to pickle serializer.
from inspirehep.modules.migrator.tasks import add_citation_counts, migrate
from inspirehep.modules.fixtures.files import init_all_storage_paths
from inspirehep.modules.fixtures.users import init_users_and_permissions
db.drop_all()
db.create_all()
sleep(10) # Makes sure that ES is up.
_es = app.extensions["invenio-search"]
list(_es.delete(ignore=[404]))
list(_es.create(ignore=[400]))
init_all_storage_paths()
init_users_and_permissions()
migrate("./inspirehep/demosite/data/demo-records.xml.gz", wait_for_results=True)
es.indices.refresh("records-hep") # Makes sure that all HEP records were migrated.
add_citation_counts()
es.indices.refresh("records-hep") # Makes sure that all citation counts were added.
yield app
def es_app(request):
"""Flask application with records fixture."""
app = Flask(__name__)
app.config.update(
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
)
Babel(app)
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
InvenioMARC21(app)
sleep(10)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask(__name__, instance_path=instance_path)
app.config.update(
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
TESTING=True,
)
FlaskCLI(app)
FlaskCeleryExt(app)
InvenioDB(app)
InvenioRecords(app)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
app = Flask("testapp")
app.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI=os.environ.get("SQLALCHEMY_DATABASE_URI", "sqlite://"),
CELERY_ALWAYS_EAGER=True,
CELERY_RESULT_BACKEND="cache",
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
RECORDS_UI_DEFAULT_PERMISSION_FACTORY=None, # No permission checking
)
FlaskCeleryExt(app)
FlaskCLI(app)
Babel(app)
InvenioDB(app)
InvenioPIDStore(app)
InvenioRecords(app)
with app.app_context():
db.create_all()
def finalize():
with app.app_context():
db.drop_all()
request.addfinalizer(finalize)
return app
def app(request):
"""Flask application fixture."""
app = create_app()
def teardown():
with app.app_context():
db.drop_all()
sleep(10) # Makes sure that ES is up.
_es = app.extensions['invenio-search']
list(_es.delete(ignore=[404]))
request.addfinalizer(teardown)
with app.app_context():
# Imports must be local, otherwise tasks default to pickle serializer.
from inspirehep.modules.migrator.tasks import add_citation_counts, migrate
db.drop_all()
db.create_all()
sleep(10) # Makes sure that ES is up.
_es = app.extensions['invenio-search']
list(_es.delete(ignore=[404]))
list(_es.create(ignore=[400]))
migrate('./inspirehep/demosite/data/demo-records.xml.gz', wait_for_results=True)
es.indices.refresh('records-hep') # Makes sure that all HEP records were migrated.
add_citation_counts(request_timeout=40)
es.indices.refresh('records-hep') # Makes sure that all citation counts were added.
yield app
def base_app():
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
base_app = Flask(__name__, instance_path=instance_path)
base_app.config.update(
ACCOUNTS_USE_CELERY=False,
LOGIN_DISABLED=False,
SECRET_KEY='testing_key',
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite://'),
TEST_USER_EMAIL='*****@*****.**',
TEST_USER_PASSWORD='******',
TESTING=True,
WTF_CSRF_ENABLED=False,
)
Babel(base_app)
Mail(base_app)
Menu(base_app)
InvenioDB(base_app)
InvenioAccounts(base_app)
base_app.register_blueprint(accounts_blueprint)
with base_app.app_context():
if str(db.engine.url) != "sqlite://" and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
def teardown():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
return base_app
def small_app():
"""Flask application fixture."""
app = create_app()
app.config.update({'DEBUG': True})
with app.app_context():
# Imports must be local, otherwise tasks default to pickle serializer.
from inspirehep.modules.migrator.tasks.records import migrate
from inspirehep.modules.fixtures.collections import init_collections
from inspirehep.modules.fixtures.files import init_all_storage_paths
from inspirehep.modules.fixtures.users import init_users_and_permissions
db.drop_all()
db.create_all()
sleep(10)
_es = app.extensions['invenio-search']
list(_es.delete(ignore=[404]))
list(_es.create(ignore=[400]))
init_all_storage_paths()
init_users_and_permissions()
init_collections()
migrate('./inspirehep/demosite/data/demo-records-small.xml', wait_for_results=True)
es.indices.refresh('records-hep')
yield app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
Babel(app)
FlaskCLI(app)
InvenioDB(app)
LoginManager(app)
app.admin_app = InvenioAdmin(app)
protected_view = protected_adminview_factory(TestModelView)
app.admin_app.admin.add_view(protected_view(TestModel, db.session))
app.config.update(
TESTING=True,
SECRET_KEY="SECRET_KEY",
)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
LOGIN_DISABLED=False,
MAIL_SUPPRESS_SEND=True,
SECRET_KEY='changeme',
SERVER_NAME='example.com',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite://'),
TESTING=True,
WTF_CSRF_ENABLED=False,
)
Babel(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioAccounts(app)
InvenioGroups(app)
with app.app_context():
if str(db.engine.url) != 'sqlite://' and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
if str(db.engine.url) != 'sqlite://':
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
TESTING=True,
SERVER_NAME='localhost:5000',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'
)
)
FlaskCLI(app)
InvenioDB(app)
InvenioREST(app)
InvenioRecords(app)
InvenioPIDStore(app)
InvenioRecordsREST(app)
with app.app_context():
if not database_exists(str(db.engine.url)) and \
app.config['SQLALCHEMY_DATABASE_URI'] != 'sqlite://':
create_database(db.engine.url)
db.drop_all()
db.create_all()
def finalize():
with app.app_context():
db.drop_all()
if app.config['SQLALCHEMY_DATABASE_URI'] != 'sqlite://':
drop_database(db.engine.url)
shutil.rmtree(instance_path)
request.addfinalizer(finalize)
return app
def app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
ACCOUNTS_USE_CELERY=False,
SECRET_KEY='CHANGE_ME',
SECURITY_PASSWORD_SALT='CHANGE_ME_ALSO',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
TESTING=True,
)
Babel(app)
Mail(app)
InvenioDB(app)
InvenioAccounts(app)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
BROKER_URL=os.environ.get('BROKER_URL', 'memory://'),
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
SQLALCHEMY_TRACK_MODIFICATIONS=False,
TESTING=True,
)
FlaskCLI(app)
FlaskCeleryExt(app)
InvenioDB(app)
InvenioRecords(app)
InvenioSearch(app)
InvenioIndexer(app)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
TESTING=True,
SERVER_NAME='localhost:5000',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'
)
)
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
with app.app_context():
if app.config['SQLALCHEMY_DATABASE_URI'] != 'sqlite://':
create_database(db.engine.url)
db.create_all()
def finalize():
with app.app_context():
db.drop_all()
if app.config['SQLALCHEMY_DATABASE_URI'] != 'sqlite://':
drop_database(db.engine.url)
request.addfinalizer(finalize)
return app
def app(request):
"""Flask application fixture.
Creates a Flask application with a simple testing configuration,
then creates an application context and inside of it recreates
all databases and indices from the fixtures. Finally it yields,
so that all tests that explicitly use the ``app`` fixture have
access to an application context.
See: http://flask.pocoo.org/docs/0.12/appcontext/.
"""
app = create_app()
app.config.update({'DEBUG': True})
with app.app_context():
# Celery task imports must be local, otherwise their
# configuration would use the default pickle serializer.
from inspirehep.modules.migrator.tasks import migrate
db.drop_all()
db.create_all()
_es = app.extensions['invenio-search']
list(_es.delete(ignore=[404]))
list(_es.create(ignore=[400]))
init_all_storage_paths()
init_users_and_permissions()
init_collections()
migrate('./inspirehep/demosite/data/demo-records-acceptance.xml.gz', wait_for_results=True)
es.indices.refresh('records-hep')
yield app
def app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
ACCOUNTS_USE_CELERY=False,
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
MAIL_SUPPRESS_SEND=True,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite://'),
TESTING=True,
LOGIN_DISABLED=False,
WTF_CSRF_ENABLED=False,
SERVER_NAME='example.com',
)
FlaskCLI(app)
Menu(app)
Babel(app)
Mail(app)
InvenioDB(app)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite://'),
SERVER_NAME='localhost',
)
Babel(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioCollections(app)
InvenioRecords(app)
app.register_blueprint(blueprint)
with app.app_context():
if str(db.engine.url) != 'sqlite://' and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
if str(db.engine.url) != 'sqlite://':
drop_database(str(db.engine.url))
request.addfinalizer(teardown)
with app.app_context():
db.create_all()
return app
def script_info(request):
"""Get ScriptInfo object for testing CLI."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
ACCOUNTS_USE_CELERY=False,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
TESTING=True,
)
FlaskCLI(app)
Babel(app)
Mail(app)
InvenioDB(app)
InvenioAccounts(app)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return ScriptInfo(create_app=lambda info: app)
def db(app):
"""Database fixture."""
if not database_exists(str(db_.engine.url)):
create_database(str(db_.engine.url))
db_.create_all()
yield db_
db_.session.remove()
db_.drop_all()
def test_db():
"""Test database backend."""
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'
)
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
with app.app_context():
create_database(db.engine.url)
db.create_all()
assert len(db.metadata.tables) == 3
data = {'title': 'Test'}
from invenio_records.models import RecordMetadata as RM
# Create a record
with app.app_context():
assert RM.query.count() == 0
record_uuid = Record.create(data).id
db.session.commit()
assert RM.query.count() == 1
db.session.commit()
# Retrieve created record
with app.app_context():
record = Record.get_record(record_uuid)
assert record.dumps() == data
with pytest.raises(NoResultFound):
Record.get_record(uuid.uuid4())
record['field'] = True
record = record.patch([
{'op': 'add', 'path': '/hello', 'value': ['world']}
])
assert record['hello'] == ['world']
record.commit()
db.session.commit()
with app.app_context():
record2 = Record.get_record(record_uuid)
assert record2.model.version_id == 2
assert record2['field']
assert record2['hello'] == ['world']
db.session.commit()
# Cannot commit record without model (i.e. Record.create_record)
with app.app_context():
record3 = Record({'title': 'Not possible'})
with pytest.raises(RecordNotCommitableError):
record3.commit()
with app.app_context():
db.drop_all()
drop_database(db.engine.url)
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
TESTING=True,
SECRET_KEY='SECRET_KEY',
ADMIN_LOGIN_ENDPOINT='login',
SQLALCHEMY_TRACK_MODIFICATIONS=True,
)
Babel(app)
InvenioDB(app)
Principal(app)
LoginManager(app)
# Install login and access loading.
@app.login_manager.user_loader
def load_user(user_id):
return TestUser.get(user_id)
@app.route('/login/')
def login():
from flask import current_app
from flask import request as flask_request
user = TestUser.get(flask_request.args.get('user', 1))
login_user(user)
identity_changed.send(
current_app._get_current_object(),
identity=Identity(user.id))
return "Logged In"
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
identity.user = current_user
identity.provides.add(UserNeed(current_user.id))
if current_user.id == 1:
identity.provides.add(action_admin_access)
# Register admin view
InvenioAdmin(
app, permission_factory=lambda x: Permission(action_admin_access))
app.extensions['invenio-admin'].register_view(TestModelView, TestModel)
# Create database
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def db(app):
"""Ensure that the database schema is created."""
if not database_exists(str(db_.engine.url)):
create_database(str(db_.engine.url))
db_.create_all()
yield db_
db_.session.remove()
db_.drop_all()
def _database_setup(app, request):
"""Set up the database."""
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
if database_exists(str(db.engine.url)):
drop_database(str(db.engine.url))
# Delete sessions in kvsession store
if hasattr(app, 'kvsession_store') and \
isinstance(app.kvsession_store, RedisStore):
app.kvsession_store.redis.flushall()
shutil.rmtree(app.instance_path)
request.addfinalizer(teardown)
return app
def db(app):
"""Create database for the tests."""
dir_path = os.path.dirname(__file__)
parent_path = str(Path(dir_path).parent)
db_path = os.environ.get('SQLALCHEMY_DATABASE_URI',
f'sqlite:////{parent_path}/database.db')
os.environ["INVENIO_SQLALCHEMY_DATABASE_URI"] = db_path
app.config.update(SQLALCHEMY_DATABASE_URI=db_path)
if database_exists(str(db_.engine.url)):
drop_database(db_.engine.url)
if not database_exists(str(db_.engine.url)):
create_database(db_.engine.url)
db_.create_all()
subprocess.run(["invenio", "taxonomies", "init"])
yield db_
# Explicitly close DB connection
db_.session.close()
db_.drop_all()
def database(appctx):
"""Setup database.
Scope: module
Normally, tests should use the function-scoped :py:data:`db` fixture
instead. This fixture takes care of creating the database/tables and
removing the tables once tests are done.
"""
from invenio_db import db as db_
from sqlalchemy_utils.functions import create_database, database_exists
if not database_exists(str(db_.engine.url)):
create_database(str(db_.engine.url))
db_.create_all()
yield db_
db_.session.remove()
db_.drop_all()
def app(request):
"""Basic Flask application."""
instance_path = tempfile.mkdtemp()
app = create_rdm_app()
DB = os.getenv("SQLALCHEMY_DATABASE_URI", "sqlite://")
app.config.update(
I18N_LANGUAGES=[("en", "English"), ("de", "German")],
SQLALCHEMY_DATABASE_URI=DB,
SQLALCHEMY_TRACK_MODIFICATIONS=False,
DATADIR="data",
)
RepositoryCli(app)
app.config[
"RECORDS_REFRESOLVER_CLS"
] = "invenio_records.resolver.InvenioRefResolver"
app.config[
"RECORDS_REFRESOLVER_STORE"
] = "invenio_jsonschemas.proxies.current_refresolver_store"
# Variable not used. We set it to silent warnings
app.config["JSONSCHEMAS_HOST"] = "not-used"
with app.app_context():
db_url = str(db.engine.url)
if db_url != "sqlite://" and not database_exists(db_url):
create_database(db_url)
db.create_all()
def teardown():
with app.app_context():
db_url = str(db.engine.url)
db.session.close()
if db_url != "sqlite://":
drop_database(db_url)
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
app.test_request_context().push()
return app
def app(request):
"""Flask application fixture for E2E/integration/selenium tests.
Overrides the `app` fixture found in `../conftest.py`. Tests/files in this
folder and subfolders will see this variant of the `app` fixture.
"""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
ACCOUNTS_USE_CELERY=False,
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
MAIL_SUPPRESS_SEND=True,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
TESTING=True,
LOGIN_DISABLED=False,
)
FlaskCLI(app)
Menu(app)
Babel(app)
Mail(app)
InvenioDB(app)
InvenioAccounts(app)
app.register_blueprint(blueprint)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
ACCOUNTS_USE_CELERY=False,
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
MAIL_SUPPRESS_SEND=True,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
TESTING=True,
LOGIN_DISABLED=False,
WTF_CSRF_ENABLED=False,
SERVER_NAME='example.com',
)
FlaskCLI(app)
Menu(app)
Babel(app)
Mail(app)
InvenioDB(app)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
# Delete sessions in kvsession store
if hasattr(app, 'kvsession_store'):
for key in app.kvsession_store.iter_keys():
app.kvsession_store.delete(key)
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def base_app(request):
"""Basic Flask application."""
instance_path = tempfile.mkdtemp()
app = Flask("testapp")
app.config.update(
MADMP_HOST_URL="https://test.invenio.cern.ch",
MADMP_HOST_TITLE="Invenio",
MADMP_FALLBACK_RECORD_CONVERTER=RDMRecordConverter(),
SQLALCHEMY_DATABASE_URI=os.getenv("SQLALCHEMY_DATABASE_URI",
"sqlite://"),
SQLALCHEMY_TRACK_MODIFICATIONS=False,
)
Babel(app)
InvenioConfigDefault(app)
InvenioDB(app)
InvenioRecords(app)
InvenioPIDStore(app)
InvenioPIDRelations(app)
InvenioAccounts(app)
InvenioAccess(app)
InvenioIndexer(app)
InvenioSearch(app)
InvenioMaDMP(app)
with app.app_context():
db_url = str(db.engine.url)
if db_url != "sqlite://" and not database_exists(db_url):
create_database(db_url)
db.create_all()
def teardown():
with app.app_context():
db_url = str(db.engine.url)
db.session.close()
if db_url != "sqlite://":
drop_database(db_url)
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
app.test_request_context().push()
return app
def app():
"""Flask application fixture."""
app = create_app(
DEBUG=True,
WTF_CSRF_ENABLED=False,
CELERY_ALWAYS_EAGER=True,
CELERY_RESULT_BACKEND='cache',
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
SECRET_KEY='secret!',
TESTING=True,
)
with app.app_context():
# Imports must be local, otherwise tasks default to pickle serializer.
from inspirehep.modules.migrator.tasks import add_citation_counts, migrate
from inspirehep.modules.fixtures.collections import init_collections
from inspirehep.modules.fixtures.files import init_all_storage_paths
from inspirehep.modules.fixtures.users import init_users_and_permissions
db.drop_all()
db.create_all()
_es = app.extensions['invenio-search']
list(_es.delete(ignore=[404]))
list(_es.create(ignore=[400]))
init_all_storage_paths()
init_users_and_permissions()
init_collections()
migrate('./inspirehep/demosite/data/demo-records.xml.gz',
wait_for_results=True)
es.indices.refresh(
'records-hep') # Makes sure that all HEP records were migrated.
add_citation_counts()
es.indices.refresh(
'records-hep') # Makes sure that all citation counts were added.
yield app
def app(request):
"""Flask app fixture."""
app = create_app()
app.config.update(
dict(TESTING=True,
TEST_RUNNER="celery.contrib.test_runner.CeleryTestSuiteRunner",
CELERY_ALWAYS_EAGER=True,
CELERY_RESULT_BACKEND="cache",
CELERY_CACHE_BACKEND="memory",
MAIL_SUPPRESS_SEND=True,
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'postgresql+psycopg2://hepdata:hepdata@localhost/hepdata_test'
)))
with app.app_context():
db.drop_all()
db.create_all()
reindex_all(recreate=True)
ctx = app.test_request_context()
ctx.push()
user_count = User.query.filter_by(email='*****@*****.**').count()
if user_count == 0:
user = User(email=TEST_EMAIL, password='******', active=True)
admin_role = Role(name='admin')
coordinator_role = Role(name='coordinator')
user.roles.append(admin_role)
user.roles.append(coordinator_role)
db.session.add(admin_role)
db.session.add(coordinator_role)
db.session.add(user)
db.session.commit()
yield app
ctx.pop()
def app(request):
"""
Flask application fixture.
:param request: Request.
:return: App object.
"""
instance_path = tempfile.mkdtemp()
app = Flask('weko_groups_app', instance_path=instance_path)
app.config.update(
LOGIN_DISABLED=False,
MAIL_SUPPRESS_SEND=True,
SECRET_KEY='1qertgyujk345678ijk',
SQLALCHEMY_DATABASE_URI='sqlite:///weko_groups.db',
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
WTF_CSRF_ENABLED=False,
)
Babel(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioAccounts(app)
WekoGroups(app)
with app.app_context():
if str(db.engine.url) != 'sqlite://' and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
if str(db.engine.url) != 'sqlite://':
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def test_db(request):
"""Test database backend."""
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite://')
FlaskCLI(app)
InvenioDB(app)
FlaskOAuth(app)
InvenioOAuthClient(app)
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
with app.app_context():
db.create_all()
tables = list(
filter(lambda table: table.startswith('oauthclient'),
db.metadata.tables.keys()))
assert len(tables) == 3
def app(licenses_example):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
JSONSCHEMAS_HOST='localhost',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite://'),
TESTING=True,
RECORDS_REST_DEFAULT_READ_PERMISSION_FACTORY=None,
CELERY_ALWAYS_EAGER=True,
CELERY_RESULT_BACKEND="cache",
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
)
app.url_map.converters['pid'] = PIDConverter
FlaskCeleryExt(app)
InvenioDB(app)
InvenioJSONSchemas(app)
InvenioRecords(app)
InvenioPIDStore(app)
InvenioOpenDefinition(app)
with app.app_context():
if str(db.engine.url) != "sqlite://" and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
def teardown():
drop_database(str(db.engine.url))
yield app
shutil.rmtree(instance_path)
def test_init():
"""Test extension initialization."""
app = Flask('demo')
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db')
FlaskCLI(app)
InvenioDB(app, entrypoint_name=False)
class Demo(db.Model):
__tablename__ = 'demo'
pk = sa.Column(sa.Integer, primary_key=True)
class Demo2(db.Model):
__tablename__ = 'demo2'
pk = sa.Column(sa.Integer, primary_key=True)
fk = sa.Column(sa.Integer, sa.ForeignKey(Demo.pk))
with app.app_context():
create_database(db.engine.url)
db.create_all()
assert len(db.metadata.tables) == 2
db.drop_all()
drop_database(db.engine.url)
def app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite://'),
)
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
InvenioDocuments(app)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def test_init():
"""Test extension initialization."""
app = Flask('demo')
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db')
FlaskCLI(app)
InvenioDB(app, entry_point_group=False)
class Demo(db.Model):
__tablename__ = 'demo'
pk = sa.Column(sa.Integer, primary_key=True)
class Demo2(db.Model):
__tablename__ = 'demo2'
pk = sa.Column(sa.Integer, primary_key=True)
fk = sa.Column(sa.Integer, sa.ForeignKey(Demo.pk))
with app.app_context():
create_database(db.engine.url)
db.create_all()
assert len(db.metadata.tables) == 2
# Test foreign key constraint checking
d1 = Demo()
db.session.add(d1)
d2 = Demo2(fk=d1.pk)
db.session.add(d2)
db.session.commit()
# Fails fk check
d3 = Demo2(fk=10)
db.session.add(d3)
pytest.raises(IntegrityError, db.session.commit)
db.session.rollback()
db.drop_all()
drop_database(db.engine.url)
def app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
TESTING=True,
LOGIN_DISABLED=False,
SECRET_KEY='test_key',
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
WTF_CSRF_ENABLED=False,
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE='simple',
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
)
FlaskCLI(app)
Babel(app)
Mail(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioAccounts(app)
app.register_blueprint(accounts_blueprint)
InvenioOAuth2Server(app)
app.register_blueprint(server_blueprint)
app.register_blueprint(settings_blueprint)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def base_app():
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app_ = Flask('test_weko_admin_app', instance_path=instance_path)
app_.config.update(
ACCOUNTS_USE_CELERY=False,
LOGIN_DISABLED=False,
SECRET_KEY='testing_key',
SQLALCHEMY_DATABASE_URI='sqlite:///test.db',
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_ECHO=False,
TEST_USER_EMAIL='*****@*****.**',
TEST_USER_PASSWORD='******',
TESTING=True,
WTF_CSRF_ENABLED=False,
)
app_.testing = True
app_.login_manager = dict(_login_disabled=True)
Babel(app_)
Mail(app_)
Menu(app_)
InvenioDB(app_)
WekoAdmin(app_)
InvenioAccounts(app_)
app_.register_blueprint(blueprint)
with app_.app_context():
if str(db.engine.url) != "sqlite://" \
and not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
yield app_
with app_.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
def gen_app(config):
"""Generate a fresh app."""
app = Flask('testapp')
app.testing = True
app.config.update(**config)
FlaskCLI(app)
FlaskMenu(app)
Babel(app)
Mail(app)
InvenioDB(app)
InvenioAccounts(app)
FlaskOAuth(app)
InvenioOAuthClient(app)
app.register_blueprint(blueprint_client)
app.register_blueprint(blueprint_settings)
with app.app_context():
db.create_all()
app.test_request_context().push()
datastore = app.extensions['invenio-accounts'].datastore
datastore.create_user(email="*****@*****.**",
password='******',
active=True)
datastore.create_user(email="*****@*****.**",
password='******',
active=True)
datastore.create_user(email="*****@*****.**",
password='******',
active=True)
datastore.commit()
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
BROKER_URL=os.environ.get('BROKER_URL', 'memory://'),
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
INDEXER_DEFAULT_INDEX='records-default-v1.0.0',
INDEXER_DEFAULT_DOC_TYPE='default-v1.0.0',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
)
FlaskCLI(app)
FlaskCeleryExt(app)
InvenioDB(app)
InvenioRecords(app)
search = InvenioSearch(app)
search.register_mappings('records', 'data')
InvenioIndexer(app)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def base_app(request):
"""Basic Flask application."""
instance_path = tempfile.mkdtemp()
app = Flask("testapp")
app.config.update(
SQLALCHEMY_DATABASE_URI=os.getenv("SQLALCHEMY_DATABASE_URI",
"sqlite://"),
SQLALCHEMY_TRACK_MODIFICATIONS=False,
TESTING=True,
SECRET_KEY="testing",
)
InvenioConfigDefault(app)
InvenioDB(app)
InvenioAccounts(app)
InvenioAccess(app)
InvenioRdmPure(app)
with app.app_context():
db_url = str(db.engine.url)
if db_url != "sqlite://" and not database_exists(db_url):
create_database(db_url)
db.create_all()
def teardown():
with app.app_context():
db_url = str(db.engine.url)
db.session.close()
if db_url != "sqlite://":
drop_database(db_url)
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
app.test_request_context().push()
return app
def db(app):
"""Create database for the tests."""
dir_path = os.path.dirname(__file__)
parent_path = str(Path(dir_path).parent)
db_path = os.environ.get('SQLALCHEMY_DATABASE_URI',
f'sqlite:////{parent_path}/database.db')
os.environ["INVENIO_SQLALCHEMY_DATABASE_URI"] = db_path
app.config.update(SQLALCHEMY_DATABASE_URI=db_path)
if database_exists(str(db_.engine.url)):
drop_database(db_.engine.url)
if not database_exists(str(db_.engine.url)):
create_database(db_.engine.url)
db_.create_all()
subprocess.run(["invenio", "taxonomies", "init"])
runner = app.test_cli_runner()
result = runner.invoke(init_db)
if result.exit_code:
print(result.output, file=sys.stderr)
assert result.exit_code == 0
yield db_
# Explicitly close DB connection
db_.session.close()
db_.drop_all()
def base_app(app_config):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
base_app = Flask(__name__, instance_path=instance_path)
base_app.config.update(app_config)
Babel(base_app)
Mail(base_app)
Menu(base_app)
InvenioDB(base_app)
InvenioAccounts(base_app)
base_app.register_blueprint(accounts_blueprint)
with base_app.app_context():
if str(db.engine.url) != "sqlite://" and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
yield base_app
with base_app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
def es_app(request):
"""Flask application with records fixture."""
app = Flask(__name__)
app.config.update(SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'), )
Babel(app)
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
InvenioMARC21(app)
sleep(10)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(TESTING=True,
SERVER_NAME='localhost:5000',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'))
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
with app.app_context():
if app.config['SQLALCHEMY_DATABASE_URI'] != 'sqlite://':
create_database(db.engine.url)
db.create_all()
def finalize():
with app.app_context():
db.drop_all()
if app.config['SQLALCHEMY_DATABASE_URI'] != 'sqlite://':
drop_database(db.engine.url)
request.addfinalizer(finalize)
return app
def app(request):
"""Flask application fixture.
Creates a Flask application with a simple testing configuration,
then creates an application context and inside of it recreates
all databases and indices from the fixtures. Finally it yields,
so that all tests that explicitly use the ``app`` fixture have
access to an application context.
See: http://flask.pocoo.org/docs/0.12/appcontext/.
"""
app = create_app()
app.config.update({'DEBUG': True})
with app.app_context():
# Celery task imports must be local, otherwise their
# configuration would use the default pickle serializer.
from inspirehep.modules.migrator.tasks import migrate_from_file
db.drop_all()
db.create_all()
_es = app.extensions['invenio-search']
list(_es.delete(ignore=[404]))
list(_es.create(ignore=[400]))
init_all_storage_paths()
init_users_and_permissions()
init_collections()
migrate_from_file(
'./inspirehep/demosite/data/demo-records-acceptance.xml.gz',
wait_for_results=True)
es.indices.refresh('records-hep')
yield app
def es_app(request):
"""Flask application with records fixture."""
app = Flask(__name__)
app.config.update(
JSONSCHEMAS_ENDPOINT="/",
JSONSCHEMAS_HOST="http://localhost:5000",
SQLALCHEMY_DATABASE_URI=os.environ.get(
"SQLALCHEMY_DATABASE_URI", "sqlite:///test.db"
),
)
Babel(app)
if not hasattr(app, "cli"):
from flask_cli import FlaskCLI
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
InvenioMARC21(app)
search = InvenioSearch(app)
InvenioIndexer(app)
InvenioJSONSchemas(app)
with app.app_context():
db.create_all()
list(search.create())
sleep(10)
def teardown():
with app.app_context():
db.drop_all()
list(search.delete())
request.addfinalizer(teardown)
return app
def base_app(request):
"""Base application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask("testapp", instance_path=instance_path)
app.config.update(
CELERY_BROKER_URL=os.environ.get(
"BROKER_URL", "amqp://*****:*****@localhost:5672//"),
CELERY_TASK_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_TASK_EAGER_PROPAGATES=True,
CELERY_RESULT_BACKEND="cache",
INDEXER_DEFAULT_INDEX="records-default-v1.0.0",
INDEXER_DEFAULT_DOC_TYPE="default-v1.0.0",
SQLALCHEMY_DATABASE_URI=os.environ.get("SQLALCHEMY_DATABASE_URI",
"sqlite:///test.db"),
SQLALCHEMY_TRACK_MODIFICATIONS=False,
TESTING=True,
)
FlaskCeleryExt(app)
InvenioDB(app)
InvenioRecords(app)
search = InvenioSearch(app, entry_point_group=None)
search.register_mappings("records", "data")
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
def create_app(request):
"""Basic Flask application."""
instance_path = tempfile.mkdtemp()
app = Flask("testapp")
DB = os.getenv("SQLALCHEMY_DATABASE_URI", "sqlite://")
app.config.update(
INVENIO_CONFIG_TUGRAZ_SINGLE_IP=["127.0.0.1", "127.0.0.2"],
INVENIO_CONFIG_TUGRAZ_IP_RANGES=[
["127.0.0.2", "127.0.0.99"],
["127.0.1.3", "127.0.1.5"],
],
SQLALCHEMY_DATABASE_URI=DB,
SQLALCHEMY_TRACK_MODIFICATIONS=False,
)
Babel(app)
InvenioConfigTugraz(app)
InvenioDB(app)
with app.app_context():
db_url = str(db.engine.url)
if db_url != "sqlite://" and not database_exists(db_url):
create_database(db_url)
db.create_all()
def teardown():
with app.app_context():
db_url = str(db.engine.url)
db.session.close()
if db_url != "sqlite://":
drop_database(db_url)
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
app.test_request_context().push()
return app
def base_app(request, test_metadata_format):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
def init_app(app_):
app_.config.update(
CELERY_ALWAYS_EAGER=False,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
JSONSCHEMAS_URL_SCHEME="http",
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get("SQLALCHEMY_DATABASE_URI",
"sqlite:///test.db"),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_ECHO=False,
TESTING=True,
WTF_CSRF_ENABLED=False,
DEPOSIT_SEARCH_API="/api/search",
SECURITY_PASSWORD_HASH="plaintext",
SECURITY_PASSWORD_SCHEMES=["plaintext"],
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
THEME_SITENAME="Test Site",
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE="simple",
ACCOUNTS_JWT_ENABLE=False,
# This allows access to files across all of invenio-files-rest
FILES_REST_PERMISSION_FACTORY=lambda *a, **kw: type(
"Allow", (object, ), {"can": lambda self: True})(),
FILES_REST_MULTIPART_CHUNKSIZE_MIN=10,
)
Babel(app_)
FlaskCeleryExt(app_)
Breadcrumbs(app_)
OAuth2Provider(app_)
InvenioDB(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
InvenioIndexer(app_)
InvenioJSONSchemas(app_)
InvenioOAuth2Server(app_)
InvenioPIDStore(app_)
InvenioRecords(app_)
search = InvenioSearch(app_)
search.register_mappings("deposits", "invenio_deposit.mappings")
api_app = Flask("testapiapp", instance_path=instance_path)
api_app.url_map.converters["pid"] = PIDConverter
# initialize InvenioDeposit first in order to detect any invalid dependency
InvenioDepositREST(api_app)
init_app(api_app)
InvenioREST(api_app)
InvenioOAuth2ServerREST(api_app)
InvenioRecordsREST(api_app)
InvenioFilesREST(api_app)
InvenioSword(api_app)
api_app.register_blueprint(files_rest_blueprint)
# api_app.register_blueprint(records_files_bp(api_app))
api_app.register_blueprint(records_rest_bp(api_app))
api_app.register_blueprint(invenio_files_rest_blueprint)
# Register a test (alternate) metadata format
api_app.config["SWORD_ENDPOINTS"]["depid"]["metadata_formats"][
test_metadata_format] = TestMetadata
app = Flask("testapp", instance_path=instance_path)
app.url_map.converters["pid"] = PIDConverter
# initialize InvenioDeposit first in order to detect any invalid dependency
InvenioDeposit(app)
init_app(app)
app.register_blueprint(accounts_blueprint)
app.register_blueprint(oauth2server_settings_blueprint)
InvenioAssets(app)
InvenioSearchUI(app)
InvenioRecordsUI(app)
app.register_blueprint(records_ui_bp(app))
app.wsgi_app = DispatcherMiddleware(app.wsgi_app,
{"/api": api_app.wsgi_app})
with app.app_context():
if str(db.engine.url) != "sqlite://" and not database_exists(
str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
yield app
with app.app_context():
if str(db.engine.url) != "sqlite://":
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
InvenioCelery(app)
InvenioPIDStore(app)
InvenioOpenAIRE(app)
InvenioJSONSchemas(app)
app.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI='postgresql+psycopg2://postgres:postgres@localhost'
'/invenio_test',
CELERY_ALWAYS_EAGER=True,
BROKER_URL='redis://*****:*****@localhost:5672//',
# CELERY_ACCEPT_CONTENT=['json', 'msgpack', 'yaml'],
# CELERY_RESULT_SERIALIZER='msgpack',
# CELERY_TASK_SERIALIZER='msgpack',
)
# celery_ext = InvenioCelery(app)
celery = create_celery_app(app)
if __name__ == "__main__":
with app.app_context():
if database_exists(str(db.engine.url)):
drop_database(str(db.engine.url))
create_database(str(db.engine.url))
db.create_all()
harvest_fundref()
harvest_openaire_projects()