def es(app):
"""Provide elasticsearch access."""
InvenioSearch(app)
try:
list(current_search.create())
except RequestError:
list(current_search.delete(ignore=[404]))
list(current_search.create(ignore=[400]))
current_search_client.indices.refresh()
yield current_search_client
list(current_search.delete(ignore=[404]))
def test_client_config():
"""Test Elasticsearch client configuration."""
app = Flask('testapp')
app.config['SEARCH_CLIENT_CONFIG'] = {'timeout': 30, 'foo': 'bar'}
with patch('elasticsearch.Elasticsearch.__init__') as mock_es_init:
mock_es_init.return_value = None
ext = InvenioSearch(app)
es_client = ext.client # trigger client initialization
mock_es_init.assert_called_once_with(
hosts=None, connection_class=RequestsHttpConnection,
timeout=30, foo='bar')
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(request):
"""Test mdcobject."""
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',
FLASK_TAXONOMIES_URL_PREFIX='/2.0/taxonomies/',
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"],
TESTING=True,
ELASTICSEARCH_DEFAULT_LANGUAGE_TEMPLATE={
"type": "text",
"fields": {
"keywords": {
"type": "keyword"
}
}
})
app.secret_key = 'changeme'
InvenioDB(app)
OarepoTaxonomies(app)
OARepoReferences(app)
InvenioRecords(app)
InvenioJSONSchemas(app)
InvenioPIDStore(app)
InvenioSearch(app)
InvenioIndexer(app)
OARepoMappingIncludesExt(app)
#
app_loaded.send(app, app=app)
with app.app_context():
yield app
# Teardown instance path.
shutil.rmtree(instance_path)
def es(app):
"""Provide elasticsearch access."""
app.config.update(dict(SEARCH_AUTOINDEX=[], ))
InvenioSearch(app)
with app.app_context():
try:
list(current_search.create())
except RequestError:
list(current_search.delete(ignore=[404]))
list(current_search.create())
yield current_search
list(current_search.delete(ignore=[404]))
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 app():
"""Flask application fixture."""
# Set temporary instance path for sqlite
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(TESTING=True)
InvenioSearch(app)
with app.app_context():
yield app
# Teardown instance path.
shutil.rmtree(instance_path)
def base_app(base_app):
"""Flask base application fixture."""
base_app.url_map.converters['pid'] = PIDConverter
InvenioDB(base_app)
InvenioRecords(base_app)
InvenioRecordsREST(base_app)
InvenioPIDStore(base_app)
InvenioIndexer(base_app)
InvenioPIDStore(base_app)
InvenioSearch(base_app)
InvenioCirculation(base_app)
InvenioJSONSchemas(base_app)
base_app.register_blueprint(create_blueprint_from_app(base_app))
yield base_app
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
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,
WTF_CSRF_ENABLED=False,
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_)
app_.register_blueprint(accounts_blueprint)
InvenioJSONSchemas(app_)
InvenioSearch(app_)
InvenioRecords(app_)
app_.url_map.converters['pid'] = PIDConverter
InvenioRecordsREST(app_)
InvenioPIDStore(app_)
InvenioIndexer(app_)
InvenioDeposit(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 es(app):
"""Provide elasticsearch access."""
InvenioSearch(app)
try:
list(current_search.create())
except RequestError:
list(current_search.delete(ignore=[404]))
list(current_search.create(ignore=[400]))
current_search_client.indices.refresh()
queue = app.config['INDEXER_MQ_QUEUE']
with establish_connection() as c:
q = queue(c)
q.declare()
yield current_search_client
list(current_search.delete(ignore=[404]))
def oai_server(sender, app=None, **kwargs):
#app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
app.config['CELERY_TASK_ALWAYS_EAGER'] = True
if not hasattr(app, 'cli'):
from flask_cli import FlaskCLI
ext_cli = FlaskCLI(app)
ext_db = InvenioDB(app)
ext_indexer = InvenioIndexer(app)
ext_pidstore = InvenioPIDStore(app)
ext_records = InvenioRecords(app)
ext_search = InvenioSearch(app)
ext_celery = FlaskCeleryExt(app)
app.config['OAISERVER_RECORD_INDEX'] = ['authors', 'records']
app.config['OAISERVER_ID_PREFIX'] = 'oai:example:'
app.config['OAISERVER_QUERY_PARSER_FIELDS'] = ["title"]
app.config['OAISERVER_METADATA_FORMATS'] = {
'oai_dc': {
'serializer': ('invenio_oaiserver.utils:dumps_etree', {
'xslt_filename':
pkg_resources.resource_filename(
'testinvenio.records', 'static/xsl/MARC21slim2OAIDC.xsl'),
'xslt_filename':
pathlib.Path(
"/home/alzbeta/testinvenio/testinvenio/records/static/xsl/MARC21slim2OAIDC.xsl"
)
}),
'schema':
'http://json-schema.org/draft-04/schema#',
'namespace':
'http://json-schema.org/draft-04/schema#',
}
}
ext_oaiserver = InvenioOAIServer(app)
app.register_blueprint(blueprint)
ctx = app.app_context()
ctx.push()
db.create_all()
ext_search.flush_and_refresh('_all')
oaiset = OAISet(spec='pattern', name='Pattern', description='...')
#nefunguje pokud search pattern ma pole ktere neni v obouch modelech...
oaiset.search_pattern = 'title:Some title1'
try:
print("1")
db.session.add(oaiset)
db.session.commit()
except:
pass
def base_app(events_config, aggregations_config):
"""Flask application fixture without InvenioStats."""
instance_path = tempfile.mkdtemp()
app_ = Flask('testapp', instance_path=instance_path)
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,
# Bump the ES client timeout for slower environments (like Travis CI)
SEARCH_CLIENT_CONFIG={'timeout': 30, 'max_retries': 5},
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={},
STATS_EVENTS=events_config,
STATS_AGGREGATIONS=aggregations_config,
))
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 base_app(instance_path):
"""Flask application fixture."""
app_ = Flask('testapp', instance_path=instance_path)
app_.config.update(
SECRET_KEY='SECRET_KEY',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
)
InvenioPIDStore(app_)
InvenioDB(app_)
InvenioPIDRelations(app_)
InvenioRecords(app_)
InvenioIndexer(app_)
InvenioSearch(app_)
Babel(app_)
return app_
def 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",
# SERVER_NAME='localhost:5000',
)
app.url_map.converters['pid'] = PIDConverter
InvenioDB(app)
InvenioPIDStore(app)
InvenioRecords(app)
InvenioAccounts(app)
InvenioAccess(app)
InvenioIndexer(app)
InvenioSearch(app)
InvenioREST(app)
InvenioRecordsREST(app)
InvenioConfigDefault(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(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
TESTING=True,
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
COMMUNITIES_MAIL_ENABLED=False,
SECRET_KEY='CHANGE_ME',
SECURITY_PASSWORD_SALT='CHANGE_ME_ALSO',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SEARCH_ELASTIC_HOSTS=os.environ.get('SEARCH_ELASTIC_HOSTS', None),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
OAISERVER_REGISTER_RECORD_SIGNALS=True,
OAISERVER_REGISTER_SET_SIGNALS=False,
OAISERVER_ID_PREFIX='oai:localhost:recid/',
SERVER_NAME='inveniosoftware.org',
THEME_SITEURL='https://inveniosoftware.org',
MAIL_SUPPRESS_SEND=True,
)
FlaskCeleryExt(app)
Menu(app)
Babel(app)
InvenioDB(app)
InvenioAccounts(app)
InvenioAssets(app)
InvenioSearch(app)
InvenioRecords(app)
InvenioIndexer(app)
InvenioOAIServer(app)
InvenioCommunities(app)
InvenioMail(app)
app.register_blueprint(ui_blueprint)
app.register_blueprint(api_blueprint, url_prefix='/api/communities')
with app.app_context():
yield app
shutil.rmtree(instance_path)
def base_app():
"""Flask applicat-ion fixture."""
instance_path = os.path.join(sys.prefix, 'var', 'tests-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='tests-',
JSONSCHEMAS_HOST='localhost:5000',
SEARCH_ELASTIC_HOSTS=os.environ.get('SEARCH_ELASTIC_HOSTS', None),
PIDSTORE_RECID_FIELD='id',
SUPPORTED_LANGUAGES = ["cs", "en", "it"],
ELASTICSEARCH_DEFAULT_LANGUAGE_TEMPLATE={
"type": "text",
"fields": {
"keywords": {
"type": "keyword"
}
}
}
)
InvenioDB(app_)
InvenioIndexer(app_)
InvenioSearch(app_)
OARepoMultilingualExt(app_)
return 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
OARepoMappingIncludesExt(base_app)
LoginManager(base_app)
search = InvenioSearch(base_app)
search.flush_and_refresh('_all')
Permission(base_app)
InvenioAccess(base_app)
InvenioOAIServer(base_app)
Principal(base_app)
base_app.register_blueprint(
invenio_records_rest.views.create_blueprint_from_app(base_app))
login_manager = LoginManager()
login_manager.init_app(base_app)
login_manager.login_view = 'login'
@login_manager.user_loader
def basic_user_loader(user_id):
user_obj = User.query.get(int(user_id))
return user_obj
@base_app.route('/test/login/<int:id>', methods=['GET', 'POST'])
def test_login(id):
print("test: logging user with id", id)
response = make_response()
user = User.query.get(id)
login_user(user)
set_identity(user)
return response
app_loaded.send(None, app=base_app)
with base_app.app_context():
yield base_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('oai-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:'),
SQLALCHEMY_DATABASE_URI='sqlite://',
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,
CELERY_ALWAYS_EAGER=True,
OAISERVER_RECORDS_INDEX='max21',
OAISERVER_ID_PREFIX='oai:example:',
)
app_.register_blueprint(blueprint)
InvenioDB(app_)
InvenioIndexer(app_)
InvenioSearch(app_)
FlaskCeleryExt(app_)
InvenioOAIServer(app_)
if not hasattr(app_, 'cli'):
ext_cli = FlaskCLI(app_)
return app_
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")
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(env_config, zenodo_config, config, instance_path):
"""Flask application fixture."""
app_ = Flask(__name__, instance_path=instance_path)
app_.config.update(zenodo_config)
app_.config.update(config)
FlaskCeleryExt(app_)
InvenioDB(app_)
InvenioAccounts(app_)
InvenioOAuthClient(app_)
InvenioOAuth2Server(app_)
InvenioRecords(app_)
InvenioIndexer(app_)
InvenioJSONSchemas(app_)
InvenioSearch(app_)
InvenioPIDStore(app_)
ZenodoMigrator(app_)
with app_.app_context():
yield app_
def factory(**config):
app = Flask('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',
SECURITY_PASSWORD_SALT='TEST_SECURITY_PASSWORD_SALT',
SECRET_KEY='TEST_SECRET_KEY',
)
Babel(app)
InvenioDB(app)
InvenioJSONSchemas(app)
InvenioRecords(app)
InvenioSearch(app)
OARepoReferences(app)
return app
def test_load_entry_point_group():
"""Test entry point loading."""
app = Flask('testapp')
ext = InvenioSearch(app)
ep_group = 'test'
def mock_entry_points(group=None):
assert group == ep_group
class ep(object):
name = 'records'
module_name = 'data'
yield ep
assert len(ext.mappings) == 0
with patch('invenio_search.ext.iter_entry_points', mock_entry_points):
ext.load_entry_point_group(entry_point_group=ep_group)
assert len(ext.mappings) == 3
def test_load_entry_point_group(template_entrypoints):
"""Test entry point loading."""
app = Flask("testapp")
ext = InvenioSearch(app)
ep_group = "test"
def mock_entry_points_mappings(group=None):
assert group == ep_group
class ep(object):
name = "records"
module_name = "mock_module.mappings"
yield ep
assert len(ext.mappings) == 0
with patch("invenio_search.ext.iter_entry_points",
mock_entry_points_mappings):
ext.load_entry_point_group_mappings(
entry_point_group_mappings=ep_group)
assert len(ext.mappings) == 3
# Check that mappings are loaded from the correct folder depending on the
# ES version.
if ES_VERSION[0] > 2:
mappings_dir = "mock_module/mappings/v{}/records".format(ES_VERSION[0])
assert all(mappings_dir in path for path in ext.mappings.values())
with patch(
"invenio_search.ext.iter_entry_points",
return_value=template_entrypoints("invenio_search.templates"),
):
if ES_VERSION[0] == 2:
assert set(ext.templates.keys()) == {
"subdirectory-file-download-v1",
"record-view-v1",
}
elif ES_VERSION[0] == 5:
assert set(ext.templates.keys()) == {
"record-view-v{}".format(ES_VERSION[0])
}
def test_bibliographic_data(es_app):
"""Test indexation using bibliographic data."""
search = InvenioSearch(es_app)
search.create()
indexer = RecordIndexer()
with es_app.test_request_context():
data_filename = pkg_resources.resource_filename(
'invenio_records', 'data/marc21/bibliographic.xml')
records_data = load(data_filename)
records = []
for item in records_data:
record = Record.create(item)
record['$schema'] = "mappings/marc21_holdings.json"
es_record = indexer.index(record)
records.append(es_record)
for record in records:
search.client.get(index=record['_index'],
doc_type=record['_type'],
id=record['_id'])
search.delete()
def app(request):
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',
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,
TESTING=True,
)
app.secret_key = 'changeme'
InvenioDB(app)
InvenioRecords(app)
InvenioJSONSchemas(app)
InvenioPIDStore(app)
InvenioSearch(app)
InvenioIndexer(app)
OARepoMappingIncludesExt(app)
app_loaded.send(app, app=app)
with app.app_context():
yield app
# Teardown instance path.
shutil.rmtree(instance_path)
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)
OARepoValidate(base_app)
Actions(base_app)
base_app.url_map.converters['pid'] = PIDConverter
SampleExt(base_app)
OARepoMappingIncludesExt(base_app)
InvenioSearch(base_app)
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 init_app(app_):
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',
ACCOUNTS_JWT_ENABLE=False,
)
Babel(app_)
FlaskCeleryExt(app_)
Breadcrumbs(app_)
OAuth2Provider(app_)
InvenioDB(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
InvenioIndexer(app_)
InvenioJSONSchemas(app_)
InvenioOAuth2Server(app_)
InvenioFilesREST(app_)
InvenioPIDStore(app_)
InvenioRecords(app_)
search = InvenioSearch(app_)
search.register_mappings('deposits', 'invenio_deposit.mappings')
def test_client_reference():
"""Test client reference."""
client1 = {'name': 'client1'}
client2 = {'name': 'client2'}
app1 = Flask('testapp1')
app2 = Flask('testapp2')
ext = InvenioSearch()
assert 'invenio-search' not in app1.extensions
assert 'invenio-search' not in app2.extensions
ext.init_app(app1, client=client1)
assert 'invenio-search' in app1.extensions
ext.init_app(app2, client=client2)
assert 'invenio-search' in app2.extensions
with app1.app_context():
assert current_search_client == client1
with app2.app_context():
assert current_search_client == client2
