def test_init():
"""Test extension initialization."""
app = Flask('testapp')
ext = InvenioOAuth2Server(app)
assert 'invenio-oauth2server' in app.extensions
app = Flask('testapp')
ext = InvenioOAuth2Server()
assert 'invenio-oauth2server' not in app.extensions
ext.init_app(app)
assert 'invenio-oauth2server' in app.extensions
def test_admin(models_fixture):
"""Test flask-admin interface."""
app = models_fixture
InvenioOAuth2Server(app)
assert isinstance(oauth2server_tokens_adminview, dict)
assert isinstance(oauth2server_clients_adminview, dict)
assert 'view_class' in oauth2server_tokens_adminview
assert 'view_class' in oauth2server_clients_adminview
admin = Admin(app, name="Test")
clients_view = oauth2server_clients_adminview.pop('view_class')
clients_model, clients_session = oauth2server_clients_adminview.pop('args')
clients_kwargs = oauth2server_clients_adminview.pop('kwargs')
tokens_view = oauth2server_tokens_adminview.pop('view_class')
tokens_model, tokens_session = oauth2server_tokens_adminview.pop('args')
tokens_kwargs = oauth2server_tokens_adminview.pop('kwargs')
admin.add_view(clients_view(clients_model, db.session, **clients_kwargs))
admin.add_view(tokens_view(tokens_model, db.session, **tokens_kwargs))
menu_items = {str(item.name): item for item in admin.menu()}
assert 'User Management' in menu_items
assert menu_items['User Management'].is_category()
submenu_items = {
str(item.name): item
for item in menu_items['User Management'].get_children()
}
assert 'OAuth Applications' in submenu_items
assert 'OAuth Application Tokens' in submenu_items
with app.test_request_context():
token_request_url = url_for('token.index_view')
client_request_url = url_for('client.index_view')
client_view_url = url_for('invenio_oauth2server_settings.client_view',
client_id='client_test_u1c1')
client_reset_url = url_for(
'invenio_oauth2server_settings.client_reset',
client_id='client_test_u1c1')
token_view_url = url_for('invenio_oauth2server_settings.token_view',
token_id='1')
token_revoke_url = url_for(
'invenio_oauth2server_settings.token_revoke', token_id='1')
with app.app_context():
with app.test_client() as client:
res = client.get(token_request_url, follow_redirects=True)
assert res.status_code == 200
res = client.get(client_request_url, follow_redirects=True)
assert res.status_code == 200
res = client.get(client_view_url, follow_redirects=True)
assert res.status_code == 200
res = client.post(client_reset_url, follow_redirects=True)
assert res.status_code == 200
res = client.get(token_view_url, follow_redirects=True)
assert res.status_code == 200
res = client.post(token_revoke_url, follow_redirects=True)
assert res.status_code == 405
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
# HTTPretty doesn't play well with Redis.
# See gabrielfalcao/HTTPretty#110
CACHE_TYPE='simple',
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND='cache',
GITHUB_SHIELDSIO_BASE_URL='http://example.org/badge/',
GITHUB_APP_CREDENTIALS=dict(
consumer_key='changeme',
consumer_secret='changeme',
),
LOGIN_DISABLED=False,
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE='simple',
OAUTHCLIENT_REMOTE_APPS=dict(
github=REMOTE_APP,
),
SECRET_KEY='test_key',
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
TESTING=True,
WTF_CSRF_ENABLED=False,
)
app.url_map.converters['pid'] = PIDConverter
FlaskCLI(app)
celeryext = FlaskCeleryExt(app)
celeryext.celery.flask_app = app # Make sure both apps are the same!
Babel(app)
Mail(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioAccounts(app)
app.register_blueprint(accounts_blueprint)
InvenioOAuthClient(app)
app.register_blueprint(oauthclient_blueprint)
InvenioOAuth2Server(app)
app.register_blueprint(server_blueprint)
app.register_blueprint(settings_blueprint)
InvenioPIDStore(app)
InvenioRecordsREST(app)
InvenioDepositREST(app)
InvenioWebhooks(app)
app.register_blueprint(webhooks_blueprint)
InvenioGitHub(app)
with app.app_context():
yield app
shutil.rmtree(instance_path)
def init_app(app):
app.config.update(
DB_VERSIONING=True,
LOGIN_DISABLED=False,
MAIL_SUPPRESS_SEND=True,
OAUTH2_CACHE_TYPE='simple',
OAUTHLIB_INSECURE_TRANSPORT=True,
SECRET_KEY='CHANGE_ME',
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SALT='CHANGE_ME_ALSO',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
SQLALCHEMY_DATABASE_URI=os.getenv(
'SQLALCHEMY_DATABASE_URI',
'sqlite:///' + os.path.join(instance_path, 'test.db')),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
WTF_CSRF_ENABLED=False,
)
Babel(app)
Mail(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioOAuth2Server(app)
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():
"""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):
"""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(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
ACCOUNTS_JWT_ENABLE=False,
BROKER_TRANSPORT='redis',
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND='cache',
CELERY_TRACK_STARTED=True,
LOGIN_DISABLED=False,
OAUTH2_CACHE_TYPE='simple',
OAUTHLIB_INSECURE_TRANSPORT=True,
SECRET_KEY='test_key',
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
TESTING=True,
WTF_CSRF_ENABLED=False,
)
celeryext = FlaskCeleryExt(app)
celeryext.celery.flask_app = app # Make sure both apps are the same!
Babel(app)
Mail(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioAccounts(app)
app.register_blueprint(accounts_blueprint)
InvenioOAuth2Server(app)
InvenioOAuth2ServerREST(app)
app.register_blueprint(server_blueprint)
app.register_blueprint(settings_blueprint)
InvenioWebhooks(app)
app.register_blueprint(blueprint)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
request.addfinalizer(teardown)
return app
def app(base_app):
"""Flask full application fixture."""
Breadcrumbs(base_app)
InvenioDB(base_app)
InvenioAccess(base_app)
InvenioAccounts(base_app)
InvenioFilesREST(base_app)
InvenioOAuth2Server(base_app)
InvenioOAuth2ServerREST(base_app)
InvenioREST(base_app)
InvenioSIPStore(base_app)
base_app.register_blueprint(server_blueprint)
base_app.register_blueprint(blueprint)
with base_app.app_context():
yield base_app
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 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 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 app(request):
"""Flask application fixture."""
app = Flask('testapp')
app.config.update(
TESTING=True,
LOGIN_DISABLED=False,
SECRET_KEY='test_key',
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
WTF_CSRF_ENABLED=False,
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE='simple',
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
)
FlaskCLI(app)
Babel(app)
Mail(app)
Menu(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioAccounts(app)
app.register_blueprint(accounts_blueprint)
InvenioOAuth2Server(app)
app.register_blueprint(server_blueprint)
app.register_blueprint(settings_blueprint)
with app.app_context():
db.create_all()
def teardown():
with app.app_context():
db.drop_all()
request.addfinalizer(teardown)
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app_ = Flask('testapp', instance_path=instance_path)
app_.config.update(
# HTTPretty doesn't play well with Redis.
# See gabrielfalcao/HTTPretty#110
CACHE_TYPE='simple',
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND='cache',
GITHUB_APP_CREDENTIALS=dict(
consumer_key='changeme',
consumer_secret='changeme',
),
GITHUB_PID_FETCHER='doi_fetcher',
LOGIN_DISABLED=False,
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE='simple',
OAUTHCLIENT_REMOTE_APPS=dict(github=REMOTE_APP, ),
SECRET_KEY='test_key',
SERVER_NAME='testserver',
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
TESTING=True,
WTF_CSRF_ENABLED=False,
)
app_.config['OAUTHCLIENT_REMOTE_APPS']['github']['params'][
'request_token_params'][
'scope'] = 'user:email,admin:repo_hook,read:org'
app_.url_map.converters['pid'] = PIDConverter
celeryext = FlaskCeleryExt(app_)
Babel(app_)
Mail(app_)
Menu(app_)
Breadcrumbs(app_)
InvenioAssets(app_)
InvenioDB(app_)
InvenioAccounts(app_)
app_.register_blueprint(accounts_blueprint)
InvenioOAuthClient(app_)
app_.register_blueprint(oauthclient_blueprint)
InvenioOAuth2Server(app_)
app_.register_blueprint(server_blueprint)
app_.register_blueprint(settings_blueprint)
InvenioFormatter(app_)
from .helpers import doi_fetcher
pidstore = InvenioPIDStore(app_)
pidstore.register_fetcher('doi_fetcher', doi_fetcher)
InvenioJSONSchemas(app_)
InvenioRecords(app_)
InvenioSearch(app_)
InvenioIndexer(app_)
InvenioFilesREST(app_)
InvenioRecordsREST(app_)
InvenioDepositREST(app_)
InvenioWebhooks(app_)
celeryext.celery.flask_app = app_ # Make sure both apps are the same!
app_.register_blueprint(webhooks_blueprint)
InvenioGitHub(app_)
app_.register_blueprint(github_blueprint)
app_.register_blueprint(github_badge_blueprint)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def app(request, accounts_rest_permission_factory):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app = Flask(__name__, instance_path=instance_path)
InvenioAccess(app)
InvenioAccounts(app)
InvenioAccountsREST(app)
InvenioOAuth2Server(app)
InvenioOAuth2ServerREST(app)
InvenioDB(app)
Babel(app)
Mail(app)
Menu(app)
Breadcrumbs(app)
# this is done mainly for coverage so that tests are run with and without
# userprofiles being loaded in the app
if not hasattr(request, 'param') or \
'with_profiles' not in request.param or \
request.param['with_profiles']:
# tests without invenio-userprofiles being installed at all
try:
from invenio_userprofiles import InvenioUserProfiles
InvenioUserProfiles(app)
except ImportError:
pass
read_role = accounts_rest_permission_factory['read_role']
update_role = accounts_rest_permission_factory['update_role']
delete_role = accounts_rest_permission_factory['delete_role']
read_roles = accounts_rest_permission_factory['read_roles_list']
create_role = accounts_rest_permission_factory['create_role']
assign_role = accounts_rest_permission_factory['assign_role']
unassign_role = accounts_rest_permission_factory['unassign_role']
role_users = accounts_rest_permission_factory['read_role_users_list']
user_roles = accounts_rest_permission_factory['read_user_roles_list']
read_user_prop = accounts_rest_permission_factory['read_user_properties']
mod_user_prop = accounts_rest_permission_factory['update_user_properties']
read_users = accounts_rest_permission_factory['read_users_list']
app.config.update(
ACCOUNTS_REST_READ_ROLE_PERMISSION_FACTORY=read_role,
ACCOUNTS_REST_UPDATE_ROLE_PERMISSION_FACTORY=update_role,
ACCOUNTS_REST_DELETE_ROLE_PERMISSION_FACTORY=delete_role,
ACCOUNTS_REST_READ_ROLES_LIST_PERMISSION_FACTORY=read_roles,
ACCOUNTS_REST_CREATE_ROLE_PERMISSION_FACTORY=create_role,
ACCOUNTS_REST_ASSIGN_ROLE_PERMISSION_FACTORY=assign_role,
ACCOUNTS_REST_UNASSIGN_ROLE_PERMISSION_FACTORY=unassign_role,
ACCOUNTS_REST_READ_ROLE_USERS_LIST_PERMISSION_FACTORY=role_users,
ACCOUNTS_REST_READ_USER_ROLES_LIST_PERMISSION_FACTORY=user_roles,
ACCOUNTS_REST_READ_USER_PROPERTIES_PERMISSION_FACTORY=read_user_prop,
ACCOUNTS_REST_UPDATE_USER_PROPERTIES_PERMISSION_FACTORY=mod_user_prop,
ACCOUNTS_REST_READ_USERS_LIST_PERMISSION_FACTORY=read_users,
OAUTH2SERVER_CLIENT_ID_SALT_LEN=40,
OAUTH2SERVER_CLIENT_SECRET_SALT_LEN=60,
OAUTH2SERVER_TOKEN_PERSONAL_SALT_LEN=60,
SECRET_KEY='changeme',
TESTING=True,
SERVER_NAME='localhost',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SECURITY_SEND_PASSWORD_CHANGE_EMAIL=False)
from invenio_oauth2server.views.server import blueprint
with app.app_context():
db_.create_all()
yield app
with app.app_context():
db_.drop_all()
])
InvenioDB(app)
InvenioTheme(app)
InvenioJSONSchemas(app)
InvenioAccounts(app)
InvenioRecords(app)
InvenioRecordsUI(app)
search = InvenioSearch(app)
# search.register_mappings('testrecords', 'data')
InvenioSearchUI(app)
InvenioREST(app)
InvenioIndexer(app)
InvenioPIDStore(app)
InvenioAdmin(app)
InvenioOAuth2Server(app)
InvenioRecordsREST(app)
InvenioFilesREST(app)
assets = InvenioAssets(app)
assets.env.register('invenio_search_ui_search_js', js)
InvenioDeposit(app)
InvenioDepositREST(app)
app.register_blueprint(accounts_blueprint)
app.register_blueprint(settings_blueprint)
app.register_blueprint(server_blueprint)
