def test_init():
"""Test extension initialization."""
app = Flask('testapp')
app.config.update(
ACCOUNTS_USE_CELERY=False,
SECRET_KEY="test_key",
)
Babel(app)
Mail(app)
Menu(app)
InvenioDB(app)
InvenioAccounts(app)
ext = InvenioUserProfiles(app)
assert 'invenio-userprofiles' in app.extensions
app = Flask('testapp')
app.config.update(
ACCOUNTS_USE_CELERY=False,
SECRET_KEY="test_key",
)
Babel(app)
Mail(app)
Menu(app)
InvenioDB(app)
InvenioAccounts(app)
ext = InvenioUserProfiles()
assert 'invenio-userprofiles' not in app.extensions
ext.init_app(app)
assert 'invenio-userprofiles' in app.extensions
def test_init_rest():
"""Test REST extension initialization."""
app = Flask('testapp')
Babel(app)
Mail(app)
InvenioDB(app)
ext = InvenioAccountsREST(app)
assert 'invenio-accounts' in app.extensions
assert 'security' not in app.blueprints.keys()
app = Flask('testapp')
Babel(app)
Mail(app)
InvenioDB(app)
ext = InvenioAccountsREST()
assert 'invenio-accounts' not in app.extensions
assert 'security' not in app.blueprints.keys()
ext.init_app(app)
assert 'invenio-accounts' in app.extensions
assert 'security' not in app.blueprints.keys()
app = Flask('testapp')
app.config['ACCOUNTS_REGISTER_BLUEPRINT'] = True
Babel(app)
Mail(app)
InvenioDB(app)
ext = InvenioAccountsREST()
assert 'invenio-accounts' not in app.extensions
assert 'security' not in app.blueprints.keys()
ext.init_app(app)
assert 'invenio-accounts' in app.extensions
assert 'security' in app.blueprints.keys()
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,
)
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()
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(
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
TESTING=True,
)
InvenioDB(app)
InvenioRecords(app)
InvenioSearch(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 base_app():
"""Flask application fixture."""
app_ = Flask('testapp')
app_.config.update(
TESTING=True,
# Celery 3
CELERY_ALWAYS_EAGER=True,
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
# Celery 4
CELERY_TASK_ALWAYS_EAGER=True,
CELERY_TASK_EAGER_PROPAGATES=True,
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///:memory:'),
WTF_CSRF_ENABLED=False,
SERVER_NAME='invenio.org',
SECURITY_PASSWORD_SALT='TEST_SECURITY_PASSWORD_SALT',
SECRET_KEY='TEST_SECRET_KEY',
FILES_REST_MULTIPART_CHUNKSIZE_MIN=2,
FILES_REST_MULTIPART_CHUNKSIZE_MAX=20,
FILES_REST_MULTIPART_MAX_PARTS=100,
FILES_REST_TASK_WAIT_INTERVAL=0.1,
FILES_REST_TASK_WAIT_MAX_SECONDS=1,
)
FlaskCeleryExt(app_)
InvenioDB(app_)
Babel(app_)
Menu(app_)
return app_
def app(request):
"""Basic Flask application."""
instance_path = tempfile.mkdtemp()
app = Flask("testapp")
DB = os.getenv("SQLALCHEMY_DATABASE_URI", "sqlite://")
app.config.update(
SQLALCHEMY_DATABASE_URI=DB,
SQLALCHEMY_TRACK_MODIFICATIONS=False,
)
InvenioDB(app)
InvenioPIDStore(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 es_app(request):
"""Flask application with records fixture."""
app = Flask(__name__)
app.config.update(
JSONSCHEMAS_HOST='http://localhost:5000',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
)
app.config[InvenioJSONSchemas.CONFIG_ENDPOINT] = '/'
Babel(app)
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."""
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,
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 base_app():
"""Flask applicat-ion fixture."""
instance_path = os.path.join(sys.prefix, 'var', 'test-instance')
# empty the instance path
if os.path.exists(instance_path):
shutil.rmtree(instance_path)
os.makedirs(instance_path)
os.environ['INVENIO_INSTANCE_PATH'] = instance_path
app_ = Flask('invenio-model-testapp', instance_path=instance_path)
app_.config.update(
TESTING=True,
JSON_AS_ASCII=True,
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///:memory:'),
SERVER_NAME='localhost:5000',
SECURITY_PASSWORD_SALT='TEST_SECURITY_PASSWORD_SALT',
SECRET_KEY='TEST_SECRET_KEY',
INVENIO_INSTANCE_PATH=instance_path,
SEARCH_INDEX_PREFIX='test-',
JSONSCHEMAS_HOST='localhost:5000',
SEARCH_ELASTIC_HOSTS=os.environ.get('SEARCH_ELASTIC_HOSTS', None),
PIDSTORE_RECID_FIELD='id',
FILES_REST_PERMISSION_FACTORY=allow_all)
InvenioDB(app_)
InvenioIndexer(app_)
InvenioSearch(app_)
return app_
def base_app():
"""Flask application fixture."""
app_ = Flask('testapp')
app_.config.update(
TESTING=True,
JSON_AS_ASCII=True,
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'sqlite:///:memory:'),
SERVER_NAME='localhost',
SECURITY_PASSWORD_SALT='TEST_SECURITY_PASSWORD_SALT',
SECRET_KEY='TEST_SECRET_KEY',
FILES_REST_MULTIPART_CHUNKSIZE_MIN=2,
FILES_REST_MULTIPART_CHUNKSIZE_MAX=20,
FILES_REST_MULTIPART_MAX_PARTS=100,
FILES_REST_TASK_WAIT_INTERVAL=0.1,
FILES_REST_TASK_WAIT_MAX_SECONDS=1,
)
app.test_client_class = JsonClient
InvenioDB(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
InvenioJSONSchemas(app_)
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 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.create_all()
yield base_app
with base_app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
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 app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app_ = Flask(__name__, instance_path=instance_path)
app_.config.update(
FILES_REST_PERMISSION_FACTORY=lambda *a, **kw: type(
'Allow', (object, ), {'can': lambda self: True})(),
SECRET_KEY='CHANGE_ME',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite://'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
)
app_.register_blueprint(files_rest_blueprint)
InvenioDB(app_)
InvenioRecords(app_)
InvenioFilesREST(app_)
InvenioIndexer(app_)
search = InvenioSearch(app_)
search.register_mappings('records-files', 'data')
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def create_app():
"""REANA Server application factory."""
logging.basicConfig(level=REANA_LOG_LEVEL, format=REANA_LOG_FORMAT)
app = Flask(__name__)
app.config.from_object('reana_server.config')
app.secret_key = "hyper secret key"
app.session = Session
Babel(app)
FlaskMenu(app)
InvenioDB(app)
InvenioAccounts(app)
FlaskOAuth(app)
InvenioOAuthClient(app)
# Register Invenio OAuth endpoints
app.register_blueprint(blueprint_user)
app.register_blueprint(blueprint_client)
app.register_blueprint(blueprint_settings)
# Register API routes
from .rest import gitlab, ping, secrets, users, workflows # noqa
app.register_blueprint(ping.blueprint, url_prefix='/api')
app.register_blueprint(workflows.blueprint, url_prefix='/api')
app.register_blueprint(users.blueprint, url_prefix='/api')
app.register_blueprint(secrets.blueprint, url_prefix='/api')
app.register_blueprint(gitlab.blueprint, url_prefix='/api')
return app
def test_disabled_versioning_with_custom_table(db, app, versioning, tables):
"""Test SQLAlchemy-Continuum table loading."""
app.config['DB_VERSIONING'] = versioning
class EarlyClass(db.Model):
__versioned__ = {}
pk = db.Column(db.Integer, primary_key=True)
idb = InvenioDB(app,
entry_point_group=None,
db=db,
versioning_manager=VersioningManager())
with app.app_context():
db.drop_all()
db.create_all()
before = len(db.metadata.tables)
ec = EarlyClass()
ec.pk = 1
db.session.add(ec)
db.session.commit()
assert tables == len(db.metadata.tables)
db.drop_all()
if versioning:
remove_versioning(manager=idb.versioning_manager)
def base_app():
"""Flask application fixture."""
app_ = Flask('testapp')
app_.config.update(
TESTING=True,
JSON_AS_ASCII=True,
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'sqlite:///:memory:'),
SERVER_NAME='localhost',
SECURITY_PASSWORD_SALT='TEST_SECURITY_PASSWORD_SALT',
SECRET_KEY='TEST_SECRET_KEY',
FILES_REST_MULTIPART_CHUNKSIZE_MIN=2,
FILES_REST_MULTIPART_CHUNKSIZE_MAX=20,
FILES_REST_MULTIPART_MAX_PARTS=100,
FILES_REST_TASK_WAIT_INTERVAL=0.1,
FILES_REST_TASK_WAIT_MAX_SECONDS=1,
TAXONOMY_SERVER_NAME='taxonomy-server.com',
TAXONOMY_REDIS_URL='redis://localhost:6379/15',
)
app.test_client_class = JsonClient
InvenioDB(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
InvenioJSONSchemas(app_)
OARepoReferences(app_)
app_.extensions['oarepo-references'] = RecordReferencesStateMock(app_)
return app_
def _app_factory(config=None):
"""Application factory."""
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",
LOGIN_DISABLED=False,
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'),
SERVER_NAME='example.com',
TESTING=True,
WTF_CSRF_ENABLED=False,
)
app.config.update(config or {})
Menu(app)
Babel(app)
Mail(app)
InvenioDB(app)
return 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(__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,
)
FlaskCeleryExt(app)
InvenioDB(app)
InvenioWorkflows(app)
InvenioWorkflowsUI(app)
InvenioOAIHarvester(app)
INSPIRECrawler(app)
with app.app_context():
yield app
shutil.rmtree(instance_path)
def _app_factory(config=None):
"""Application factory."""
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",
LOGIN_DISABLED=False,
MAIL_SUPPRESS_SEND=True,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SECURITY_CONFIRM_EMAIL_WITHIN="2 seconds",
SECURITY_RESET_PASSWORD_WITHIN="2 seconds",
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
SERVER_NAME='example.com',
TESTING=True,
WTF_CSRF_ENABLED=False,
)
# Set key value session store to use Redis when running on TravisCI.
if os.environ.get('CI', 'false') == 'true':
app.config.update(
ACCOUNTS_SESSION_REDIS_URL='redis://localhost:6379/0',
)
app.config.update(config or {})
Menu(app)
Babel(app)
Mail(app)
InvenioDB(app)
return app
def app():
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
JSONSCHEMAS_HOST="nusl.cz",
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'postgresql+psycopg2://{user}:{pw}@{url}/{db}'.format(user="******", pw="oarepo",
url="127.0.0.1",
db="oarepo")),
SERVER_NAME='127.0.0.1:5000',
)
InvenioRecordsDraft(app)
InvenioJSONSchemas(app)
InvenioRecords(app)
InvenioSearch(app)
InvenioIndexer(app)
InvenioDB(app)
FlaskTaxonomies(app)
FlaskTaxonomiesES(app)
InvenioNUSLTheses(app)
with app.app_context():
app.register_blueprint(taxonomies_blueprint)
yield app
shutil.rmtree(instance_path)
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)
Babel(app)
InvenioDB(app)
InvenioPIDStore(app)
InvenioRecords(app)
InvenioFilesREST(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."""
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'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
)
FlaskCeleryExt(app_)
InvenioDB(app_)
InvenioRecords(app_)
InvenioPIDStore(app_)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def app(base_app):
"""Flask full application fixture."""
InvenioDB(base_app)
InvenioFilesREST(base_app)
InvenioPIDStore(base_app)
with base_app.app_context():
yield base_app
def test_db(request):
"""Test database backend."""
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite://')
InvenioDB(app)
FlaskOAuth(app)
InvenioOAuthClient(app)
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
with app.app_context():
is_sqllite = str(db.engine.url) == 'sqlite://'
db_exists = database_exists(str(db.engine.url))
if not is_sqllite and not db_exists:
create_database(str(db.engine.url))
db.create_all()
tables = list(
filter(lambda table: table.startswith('oauthclient'),
db.metadata.tables.keys()))
assert len(tables) == 2
def records_app(request):
"""Initialize InvenioRecords."""
app = Flask('records_testapp')
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=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 app(request):
"""Flask application fixture."""
app_ = Flask('testapp')
app_.config.update(
CELERY_ALWAYS_EAGER=True,
CELERY_RESULT_BACKEND="cache",
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
TESTING=True,
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'sqlite:///:memory:'),
SECURITY_PASSWORD_SALT='TEST',
SECRET_KEY='TEST',
)
FlaskCeleryExt(app_)
InvenioDB(app_)
InvenioRecords(app_)
InvenioDeposit(app_)
InvenioJSONSchemas(app_)
InvenioAccounts(app_)
InvenioCommunities(app_)
InvenioPIDStore(app_)
InvenioSIPStore(app_)
Babel(app_)
InvenioFilesREST(app_)
InvenioMigrator(app_)
FlaskOAuth(app_)
InvenioOAuthClient(app_)
with app_.app_context():
yield app_
