def test_init():
"""Test extension initialization."""
app = Flask('testapp')
ext = InvenioIndexer(app)
assert 'invenio-indexer' in app.extensions
app = Flask('testapp')
ext = InvenioIndexer()
assert 'invenio-indexer' not in app.extensions
ext.init_app(app)
assert 'invenio-indexer' in app.extensions
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 test_percolator(app, request):
"""Test percolator."""
def teardown():
with app.app_context():
current_collections.unregister_signals()
list(current_search.delete())
request.addfinalizer(teardown)
with app.test_request_context():
app.config.update(
COLLECTIONS_USE_PERCOLATOR=True,
SEARCH_ELASTIC_KEYWORD_MAPPING={None: ['_all']},
)
search = InvenioSearch(app)
search.register_mappings('records', 'data')
InvenioIndexer(app)
current_collections.unregister_signals()
current_collections.register_signals()
list(current_search.create())
_try_populate_collections()
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 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 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."""
# 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 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-records-draft-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))
app.test_client_class = JsonClient
InvenioDB(app_)
InvenioIndexer(app_)
InvenioSearch(app_)
print('records draft registered to app')
InvenioRecordsDraft(app_)
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 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 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():
"""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 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):
"""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 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(od_licenses_json):
"""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)
InvenioIndexer(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))
# MySQL has case-sensitivity issues with its default collation. To fix
# this, we alter the created database's charset and collation.
if str(db.engine.url).startswith('mysql'):
conn = db.engine.connect()
conn.execute('COMMIT') # close the current transaction
conn.execute('ALTER DATABASE invenio '
'CHARACTER SET utf8 COLLATE utf8_bin')
conn.close()
db.drop_all()
db.create_all()
def teardown():
drop_database(str(db.engine.url))
yield app
shutil.rmtree(instance_path)
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 test_init():
"""Test extension initialization."""
app = Flask('testapp')
ext = InvenioIndexer(app)
assert 'invenio-indexer' in app.extensions
app = Flask('testapp')
ext = InvenioIndexer()
assert 'invenio-indexer' not in app.extensions
ext.init_app(app)
assert 'invenio-indexer' in app.extensions
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):
"""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 test_hook_initialization(base_app):
"""Test hook initialization."""
app = base_app
magic_hook = MagicMock()
app.config['INDEXER_BEFORE_INDEX_HOOKS'] = [
magic_hook, 'test_invenio_indexer:_global_magic_hook'
]
ext = InvenioIndexer(app)
with app.app_context():
recid = uuid.uuid4()
record = Record.create({'title': 'Test'}, id_=recid)
db.session.commit()
client_mock = MagicMock()
RecordIndexer(search_client=client_mock,
version_type='force').index(record)
args = (app, )
doc_type = app.config['INDEXER_DEFAULT_DOC_TYPE'] if lt_es7 else '_doc'
kwargs = dict(
index=app.config['INDEXER_DEFAULT_INDEX'],
doc_type=doc_type,
arguments={},
record=record,
json={
'title': 'Test',
'_created': pytz.utc.localize(record.created).isoformat(),
'_updated': pytz.utc.localize(record.updated).isoformat(),
},
)
magic_hook.assert_called_with(*args, **kwargs)
_global_magic_hook.assert_called_with(*args, **kwargs)
client_mock.index.assert_called_with(
id=str(recid),
version=0,
version_type='force',
index=app.config['INDEXER_DEFAULT_INDEX'],
doc_type=doc_type,
body={
'title': 'Test',
'_created': pytz.utc.localize(record.created).isoformat(),
'_updated': pytz.utc.localize(record.updated).isoformat(),
},
)
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 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 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 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 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 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 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 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')
