def begin(self):
# Add test apps to import path
sys.path.append(
os.path.join(os.path.dirname(os.path.dirname(__file__)), 'tests',
'apps'))
if self.val_disable:
return
# import here so we can avoid test coverage issues
from blazeweb.events import signal
from blazeweb.globals import ag, settings
from blazeweb.hierarchy import findobj
from blazeweb.scripting import load_current_app, UsageError
try:
_, _, _, wsgiapp = load_current_app(self.val_app_name,
self.val_app_profile)
# make the app available to the tests
ag.wsgi_test_app = wsgiapp
# an application can define functions to be called after the app
# is initialized but before any test inspection is done or tests
# are ran. We call those functions here:
for callstring in tolist(settings.testing.init_callables):
tocall = findobj(callstring)
tocall()
# we also support events for pre-test setup
signal('blazeweb.pre_test_init').send()
except UsageError:
if self.val_debug:
raise
self.val_disable = True
def wsgi_app(self, environ, start_response):
log.debug('request received for URL: %s', environ['PATH_INFO'])
with self.request_manager(environ):
signal('blazeweb.request.started').send()
try:
try:
endpoint, args = rg.urladapter.match()
except HTTPException as e:
log.debug('routing HTTP exception %s from %s', e,
rg.request.url)
raise
log.debug('wsgi_app processing %s (%s)', endpoint, args)
response = self.response_cycle(endpoint, args)
except _Redirect as e:
response = e.response
except HTTPException as e:
if not self.settings.http_exception_handling:
raise
response = self.handle_http_exception(e)
except Exception as e:
response = self.handle_exception(e)
# todo: I wonder if this signal send should be called even in the
# case of an exception by putting in a finally block
signal('blazeweb.request.ended').send(response=response)
return response(environ, start_response)
def begin(self):
# Add test apps to import path
sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'tests', 'apps'))
if self.val_disable:
return
# import here so we can avoid test coverage issues
from blazeweb.events import signal
from blazeweb.globals import ag, settings
from blazeweb.hierarchy import findobj
from blazeweb.scripting import load_current_app, UsageError
try:
_, _, _, wsgiapp = load_current_app(self.val_app_name, self.val_app_profile)
# make the app available to the tests
ag.wsgi_test_app = wsgiapp
# an application can define functions to be called after the app
# is initialized but before any test inspection is done or tests
# are ran. We call those functions here:
for callstring in tolist(settings.testing.init_callables):
tocall = findobj(callstring)
tocall()
# we also support events for pre-test setup
signal('blazeweb.pre_test_init').send()
except UsageError:
if self.val_debug:
raise
self.val_disable = True
def response_cycle(self, endpoint, args, error_doc_code=None):
rg.forward_queue = [(endpoint, args)]
while True:
with self.response_context(error_doc_code):
endpoint, args = rg.forward_queue[-1]
signal('blazeweb.response_cycle.started').send(endpoint=endpoint, urlargs=args)
response = self.dispatch_to_endpoint(endpoint, args)
signal('blazeweb.response_cycle.ended').send(response=response)
return response
def response_cycle(self, endpoint, args, error_doc_code=None):
rg.forward_queue = [(endpoint, args)]
while True:
with self.response_context(error_doc_code):
endpoint, args = rg.forward_queue[-1]
signal('blazeweb.response_cycle.started').send(
endpoint=endpoint, urlargs=args)
response = self.dispatch_to_endpoint(endpoint, args)
signal('blazeweb.response_cycle.ended').send(response=response)
return response
def init_auto_actions(self):
# create the writeable directories if they don't exist already
if self.settings.auto_create_writeable_dirs:
mkdirs(self.settings.dirs.data)
mkdirs(self.settings.dirs.logs)
mkdirs(self.settings.dirs.tmp)
# copy static files if requested
if self.settings.auto_copy_static.enabled:
copy_static_files(self.settings.auto_copy_static.delete_existing)
if self.settings.auto_abort_as_builtin is True:
six.moves.builtins.dabort = abort
signal('blazeweb.auto_actions.initialized').connect(clear_old_beaker_sessions)
signal('blazeweb.auto_actions.initialized').send(self.init_auto_actions)
def init_auto_actions(self):
# create the writeable directories if they don't exist already
if self.settings.auto_create_writeable_dirs:
mkdirs(self.settings.dirs.data)
mkdirs(self.settings.dirs.logs)
mkdirs(self.settings.dirs.tmp)
# copy static files if requested
if self.settings.auto_copy_static.enabled:
copy_static_files(self.settings.auto_copy_static.delete_existing)
if self.settings.auto_abort_as_builtin is True:
six.moves.builtins.dabort = abort
signal('blazeweb.auto_actions.initialized').connect(
clear_old_beaker_sessions)
signal('blazeweb.auto_actions.initialized').send(
self.init_auto_actions)
def pytest_configure(config):
from blazeutils import tolist
from blazeweb.events import signal
from blazeweb.globals import ag, settings
from blazeweb.hierarchy import findobj
from blazeweb.scripting import load_current_app
_, _, _, wsgiapp = load_current_app(config.getoption('blazeweb_package'),
config.getoption('blazeweb_profile'))
# make the app available to the tests
ag.wsgi_test_app = wsgiapp
# an application can define functions to be called after the app
# is initialized but before any test inspection is done or tests
# are ran. We call those functions here:
for callstring in tolist(settings.testing.init_callables):
tocall = findobj(callstring)
tocall()
# we also support events for pre-test setup
signal('blazeweb.pre_test_init').send()
def setup_class(cls):
# these lines necessary because we are sharing test space with a Flask
# app built with FlaskSQLAlchemy. That lib places listeners on the
# session class but expects its own code will run to set up a session
SASession._model_changes = mock.Mock()
SASession.app = mock.Mock()
_, _, _, wsgiapp = load_current_app('webgrid_blazeweb_ta', 'Test')
# make the app available to the tests
ag.wsgi_test_app = wsgiapp
# an application can define functions to be called after the app
# is initialized but before any test inspection is done or tests
# are ran. We call those functions here:
for callstring in tolist(settings.testing.init_callables):
tocall = findobj(callstring)
tocall()
# we also support events for pre-test setup
signal('blazeweb.pre_test_init').send()
cls.ta = TestApp(ag.wsgi_test_app)
def setup_class(cls):
# these lines necessary because we are sharing test space with a Flask
# app built with FlaskSQLAlchemy. That lib places listeners on the
# session class but expects its own code will run to set up a session
SASession._model_changes = mock.Mock()
SASession.app = mock.Mock()
_, _, _, wsgiapp = load_current_app('webgrid_blazeweb_ta', 'Test')
# make the app available to the tests
ag.wsgi_test_app = wsgiapp
# an application can define functions to be called after the app
# is initialized but before any test inspection is done or tests
# are ran. We call those functions here:
for callstring in tolist(settings.testing.init_callables):
tocall = findobj(callstring)
tocall()
# we also support events for pre-test setup
signal('blazeweb.pre_test_init').send()
cls.ta = TestApp(ag.wsgi_test_app)
def wsgi_app(self, environ, start_response):
log.debug('request received for URL: %s', environ['PATH_INFO'])
with self.request_manager(environ):
signal('blazeweb.request.started').send()
try:
try:
endpoint, args = rg.urladapter.match()
except HTTPException as e:
log.debug('routing HTTP exception %s from %s', e, rg.request.url)
raise
log.debug('wsgi_app processing %s (%s)', endpoint, args)
response = self.response_cycle(endpoint, args)
except _Redirect as e:
response = e.response
except HTTPException as e:
if not self.settings.http_exception_handling:
raise
response = self.handle_http_exception(e)
except Exception as e:
response = self.handle_exception(e)
# todo: I wonder if this signal send should be called even in the
# case of an exception by putting in a finally block
signal('blazeweb.request.ended').send(response=response)
return response(environ, start_response)
from blazeweb.events import signal
from blazeweb.globals import user
from blazeweb.views import forward
def check_reset_required(sender, endpoint, urlargs):
skip_endpoints = ['auth:ChangePassword', 'auth:Logout']
if user.is_authenticated and user.reset_required and endpoint not in skip_endpoints:
forward('auth:ChangePassword')
signal('blazeweb.response_cycle.started').connect(check_reset_required)
def init_signals(self):
# signals are weakly referenced, so we need to keep a reference as long
# as this application is instantiated
self.signals = (
signal('blazeweb.pre_test_init'),
signal('blazeweb.events.initialized'),
signal('blazeweb.settings.initialized'),
signal('blazeweb.auto_actions.initialized'),
signal('blazeweb.logging.initialized'),
signal('blazeweb.routing.initialized'),
signal('blazeweb.templating.initialized'),
signal('blazeweb.request.started'),
signal('blazeweb.response_cycle.started'),
signal('blazeweb.response_cycle.ended'),
signal('blazeweb.request.ended'),
)
def init_logging(self):
create_handlers_from_settings(self.settings)
signal('blazeweb.logging.initialized').send(self.init_logging)
def init_events(self):
visitmods('events')
signal('blazeweb.events.initialized').send(self.init_events)
def init_logging(self):
create_handlers_from_settings(self.settings)
signal('blazeweb.logging.initialized').send(self.init_logging)
def init_events(self):
visitmods('events')
signal('blazeweb.events.initialized').send(self.init_events)
def init_signals(self):
# signals are weakly referenced, so we need to keep a reference as long
# as this application is instantiated
self.signals = (
signal('blazeweb.pre_test_init'),
signal('blazeweb.events.initialized'),
signal('blazeweb.settings.initialized'),
signal('blazeweb.auto_actions.initialized'),
signal('blazeweb.logging.initialized'),
signal('blazeweb.routing.initialized'),
signal('blazeweb.templating.initialized'),
signal('blazeweb.request.started'),
signal('blazeweb.response_cycle.started'),
signal('blazeweb.response_cycle.ended'),
signal('blazeweb.request.ended'),
)
def init_events(self):
global called
visitmods('events')
called = signal('blazeweb.events.initialized').send(self.init_events)
from blazeweb.events import signal
from blazeweb.globals import settings
from blazeweb.tasks import run_tasks
def setup_db_structure(sender):
if settings.components.sqlalchemy.pre_test_init_tasks:
run_tasks(settings.components.sqlalchemy.pre_test_init_tasks)
signal('blazeweb.pre_test_init').connect(setup_db_structure)
def clear_old_beaker_sessions(sender):
# clear up old beaker sessions, if needed
if (
settings.beaker.enabled and
settings.beaker.auto_clear_sessions and
settings.beaker.type == 'ext:database'
):
import datetime as dt
import sqlalchemy as sa
table_name = getattr(settings.beaker, 'table_name', 'beaker_cache')
try:
sessions_table = sa.Table(
table_name,
sa.MetaData(settings.beaker.url),
autoload=True
)
sessions_table.delete(
sessions_table.c.accessed < (
from blazeweb.globals import rg
from blazeweb.events import signal
from blazeweb.utils import redirect
from blazeweb.views import forward
def fire_after_event_init(sender):
return 'newlayout'
signal('blazeweb.events.initialized').connect(fire_after_event_init)
def modify_response(sender, response=None):
if 'eventtest' in rg.request.url:
response.data = response.data + b'newlayout'
signal('blazeweb.response_cycle.ended').connect(modify_response)
def send_to_index(sender, endpoint, urlargs):
"""
simulating hijacking the request and forcing it to go to another view.
This minicks what you would want to do if a user need to change a password,
was locked out, or any number of things that might cause you to want to
send them to a different location than the one they are requesting.
"""
if 'request-hijack/forward' in rg.request.url:
# we have to have a flag that says we have already forwarded, otherwise
# we will get a forward loop since the request isn't modified
# when we forward
if getattr(rg, 'newlayout_events_send_to_index', None):
return
rg.newlayout_events_send_to_index = True
from blazeweb.globals import rg
from blazeweb.events import signal
from blazeweb.utils import redirect
from blazeweb.views import forward
def fire_after_event_init(sender):
return 'newlayout'
signal('blazeweb.events.initialized').connect(fire_after_event_init)
def modify_response(sender, response=None):
if 'eventtest' in rg.request.url:
response.data = response.data + b'newlayout'
signal('blazeweb.response_cycle.ended').connect(modify_response)
def send_to_index(sender, endpoint, urlargs):
"""
simulating hijacking the request and forcing it to go to another view.
This minicks what you would want to do if a user need to change a password,
was locked out, or any number of things that might cause you to want to
send them to a different location than the one they are requesting.
"""
if 'request-hijack/forward' in rg.request.url:
# we have to have a flag that says we have already forwarded, otherwise
# we will get a forward loop since the request isn't modified
# when we forward
if getattr(rg, 'newlayout_events_send_to_index', None):
return
rg.newlayout_events_send_to_index = True
