def setUp(self):
super(TestAPICompatUserClass, self).setUp()
self.log = logging.getLogger(__name__)
self.logstore = init_timescale_connection(
self.log, {
'REDIS_HOST': config.REDIS_HOST,
'REDIS_PORT': config.REDIS_PORT,
'REDIS_NAMESPACE': config.REDIS_NAMESPACE,
'SQLALCHEMY_TIMESCALE_URI': config.SQLALCHEMY_TIMESCALE_URI
})
# Create a user
uid = db_user.create(1, "test_api_compat_user")
self.assertIsNotNone(db_user.get(uid))
with db.engine.connect() as connection:
result = connection.execute(
text("""
SELECT *
FROM "user"
WHERE id = :id
"""), {
"id": uid,
})
row = result.fetchone()
self.user = User(row['id'], row['created'], row['musicbrainz_id'],
row['auth_token'])
def create_timescale(app):
from listenbrainz.webserver.timescale_connection import init_timescale_connection
return init_timescale_connection(app.logger, {
'SQLALCHEMY_TIMESCALE_URI': app.config['SQLALCHEMY_TIMESCALE_URI'],
'REDIS_HOST': app.config['REDIS_HOST'],
'REDIS_PORT': app.config['REDIS_PORT'],
'REDIS_NAMESPACE': app.config['REDIS_NAMESPACE'],
'LISTEN_DUMP_TEMP_DIR_ROOT': app.config['LISTEN_DUMP_TEMP_DIR_ROOT'],
})
def setUp(self):
super(APICompatDeprecatedTestCase, self).setUp()
self.user = db_user.get_or_create(1, 'apicompatoldtestuser')
self.log = logging.getLogger(__name__)
self.ls = init_timescale_connection(
self.log, {
'REDIS_HOST': config.REDIS_HOST,
'REDIS_PORT': config.REDIS_PORT,
'REDIS_NAMESPACE': config.REDIS_NAMESPACE,
'SQLALCHEMY_TIMESCALE_URI': config.SQLALCHEMY_TIMESCALE_URI,
})
def setUp(self):
super().setUp()
self.app = create_app()
self.tempdir = tempfile.mkdtemp()
self.runner = CliRunner()
self.listenstore = init_timescale_connection(logging.getLogger(__name__), {
'REDIS_HOST': self.app.config['REDIS_HOST'],
'REDIS_PORT': self.app.config['REDIS_PORT'],
'REDIS_NAMESPACE': self.app.config['REDIS_NAMESPACE'],
'SQLALCHEMY_TIMESCALE_URI': self.app.config['SQLALCHEMY_TIMESCALE_URI']
})
self.user_id = db_user.create(1, 'iliekcomputers')
self.user_name = db_user.get(self.user_id)['musicbrainz_id']
def setUp(self):
super(TestTimescaleListenStore, self).setUp()
self.log = logging.getLogger(__name__)
self.reset_timescale_db()
self.ns = config.REDIS_NAMESPACE
self.logstore = init_timescale_connection(self.log, {
'REDIS_HOST': config.REDIS_HOST,
'REDIS_PORT': config.REDIS_PORT,
'REDIS_NAMESPACE': config.REDIS_NAMESPACE,
'SQLALCHEMY_TIMESCALE_URI': config.SQLALCHEMY_TIMESCALE_URI,
})
self.testuser_id = db_user.create(1, "test")
self.testuser_name = db_user.get(self.testuser_id)['musicbrainz_id']
def setUp(self):
super(APICompatTestCase, self).setUp()
self.lb_user = db_user.get_or_create(1, 'apicompattestuser')
self.lfm_user = User(
self.lb_user['id'],
self.lb_user['created'],
self.lb_user['musicbrainz_id'],
self.lb_user['auth_token'],
)
self.log = logging.getLogger(__name__)
self.ls = init_timescale_connection(
self.log, {
'REDIS_HOST': config.REDIS_HOST,
'REDIS_PORT': config.REDIS_PORT,
'REDIS_NAMESPACE': config.REDIS_NAMESPACE,
'SQLALCHEMY_TIMESCALE_URI': config.SQLALCHEMY_TIMESCALE_URI,
})
def setUp(self):
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.log = logging.getLogger(__name__)
self.logstore = init_timescale_connection(self.log, {
'REDIS_HOST': current_app.config['REDIS_HOST'],
'REDIS_PORT': current_app.config['REDIS_PORT'],
'REDIS_NAMESPACE': current_app.config['REDIS_NAMESPACE'],
'SQLALCHEMY_TIMESCALE_URI': self.app.config['SQLALCHEMY_TIMESCALE_URI']
})
user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(user['musicbrainz_id'])
self.user = User.from_dbrow(user)
weirduser = db_user.get_or_create(2, 'weird\\user name')
self.weirduser = User.from_dbrow(weirduser)
def create_app(debug=None):
""" Generate a Flask app for LB with all configurations done and connections established.
In the Flask app returned, blueprints are not registered.
"""
app = CustomFlask(
import_name=__name__,
use_flask_uuid=True,
)
load_config(app)
if debug is not None:
app.debug = debug
# As early as possible, if debug is True, set the log level of our 'listenbrainz' logger to DEBUG
# to prevent flask from creating a new log handler
if app.debug:
logger = logging.getLogger('listenbrainz')
logger.setLevel(logging.DEBUG)
# initialize Flask-DebugToolbar if the debug option is True
if app.debug and app.config['SECRET_KEY']:
app.init_debug_toolbar()
sentry_config = app.config.get('LOG_SENTRY')
if sentry_config:
sentry.init_sentry(**sentry_config)
# Initialize BU cache and metrics
cache.init(host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
namespace=app.config['REDIS_NAMESPACE'])
metrics.init("listenbrainz")
# Database connections
from listenbrainz import db
from listenbrainz.db import timescale as ts
from listenbrainz import messybrainz as msb
db.init_db_connection(app.config['SQLALCHEMY_DATABASE_URI'])
ts.init_db_connection(app.config['SQLALCHEMY_TIMESCALE_URI'])
msb.init_db_connection(app.config['MESSYBRAINZ_SQLALCHEMY_DATABASE_URI'])
# Redis connection
from listenbrainz.webserver.redis_connection import init_redis_connection
init_redis_connection(app.logger)
# Timescale connection
from listenbrainz.webserver.timescale_connection import init_timescale_connection
init_timescale_connection(app)
# RabbitMQ connection
from listenbrainz.webserver.rabbitmq_connection import init_rabbitmq_connection
try:
init_rabbitmq_connection(app)
except ConnectionError:
app.logger.critical("RabbitMQ service is not up!", exc_info=True)
if app.config['MB_DATABASE_URI']:
from brainzutils import musicbrainz_db
musicbrainz_db.init_db_engine(app.config['MB_DATABASE_URI'])
# OAuth
from listenbrainz.webserver.login import login_manager, provider
login_manager.init_app(app)
provider.init(app.config['MUSICBRAINZ_CLIENT_ID'],
app.config['MUSICBRAINZ_CLIENT_SECRET'])
# Error handling
from listenbrainz.webserver.errors import init_error_handlers
init_error_handlers(app)
from brainzutils.ratelimit import inject_x_rate_headers, set_user_validation_function
set_user_validation_function(check_ratelimit_token_whitelist)
@app.after_request
def after_request_callbacks(response):
return inject_x_rate_headers(response)
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from listenbrainz.webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
return app
