def test_init():
"""Test extension initialization."""
app = Flask('testapp')
ext = InvenioRecords(app)
assert 'invenio-records' in app.extensions
app = Flask('testapp')
ext = InvenioRecords()
assert 'invenio-records' not in app.extensions
ext.init_app(app)
assert 'invenio-records' in app.extensions
def app(request):
"""Flask application fixture."""
# Set temporary instance path for sqlite
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
INDEXER_REPLACE_REFS=True,
CELERY_ALWAYS_EAGER=True,
CELERY_RESULT_BACKEND="cache",
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
JSONSCHEMAS_HOST='inveniosoftware.org',
OPENAIRE_OAI_LOCAL_SOURCE='invenio_openaire/data/oaire_local.sqlite',
TESTING=True,
)
app.url_map.converters['pid'] = PIDConverter
app.url_map.converters['pidpath'] = PIDPathConverter
LoginManager(app)
InvenioDB(app)
InvenioIndexer(app)
InvenioRecords(app)
InvenioCelery(app)
InvenioPIDStore(app)
InvenioOpenAIRE(app)
InvenioSearch(app)
InvenioJSONSchemas(app)
with app.app_context():
yield app
shutil.rmtree(instance_path)
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():
"""Create fixture app."""
# Set temporary instance path for sqlite
instance_path = tempfile.mkdtemp()
_app = Flask('testapp', instance_path=instance_path)
InvenioAccess(_app)
InvenioAccounts(_app)
InvenioDB(_app)
InvenioUserProfiles(_app)
InvenioRecords(_app)
InvenioFilesREST(_app)
# UserProfile(_app)
_app.config.update(
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
TESTING=True,
SECRET_KEY='test',
)
with _app.app_context():
yield _app
# Teardown instance path.
shutil.rmtree(instance_path)
def in_cluster_app(request, in_cluster_app_config):
"""Initialize InvenioRecords."""
app = Flask('in_cluster_testapp')
app.config.update(in_cluster_app_config)
InvenioDB(app)
InvenioRecords(app)
search = InvenioSearch(app)
InvenioIndexer(app)
InvenioIndexMigrator(app)
search.register_mappings('records', 'mock_module.mappings')
search.register_mappings('authors', 'mock_module.mappings')
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
list(search.create())
search.flush_and_refresh('*')
def teardown():
with app.app_context():
db.drop_all()
list(search.delete(ignore=[404]))
search.client.indices.delete('*')
request.addfinalizer(teardown)
with app.app_context():
yield app
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 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 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_
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 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 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(__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(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 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(
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('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'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
RECORDS_REST_ENDPOINTS=config.RECORDS_REST_ENDPOINTS,
# No permission checking
RECORDS_REST_DEFAULT_CREATE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_READ_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_UPDATE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_DELETE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_SEARCH_INDEX=ES_INDEX,
RECORDS_REST_SORT_OPTIONS={
ES_INDEX: dict(year=dict(fields=['year'], ))
},
)
app.config['RECORDS_REST_ENDPOINTS']['recid']['search_class'] = TestSearch
# update the application with the configuration provided by the test
if hasattr(request, 'param') and 'config' in request.param:
app.config.update(**request.param['config'])
FlaskCLI(app)
InvenioDB(app)
InvenioREST(app)
InvenioRecords(app)
InvenioPIDStore(app)
InvenioSearch(app)
InvenioAccess(app)
InvenioRecordsREST(app)
with app.app_context():
# Setup app
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()
if current_search_client.indices.exists(ES_INDEX):
current_search_client.indices.delete(ES_INDEX)
current_search_client.indices.create(ES_INDEX)
prepare_indexing(app)
with app.app_context():
# Yield app in request context
with app.test_request_context():
yield app
with app.app_context():
# Teardown app
db.drop_all()
if app.config['SQLALCHEMY_DATABASE_URI'] != 'sqlite://':
drop_database(db.engine.url)
shutil.rmtree(instance_path)
def app():
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
CELERY_ALWAYS_EAGER=True,
CELERY_TASK_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_TASK_EAGER_PROPAGATES=True,
CELERY_RESULT_BACKEND='cache',
JSONSCHEMAS_HOST='inveniosoftware.org',
TESTING=True,
SECRET_KEY='CHANGE_ME',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SERVER_NAME='app',
OAISERVER_ID_PREFIX='oai:inveniosoftware.org:recid/',
OAISERVER_QUERY_PARSER_FIELDS=["title_statement"],
OAISERVER_RECORD_INDEX='_all',
OAISERVER_REGISTER_SET_SIGNALS=True,
)
if not hasattr(app, 'cli'):
from flask_cli import FlaskCLI
FlaskCLI(app)
InvenioDB(app)
FlaskCeleryExt(app)
InvenioJSONSchemas(app)
InvenioRecords(app)
InvenioPIDStore(app)
InvenioMARC21(app)
client = Elasticsearch(hosts=[os.environ.get('ES_HOST', 'localhost')])
search = InvenioSearch(app, client=client)
search.register_mappings('records', 'data')
InvenioIndexer(app)
InvenioOAIServer(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()
list(search.delete(ignore=[404]))
list(search.create())
search.flush_and_refresh('_all')
with app.app_context():
yield app
with app.app_context():
db.session.close()
if str(db.engine.url) != 'sqlite://':
drop_database(str(db.engine.url))
list(search.delete(ignore=[404]))
search.client.indices.delete("*-percolators")
shutil.rmtree(instance_path)
def base_app():
"""Flask application fixture without InvenioStats."""
from invenio_stats.config import STATS_EVENTS
instance_path = tempfile.mkdtemp()
app_ = Flask('testapp', instance_path=instance_path)
stats_events = {
'file-download': deepcopy(STATS_EVENTS['file-download']),
'record-view': {
'signal': 'invenio_records_ui.signals.record_viewed',
'event_builders': ['invenio_stats.contrib.event_builders'
'.record_view_event_builder']
}
}
stats_events.update({'event_{}'.format(idx): {} for idx in range(5)})
app_.config.update(dict(
CELERY_ALWAYS_EAGER=True,
CELERY_TASK_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_TASK_EAGER_PROPAGATES=True,
CELERY_RESULT_BACKEND='cache',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite://'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
OAUTH2SERVER_CLIENT_ID_SALT_LEN=64,
OAUTH2SERVER_CLIENT_SECRET_SALT_LEN=60,
OAUTH2SERVER_TOKEN_PERSONAL_SALT_LEN=60,
STATS_MQ_EXCHANGE=Exchange(
'test_events',
type='direct',
delivery_mode='transient', # in-memory queue
durable=True,
),
SECRET_KEY='asecretkey',
SERVER_NAME='localhost',
STATS_QUERIES={'bucket-file-download-histogram': {},
'bucket-file-download-total': {},
'test-query': {},
'test-query2': {}},
STATS_EVENTS=stats_events,
STATS_AGGREGATIONS={'file-download-agg': {}}
))
FlaskCeleryExt(app_)
InvenioAccounts(app_)
InvenioAccountsREST(app_)
InvenioDB(app_)
InvenioRecords(app_)
InvenioFilesREST(app_)
InvenioPIDStore(app_)
InvenioCache(app_)
InvenioQueues(app_)
InvenioOAuth2Server(app_)
InvenioOAuth2ServerREST(app_)
InvenioSearch(app_, entry_point_group=None)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def app(request):
"""Test multilingual."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
ACCOUNTS_JWT_ENABLE=False,
INDEXER_DEFAULT_DOC_TYPE='record-v1.0.0',
RECORDS_REST_ENDPOINTS={},
RECORDS_REST_DEFAULT_CREATE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_DELETE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_READ_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_UPDATE_PERMISSION_FACTORY=None,
SERVER_NAME='localhost:5000',
JSONSCHEMAS_HOST='localhost:5000',
CELERY_ALWAYS_EAGER=True,
CELERY_RESULT_BACKEND='cache',
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'
),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SUPPORTED_LANGUAGES=["cs", "en"],
BABEL_DEFAULT_LOCALE='cs',
I18N_LANGUAGES=(
('en', _('English')),
),
TESTING=True,
ELASTICSEARCH_DEFAULT_LANGUAGE_TEMPLATE={
"type": "text",
"fields": {
"raw": {
"type": "keyword"
}
}
}
)
app.secret_key = 'changeme'
InvenioDB(app)
InvenioRecords(app)
InvenioJSONSchemas(app)
InvenioPIDStore(app)
InvenioSearch(app)
InvenioIndexer(app)
OARepoMappingIncludesExt(app)
OARepoMultilingualExt(app)
#
app_loaded.send(app, app=app)
with app.app_context():
yield app
# Teardown instance path.
shutil.rmtree(instance_path)
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
es_index = 'invenio_records_rest_test_index'
app.config.update(
TESTING=True,
SERVER_NAME='localhost:5000',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
RECORDS_REST_ENDPOINTS=config.RECORDS_REST_ENDPOINTS,
# No permission checking
RECORDS_REST_DEFAULT_CREATE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_READ_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_UPDATE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_DELETE_PERMISSION_FACTORY=None,
RECORDS_REST_DEFAULT_SEARCH_INDEX=es_index,
RECORDS_REST_SORT_OPTIONS={
es_index: dict(year=dict(fields=['year'], ))
},
SEARCH_QUERY_ENHANCERS=[filter_record_access_query_enhancer],
)
app.config['RECORDS_REST_ENDPOINTS']['recid']['search_index'] = es_index
# update the application with the configuration provided by the test
if hasattr(request, 'param') and 'config' in request.param:
app.config.update(**request.param['config'])
FlaskCLI(app)
InvenioDB(app)
InvenioREST(app)
InvenioRecords(app)
InvenioPIDStore(app)
InvenioSearch(app)
InvenioAccess(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()
if current_search_client.indices.exists(es_index):
current_search_client.indices.delete(es_index)
current_search_client.indices.create(es_index)
prepare_indexing(app)
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(
TESTING=True,
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://'),
SQLALCHEMY_TRACK_MODIFICATIONS=False,
SECRET_KEY='mysecret',
SUPPORT_EMAIL='*****@*****.**',
WTF_CSRF_ENABLED=False,
SERVER_NAME='test.it',
RECORDS_UI_ENDPOINTS=dict(
recid=dict(
pid_type='recid',
route='/records/<pid_value>',
template='invenio_records_ui/detail.html',
),
recid_access_request=dict(
pid_type='recid',
route='/records/<pid_value>/accessrequest',
template='zenodo_accessrequests/access_request.html',
view_imp='zenodo_accessrequests.views.requests.access_request',
methods=['GET', 'POST'],
),
recid_access_request_email_confirm=dict(
pid_type='recid',
route='/records/<pid_value>/accessrequest/<token>/confirm',
# template='invenio_records_ui/detail.html',
view_imp='zenodo_accessrequests.views.requests.confirm',
),
),
)
InvenioFormatter(app_)
Babel(app_)
InvenioDB(app_)
InvenioAccounts(app_)
InvenioRecords(app_)
FlaskMenu(app_)
Mail(app_)
InvenioRecordsUI(app_)
InvenioAccess(app_)
ZenodoAccessRequests(app_)
InvenioPIDStore(app_)
app_.register_blueprint(request_blueprint)
app_.register_blueprint(settings_blueprint)
app_.register_blueprint(blueprint_user)
app_.register_blueprint(create_blueprint_from_app(app_))
with app_.app_context():
yield app_
def app(request, docid_record_type_endpoint):
"""Flask application fixture."""
from invenio_records_files.api import Record as RecordFiles
instance_path = tempfile.mkdtemp()
app_ = Flask(__name__, instance_path=instance_path)
RECORDS_REST_ENDPOINTS.update(
docid=docid_record_type_endpoint
)
# Endpoint with files support
RECORDS_REST_ENDPOINTS['recid']['record_class'] = RecordFiles
RECORDS_REST_ENDPOINTS['recid']['item_route'] = \
'/records/<pid(recid, ' \
'record_class="invenio_records_files.api.Record"):pid_value>'
RECORDS_REST_ENDPOINTS['recid']['indexer_class'] = None
# Application
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,
RECORDS_FILES_REST_ENDPOINTS={
'RECORDS_REST_ENDPOINTS': {
'recid': 'files',
'docid': 'nofiles',
}
},
RECORDS_REST_ENDPOINTS=RECORDS_REST_ENDPOINTS,
RECORDS_REST_DEFAULT_CREATE_PERMISSION_FACTORY=allow_all,
)
app_.url_map.converters['pid'] = PIDConverter
InvenioDB(app_)
InvenioRecords(app_)
InvenioFilesREST(app_)
InvenioIndexer(app_)
InvenioPIDStore(app_)
InvenioRecordsREST(app_)
InvenioRecordsFiles(app_)
app_.register_blueprint(files_rest_blueprint)
app_.register_blueprint(create_blueprint_from_app(app_))
app_.register_blueprint(records_rest_create_blueprint_from_app(app_))
search = InvenioSearch(app_)
search.register_mappings('records-files', 'data')
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def app():
"""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',
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=[],
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE='simple',
)
app_.url_map.converters['pid'] = PIDConverter
FlaskCLI(app_)
Babel(app_)
FlaskCeleryExt(app_)
InvenioDB(app_)
Breadcrumbs(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
app_.register_blueprint(accounts_blueprint)
InvenioAssets(app_)
InvenioJSONSchemas(app_)
InvenioSearch(app_)
InvenioRecords(app_)
app_.url_map.converters['pid'] = PIDConverter
InvenioRecordsREST(app_)
InvenioPIDStore(app_)
InvenioIndexer(app_)
InvenioDeposit(app_)
InvenioSearchUI(app_)
InvenioRecordsUI(app_)
InvenioFilesREST(app_)
OAuth2Provider(app_)
InvenioOAuth2Server(app_)
InvenioOAuth2ServerREST(app_)
app_.register_blueprint(oauth2server_settings_blueprint)
InvenioDepositREST(app_)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def _create_app(**config):
app_ = Flask(
__name__,
instance_path=instance_path,
)
app_.config.update(config)
InvenioCelery(app_)
InvenioDB(app_)
InvenioRecords(app_)
return app_
def app():
"""Flask application fixture with database initialization."""
instance_path = tempfile.mkdtemp()
app_ = Flask(
'testapp', static_folder=instance_path, instance_path=instance_path)
app_.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'sqlite:///:memory:'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
RECORDS_UI_DEFAULT_PERMISSION_FACTORY=None,
RECORDS_UI_ENDPOINTS=dict(
recid=dict(
pid_type='recid',
route='/records/<pid_value>',
template='invenio_records_ui/detail.html',
),
recid_previewer=dict(
pid_type='recid',
route='/records/<pid_value>/preview/<filename>',
view_imp='invenio_previewer.views:preview',
record_class='invenio_records_files.api:Record',
),
recid_files=dict(
pid_type='recid',
route='/record/<pid_value>/files/<filename>',
view_imp='invenio_records_files.utils.file_download_ui',
record_class='invenio_records_files.api:Record',
),
),
SERVER_NAME='localhost'
)
Babel(app_)
assets_ext = InvenioAssets(app_)
InvenioDB(app_)
InvenioRecords(app_)
previewer = InvenioPreviewer(app_)._state
InvenioRecordsUI(app_)
InvenioFilesREST(app_)
# Add base assets bundles for jQuery and Bootstrap
# Note: These bundles aren't included by default since package consumers
# should handle assets and their dependencies manually.
assets_ext.env.register(previewer.js_bundles[0], previewer_base_js)
assets_ext.env.register(previewer.css_bundles[0], previewer_base_css)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app_ = Flask(__name__, instance_path=instance_path)
app_.config.update(
SQLALCHEMY_DATABASE_URI=os.getenv(
'SQLALCHEMY_DATABASE_URI',
'postgresql+psycopg2://localhost/circulation_test'),
OAUTH2SERVER_CLIENT_ID_SALT_LEN=40,
OAUTH2SERVER_CLIENT_SECRET_SALT_LEN=60,
OAUTH2SERVER_TOKEN_PERSONAL_SALT_LEN=60,
SECRET_KEY='changeme',
SERVER_NAME='localhost:5000',
REPLACE_REFS=False,
TESTING=True,
CIRCULATION_ACTION_LOAN_URL=(
'/hooks/receivers/circulation_loan/events/'),
CIRCULATION_ACTION_REQUEST_URL=(
'/hooks/receivers/circulation_request/events/'),
CIRCULATION_ACTION_RETURN_URL=(
'/hooks/receivers/circulation_return/events/'),
)
app_.url_map.converters['pid'] = PIDConverter
Babel(app_)
Menu(app_)
Breadcrumbs(app_)
InvenioAccounts(app_)
InvenioAssets(app_)
InvenioDB(app_)
InvenioIndexer(app_)
InvenioJSONSchemas(app_)
InvenioPIDStore(app_)
InvenioRecords(app_)
InvenioRecordsREST(app_)
InvenioWebhooks(app_)
InvenioOAuth2Server(app_)
InvenioCirculation(app_)
InvenioCirculationREST(app_)
InvenioSearch(app_)
app_.register_blueprint(server_blueprint)
app_.register_blueprint(settings_blueprint)
app_.register_blueprint(webhooks_blueprint)
app_.register_blueprint(circulation_blueprint)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def testapp(base_app, database):
"""Application with just a database.
Pytest-Invenio also initialises ES with the app fixture.
"""
location_obj = Location(
name="marctest-location", uri=tempfile.mkdtemp(), default=True
)
database.session.add(location_obj)
database.session.commit()
InvenioRecords(base_app)
InvenioJSONSchemas(base_app)
yield base_app
def app(base_app):
"""Flask application fixture."""
base_app._internal_jsonschemas = InvenioJSONSchemas(base_app)
InvenioREST(base_app)
InvenioRecordsREST(base_app)
InvenioRecords(base_app)
InvenioPIDStore(base_app)
base_app.url_map.converters['pid'] = PIDConverter
base_app.register_blueprint(create_blueprint_from_app(base_app))
app_loaded.send(None, app=base_app)
with base_app.app_context():
yield base_app
def app():
"""Flask application fixture with database initialization."""
instance_path = tempfile.mkdtemp()
app_ = Flask('testapp',
static_folder=instance_path,
instance_path=instance_path)
app_.config.update(
TESTING=True,
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///:memory:'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
RECORDS_UI_DEFAULT_PERMISSION_FACTORY=None,
RECORDS_UI_ENDPOINTS=dict(
recid=dict(
pid_type='recid',
route='/records/<pid_value>',
template='invenio_records_ui/detail.html',
),
recid_previewer=dict(
pid_type='recid',
route='/records/<pid_value>/preview',
view_imp='invenio_previewer.views:preview',
record_class='invenio_records_files.api:Record',
),
recid_files=dict(
pid_type='recid',
route='/record/<pid_value>/files/<filename>',
view_imp='invenio_records_files.utils.file_download_ui',
record_class='invenio_records_files.api:Record',
),
),
SERVER_NAME='localhost',
APP_THEME=['semantic-ui'])
Babel(app_)
InvenioAssets(app_)
InvenioDB(app_)
InvenioRecords(app_)
InvenioConfigDefault(app_)
InvenioFormatter(app_)
InvenioPreviewer(app_)._state
InvenioRecordsUI(app_)
app_.register_blueprint(create_blueprint_from_app(app_))
InvenioFilesREST(app_)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
TESTING=True,
SECRET_KEY='CHANGE_ME',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite://'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SERVER_NAME='app',
OAISERVER_RECORD_INDEX='records-record-v1.0.0',
OAISERVER_METADATA_FORMATS={
'oai_dc': {
'serializer': ('conftest:dump_etree', {
'xslt_filename':
pkg_resources.resource_filename(
'invenio_oaiserver', 'static/xsl/oai2.v1.0.xsl')
}),
'schema':
'http://www.openarchives.org/OAI/2.0/oai_dc.xsd',
'namespace':
'http://www.openarchives.org/OAI/2.0/oai_dc/',
}
},
)
FlaskCLI(app)
InvenioDB(app)
InvenioRecords(app)
InvenioPIDStore(app)
search = InvenioSearch(app)
search.register_mappings('records', 'data')
InvenioIndexer(app)
InvenioOAIServer(app)
with app.app_context():
db.create_all()
search.client.indices.delete_alias('_all', '_all', ignore=[400, 404])
search.client.indices.delete('*')
list(search.create(ignore=[400]))
def teardown():
with app.app_context():
list(search.delete(ignore=[404]))
db.drop_all()
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return app
