def callback_app(simple_resource):
app = App()
app.add_route('/', simple_resource)
app.add_route('/sse', simple_resource, suffix='sse')
app.add_route('/stream', simple_resource, suffix='stream')
return app
def test_startup_only():
class Foo:
async def process_startup(self, scope, event):
self._called = True
foo = Foo()
app = App()
app.add_middleware(foo)
client = testing.TestClient(app)
client.simulate_get()
assert foo._called
def _call_with_scope(scope):
app = App()
resource = testing.SimpleTestResourceAsync()
app.add_route('/', resource)
req_event_emitter = testing.ASGIRequestEventEmitter()
resp_event_collector = testing.ASGIResponseEventCollector()
falcon.invoke_coroutine_sync(app.__call__, scope, req_event_emitter,
resp_event_collector)
assert resource.called
return resource
def test_lifespan_scope_version(spec_version, supported):
app = App()
shutting_down = asyncio.Condition()
req_event_emitter = testing.ASGILifespanEventEmitter(shutting_down)
resp_event_collector = testing.ASGIResponseEventCollector()
scope = {
'type': 'lifespan',
'asgi': {'spec_version': spec_version, 'version': '3.0'}
}
if not supported:
with pytest.raises(UnsupportedScopeError):
falcon.async_to_sync(
app.__call__, scope, req_event_emitter, resp_event_collector
)
return
async def t():
t = asyncio.get_event_loop().create_task(
app(scope, req_event_emitter, resp_event_collector)
)
# NOTE(kgriffs): Yield to the lifespan task above
await asyncio.sleep(0.001)
async with shutting_down:
shutting_down.notify()
await t
falcon.async_to_sync(t)
def client(self):
class SomeResource:
async def on_get(self, req, resp):
async def emitter():
yield SSEvent(json={'foo': 'bar'})
yield SSEvent(json={'bar': 'baz'})
resp.sse = emitter()
resource = SomeResource()
app = App()
app.add_route('/', resource)
client = testing.TestClient(app)
return client
def test_multiple_events():
class SomeResource:
async def on_get(self, req, resp):
async def emitter():
yield SSEvent(data=b'ketchup')
yield SSEvent(data=b'mustard', event='condiment')
yield SSEvent(data=b'mayo', event='condiment', event_id='1234')
yield SSEvent(data=b'onions',
event='topping',
event_id='5678',
retry=100)
yield SSEvent(text='guacamole \u1F951',
retry=100,
comment='Serve with chips.')
yield SSEvent(json={'condiment': 'salsa'}, retry=100)
resp.sse = emitter()
resource = SomeResource()
app = App()
app.add_route('/', resource)
client = testing.TestClient(app)
result = client.simulate_get()
assert result.text == ('data: ketchup\n'
'\n'
'event: condiment\n'
'data: mustard\n'
'\n'
'event: condiment\n'
'id: 1234\n'
'data: mayo\n'
'\n'
'event: topping\n'
'id: 5678\n'
'retry: 100\n'
'data: onions\n'
'\n'
': Serve with chips.\n'
'retry: 100\n'
'data: guacamole \u1F951\n'
'\n'
'retry: 100\n'
'data: {"condiment": "salsa"}\n'
'\n')
def test_non_iterable():
class SomeResource:
async def on_get(self, req, resp):
async def emitter():
yield
resp.sse = emitter
resource = SomeResource()
app = App()
app.add_route('/', resource)
client = testing.TestClient(app)
with pytest.raises(TypeError):
client.simulate_get()
def test_mw_methods_must_be_coroutines():
class MiddlewareA:
def process_resource_ws(self, req, ws, resource, params):
pass
class MiddlewareB:
def process_request_ws(self, req, ws):
pass
app = App()
for mw in [MiddlewareA(), MiddlewareB()]:
with pytest.raises(falcon.CompatibilityError):
app.add_middleware(mw)
with pytest.raises(falcon.CompatibilityError):
App(middleware=mw)
def create_app(asgi, **app_kwargs):
if asgi:
skipif_asgi_unsupported()
from falcon.asgi import App
else:
from falcon import App
app = App(**app_kwargs)
return app
def test_supported_asgi_version(version, supported):
scope = {
'type': 'lifespan',
'asgi': {
'spec_version': '2.0',
'version': version
},
}
if version is None:
del scope['asgi']['version']
app = App()
resource = testing.SimpleTestResourceAsync()
app.add_route('/', resource)
shutting_down = asyncio.Condition()
req_event_emitter = testing.ASGILifespanEventEmitter(shutting_down)
resp_event_collector = testing.ASGIResponseEventCollector()
async def task():
coro = asyncio.get_event_loop().create_task(
app(scope, req_event_emitter, resp_event_collector))
# NOTE(vytas): Yield to the lifespan task above.
await asyncio.sleep(0)
assert len(resp_event_collector.events) == 1
event = resp_event_collector.events[0]
if supported:
assert event['type'] == 'lifespan.startup.complete'
else:
assert event['type'] == 'lifespan.startup.failed'
assert event['message'].startswith(
'Falcon requires ASGI version 3.x')
async with shutting_down:
shutting_down.notify()
await coro
falcon.async_to_sync(task)
async def test_missing_spec_version():
app = App()
scope = testing.create_scope_ws()
del scope['asgi']['spec_version']
ws = testing.ASGIWebSocketSimulator()
# NOTE(kgriffs): As long as this does not raise, we know the spec
# version defaulted OK.
await app(scope, ws._emit, ws._collect)
def test_multiple_events_early_disconnect():
class SomeResource:
async def on_get(self, req, resp):
async def emitter():
while True:
yield SSEvent(data=b'whassup')
await asyncio.sleep(0.01)
resp.sse = emitter()
resource = SomeResource()
app = App()
app.add_route('/', resource)
async def _test():
conductor = testing.ASGIConductor(app)
result = await conductor.simulate_get()
assert 'data: whassup' in result.text
async with testing.ASGIConductor(app) as conductor:
# NOTE(vytas): Using the get_stream() alias.
async with conductor.get_stream() as sr:
event_count = 0
result_text = ''
while event_count < 5:
chunk = (await sr.stream.read()).decode()
if not chunk:
continue
result_text += chunk
event_count += len(chunk.strip().split('\n\n'))
assert result_text.startswith('data: whassup\n\n' * 5)
assert event_count == 5
falcon.async_to_sync(_test)
def test_startup_raises():
class Foo:
def __init__(self):
self._shutdown_called = False
async def process_startup(self, scope, event):
raise Exception('testing 123')
async def process_shutdown(self, scope, event):
self._shutdown_called = True
class Bar:
def __init__(self):
self._startup_called = False
self._shutdown_called = False
async def process_startup(self, scope, event):
self._startup_called = True
async def process_shutdown(self, scope, event):
self._shutdown_called = True
foo = Foo()
bar = Bar()
app = App()
app.add_middleware([foo, bar])
client = testing.TestClient(app)
with pytest.raises(RuntimeError) as excinfo:
client.simulate_get()
message = str(excinfo.value)
assert message.startswith('ASGI app returned lifespan.startup.failed.')
assert 'testing 123' in message
assert not foo._shutdown_called
assert not bar._startup_called
assert not bar._shutdown_called
def test_no_events():
class Emitter:
def __aiter__(self):
return self
async def __anext__(self):
raise StopAsyncIteration
class SomeResource:
async def on_get(self, req, resp):
self._called = True
resp.sse = Emitter()
resource = SomeResource()
app = App()
app.add_route('/', resource)
client = testing.TestClient(app)
client.simulate_get()
assert resource._called
def test_shutdown_raises():
class HandlerA:
def __init__(self):
self._startup_called = False
async def process_startup(self, scope, event):
self._startup_called = True
async def process_shutdown(self, scope, event):
raise Exception('testing 321')
class HandlerB:
def __init__(self):
self._startup_called = False
self._shutdown_called = False
async def process_startup(self, scope, event):
self._startup_called = True
async def process_shutdown(self, scope, event):
self._shutdown_called = True
a = HandlerA()
b1 = HandlerB()
b2 = HandlerB()
app = App()
app.add_middleware(b1)
app.add_middleware([a, b2])
client = testing.TestClient(app)
with pytest.raises(RuntimeError) as excinfo:
client.simulate_get()
message = str(excinfo.value)
assert message.startswith('ASGI app returned lifespan.shutdown.failed.')
assert 'testing 321' in message
assert a._startup_called
assert b1._startup_called
assert not b1._shutdown_called
assert b2._startup_called
assert b2._shutdown_called
async def test_bad_first_event():
app = App()
scope = testing.create_scope_ws()
del scope['asgi']['spec_version']
ws = testing.ASGIWebSocketSimulator()
wrapped_emit = ws._emit
async def _emit():
if ws._state == ClientWebSocketState.CONNECT:
ws._state = ClientWebSocketState.HANDSHAKE
return {'type': EventType.WS_SEND}
return await wrapped_emit(ws)
ws._emit = _emit
# NOTE(kgriffs): If there is a bad first event, the framework should
# just bail out early and close the request...
await app(scope, ws._emit, ws._collect)
assert ws.closed
assert ws.close_code == CloseCode.SERVER_ERROR
"""Configures the main Falcon app and routes
`app` is hoisted to the main application; e.g.:
from application import app
"""
from falcon.asgi import App
from . import views
from .environment import settings
from .middleware.sqlalchemy import SQLAlchemySessionManager
from .middleware.firebase import FirebaseSessionManager
# Create our main application
app = App(middleware=[
SQLAlchemySessionManager(),
FirebaseSessionManager(),
])
# Allow HTTP cookies for local development
app.resp_options.secure_cookies_by_default = settings.debug
# Define our application routes
app.add_route('/health-check', views.HealthCheck())
app.add_route('/session', views.FirebaseAuth())
def test_multiple():
class SomeResource:
def __init__(self):
self.counter = Counter()
async def on_get(self, req, resp):
async def background_job_async():
self.counter['backround:on_get:async'] += 1
def background_job_sync():
self.counter['backround:on_get:sync'] += 20
with pytest.raises(TypeError):
resp.schedule(background_job_sync)
resp.schedule_sync(background_job_sync)
resp.schedule(background_job_async)
resp.schedule_sync(background_job_sync)
resp.schedule(background_job_async)
async def on_post(self, req, resp):
async def background_job_async():
self.counter['backround:on_get:async'] += 1000
def background_job_sync():
self.counter['backround:on_get:sync'] += 2000
resp.schedule(background_job_async)
resp.schedule(background_job_async)
resp.schedule_sync(background_job_sync)
resp.schedule_sync(background_job_sync)
async def on_put(self, req, resp):
async def background_job_async():
self.counter['backround:on_get:async'] += 1000
c = background_job_async()
try:
resp.schedule(c)
finally:
await c
resource = SomeResource()
app = App()
app.add_route('/', resource)
client = testing.TestClient(app)
client.simulate_get()
client.simulate_post()
time.sleep(0.5)
assert resource.counter['backround:on_get:async'] == 2002
assert resource.counter['backround:on_get:sync'] == 4040
result = client.simulate_put()
assert result.status_code == 500
# NOTE(kgriffs): Remove default handlers so that we can check the raised
# exception is what we expecte.
app._error_handlers.clear()
with pytest.raises(TypeError) as exinfo:
client.simulate_put()
assert 'coroutine' in str(exinfo.value)
def test_multiple_handlers():
counter = 0
class HandlerA:
async def process_startup(self, scope, event):
nonlocal counter
self._called_startup = counter
counter += 1
class HandlerB:
async def process_startup(self, scope, event):
nonlocal counter
self._called_startup = counter
counter += 1
async def process_shutdown(self, scope, event):
nonlocal counter
self._called_shutdown = counter
counter += 1
class HandlerC:
async def process_shutdown(self, scope, event):
nonlocal counter
self._called_shutdown = counter
counter += 1
class HandlerD:
async def process_startup(self, scope, event):
nonlocal counter
self._called_startup = counter
counter += 1
class HandlerE:
async def process_startup(self, scope, event):
nonlocal counter
self._called_startup = counter
counter += 1
async def process_shutdown(self, scope, event):
nonlocal counter
self._called_shutdown = counter
counter += 1
async def process_request(self, req, resp):
self._called_request = True
app = App()
a = HandlerA()
b = HandlerB()
c = HandlerC()
d = HandlerD()
e = HandlerE()
app.add_middleware([a, b, c, d, e])
client = testing.TestClient(app)
client.simulate_get()
assert a._called_startup == 0
assert b._called_startup == 1
assert d._called_startup == 2
assert e._called_startup == 3
assert e._called_shutdown == 4
assert c._called_shutdown == 5
assert b._called_shutdown == 6
assert e._called_request
async def test_echo(): # noqa: C901
consumer_sleep = 0.01
producer_loop = 10
producer_sleep_factor = consumer_sleep / (producer_loop / 2)
class Resource:
def __init__(self):
self.caught_operation_not_allowed = False
async def on_websocket(self, req, ws, p1, p2, injected):
# NOTE(kgriffs): Normally the receiver task is not started
# until the websocket is started. But here we start it
# first in order to simulate a potential race condition
# that ASGIWebSocketSimulator._emit() guards against,
# in case it ever arises due to the way the target ASGI
# app may be implemented.
ws._buffered_receiver.start()
await asyncio.sleep(0)
if ws.unaccepted:
await ws.accept()
try:
await ws.accept()
except falcon.OperationNotAllowed:
self.caught_operation_not_allowed = True
if ws.ready:
await ws.send_text(
f'{p1}:{p2}:{req.context.message}:{injected}')
messages = deque()
sink_task = falcon.create_task(self._sink(ws, messages))
while not sink_task.done():
if not messages:
await asyncio.sleep(0)
continue
try:
await ws.send_text(messages.popleft())
except falcon.WebSocketDisconnected:
break
sink_task.cancel()
try:
await sink_task
except asyncio.CancelledError:
pass
async def _sink(self, ws, messages):
while True:
# NOTE(kgriffs): Throttle slightly to allow messages to
# fill up the buffer.
await asyncio.sleep(consumer_sleep)
try:
message = await ws.receive_text()
except falcon.WebSocketDisconnected:
break
if message != 'ignore':
messages.append(message)
class MiddlewareA:
async def process_resource_ws(self, req, ws, resource, params):
assert isinstance(resource, Resource)
assert isinstance(ws, falcon.asgi.WebSocket)
params['injected'] = '42'
class MiddlewareB:
async def process_request_ws(self, req, ws):
assert isinstance(ws, falcon.asgi.WebSocket)
req.context.message = 'hello'
resource = Resource()
# NOTE(kgriffs): The two methods are split across different middleware
# classes so that we can test code paths that check for the existence
# of one WebSocket middleware method vs the other, and also so that
# we can make sure both the kwarg and the add_middlware() paths
# succeed.
app = App(middleware=MiddlewareA())
app.add_middleware(MiddlewareB())
app.add_route('/{p1}/{p2}', resource)
async with testing.ASGIConductor(app) as c:
async with c.simulate_ws('/v1/v2', headers={}) as ws:
assert (await ws.receive_text()) == 'v1:v2:hello:42'
for i in range(producer_loop):
message = str(
i
) if i else '' # Test round-tripping the empty string as well
for i in range(100):
await ws.send_text('ignore')
# NOTE(kgriffs): For part of the time, cause the buffer on the
# server side to fill up, and for the remainder of the time
# for the buffer to be empty and wait on the client for
# additional messages.
await asyncio.sleep(i * producer_sleep_factor)
await ws.send_text(message)
assert (await ws.receive_text()) == message
await ws.close()
assert ws.closed
assert ws.close_code == CloseCode.NORMAL
assert resource.caught_operation_not_allowed
def test_sync_helpers():
safely_values = []
unsafely_values = []
shirley_values = []
class SomeResource:
async def on_get(self, req, resp):
safely_coroutine_objects = []
unsafely_coroutine_objects = []
shirley_coroutine_objects = []
def callme_safely(a, b, c=None):
# NOTE(kgriffs): Sleep to prove that there isn't another
# instance running in parallel that is able to race ahead.
time.sleep(0.001)
safely_values.append((a, b, c))
def callme_unsafely(a, b, c=None):
time.sleep(0.01)
# NOTE(vytas): Deliberately exaggerate a race condition here
# in order to ensure a more deterministic test outcome.
if a == 137:
for _ in range(1000):
if len(unsafely_values) > 137:
break
time.sleep(0.01)
unsafely_values.append((a, b, c))
def callme_shirley(a=42, b=None):
time.sleep(0.01)
v = (a, b)
shirley_values.append(v)
# NOTE(kgriffs): Test that returning values works as expected
return v
# NOTE(kgriffs): Test setting threadsafe=True explicitly
cmus = falcon.util.wrap_sync_to_async(callme_unsafely, threadsafe=True)
cms = falcon.util.wrap_sync_to_async(callme_safely, threadsafe=False)
loop = falcon.util.get_running_loop()
# NOTE(kgriffs): create_task() is used here, so that the coroutines
# are scheduled immediately in the order created; under Python
# 3.6, asyncio.gather() does not seem to always schedule
# them in order, so we do it this way to make it predictable.
for i in range(1000):
safely_coroutine_objects.append(
loop.create_task(cms(i, i + 1, c=i + 2))
)
unsafely_coroutine_objects.append(
loop.create_task(cmus(i, i + 1, c=i + 2))
)
shirley_coroutine_objects.append(
loop.create_task(falcon.util.sync_to_async(callme_shirley, 24, b=i))
)
await asyncio.gather(
*(
safely_coroutine_objects +
unsafely_coroutine_objects +
shirley_coroutine_objects
)
)
assert (42, None) == await falcon.util.sync_to_async(callme_shirley)
assert (1, 2) == await falcon.util.sync_to_async(callme_shirley, 1, 2)
assert (3, 4) == await falcon.util.sync_to_async(callme_shirley, 3, b=4)
assert (5, None) == await falcon.util.wrap_sync_to_async(callme_shirley)(5)
assert (42, 6) == await falcon.util.wrap_sync_to_async(
callme_shirley, threadsafe=True)(b=6)
with pytest.raises(TypeError):
await falcon.util.sync_to_async(callme_shirley, -1, bogus=-1)
resource = SomeResource()
app = App()
app.add_route('/', resource)
client = testing.TestClient(app)
result = client.simulate_get()
assert result.status_code == 200
assert len(safely_values) == 1000
for i, val in enumerate(safely_values):
assert val == (i, i + 1, i + 2)
assert len(unsafely_values) == 1000
assert any(
val != (i, i + 1, i + 2)
for i, val in enumerate(unsafely_values)
)
for i, val in enumerate(shirley_values):
assert val[0] in {24, 42, 1, 5, 3}
assert val[1] is None or (0 <= val[1] < 1000)
else:
response.text = dumps(
{
'params': {
'user': user,
'record': record
},
'query': request.params,
'data': await request.get_media(),
},
ensure_ascii=False,
separators=(',', ':'))
app = App()
# first add ten more routes to load routing system
# ------------------------------------------------
class req_ok:
async def on_get(self, *args, **kwargs):
pass
for n in range(5):
app.add_route(f"/route-{n}", req_ok())
app.add_route(f"/route-dyn-{n}/{{part}}", req_ok())
# then prepare endpoints for the benchmark
# ----------------------------------------
def test_multiple_events():
expected_result_text = ('data: ketchup\n'
'\n'
'event: condiment\n'
'data: mustard\n'
'\n'
'event: condiment\n'
'id: 1234\n'
'data: mayo\n'
'\n'
'event: topping\n'
'id: 5678\n'
'retry: 100\n'
'data: onions\n'
'\n'
': Serve with chips.\n'
'retry: 100\n'
'data: guacamole \u1F951\n'
'\n'
'retry: 100\n'
'data: {"condiment": "salsa"}\n'
'\n')
class SomeResource:
async def on_get(self, req, resp):
async def emitter():
for event in [
SSEvent(data=b'ketchup'),
SSEvent(data=b'mustard', event='condiment'),
SSEvent(data=b'mayo',
event='condiment',
event_id='1234'),
SSEvent(data=b'onions',
event='topping',
event_id='5678',
retry=100),
SSEvent(text='guacamole \u1F951',
retry=100,
comment='Serve with chips.'),
SSEvent(json={'condiment': 'salsa'}, retry=100),
]:
yield event
await asyncio.sleep(0.001)
resp.sse = emitter()
resource = SomeResource()
app = App()
app.add_route('/', resource)
client = testing.TestClient(app)
async def _test():
async with client as conductor:
# NOTE(kgriffs): Single-shot test will only allow the first
# one or two events since a client disconnect will be emitted
# into the app immediately.
result = await conductor.simulate_get()
assert expected_result_text.startswith(result.text)
async with conductor.simulate_get_stream() as sr:
event_count = 0
result_text = ''
while True:
chunk = (await sr.stream.read()).decode()
if not chunk:
continue
result_text += chunk
event_count += len(chunk.strip().split('\n\n'))
if 'salsa' in chunk:
break
assert not (await sr.stream.read())
assert event_count == 6
assert result_text == expected_result_text
falcon.async_to_sync(_test)
