def middleware(self, request: Request, handler, call_next):
request.set("data", self._data, lazy=True)
request.set("path", self._path, lazy=True)
request.set("query_params", self._query_params, lazy=True)
request.set("json", self._json, lazy=True)
request.set("content_type", self._content_type, lazy=True)
request.set("encoding", self._encoding, lazy=True)
return call_next(request, handler)
def test_resolve_simple_negative():
router = HttpRouter(not_found_handler=not_found_handler)
router.add(b"POST", b"/test1", handler)
assert router._resolve(Request(path=b"/test/", method=b"POST",
body=b""))[0] is not_found_handler
assert router._resolve(
Request(path=b"/test/test1", method=b"POST",
body=b""))[0] is not_found_handler
assert router._resolve(
Request(path=b"/test1/some", method=b"POST",
body=b""))[0] is not_found_handler
assert router._resolve(Request(path=b"/test1", method=b"GET",
body=b""))[0] is not_found_handler
def test_resolve_pattern_negative():
router = HttpRouter(not_found_handler=not_found_handler)
router.add(b"POST", b"/test/{user}", handler)
assert router._resolve(Request(path=b"/test", method=b"POST",
body=b""))[0] is not_found_handler
assert router._resolve(
Request(path=b"/testmyuser", method=b"POST",
body=b""))[0] is not_found_handler
assert router._resolve(
Request(path=b"/test/myuser/test", method=b"POST",
body=b""))[0] is not_found_handler
assert router._resolve(
Request(path=b"/v1/test/myuser", method=b"POST",
body=b""))[0] is not_found_handler
async def test_full_connection_lifecycle_with_resp(event_loop):
parser = Mock()
request = Request(b"/path")
parser.handle_request = Mock(return_value=(b"", [request], True))
parser.handle_response = Mock(return_value=[
b"test",
])
async def handler(request):
assert request.raw_path == b"/path"
assert request.method == b"GET"
return
transport = Mock()
connection = Connection(parsers=[parser], handler=handler, loop=event_loop)
connection.connection_made(transport)
parser.connect.assert_called_once()
connection.data_received(b"-")
await asyncio.sleep(0.01,
loop=event_loop) # switch task - allow handler execute
parser.handle_request.assert_called_once()
transport.write.assert_called_once_with(b"test")
transport.close.assert_called_once()
def test_resolve_simple_slash_route():
router = HttpRouter(not_found_handler=not_found_handler)
router.add(b"POST", b"/test1/", handler)
request = Request(path=b"/test1", method=b"POST", body=b"")
handler_res, data = router._resolve(request)
assert handler_res is handler
assert data["pattern"] == b"/test1/"
def middleware(request: Request, handler, call_next) -> Response:
params = inspect.signature(handler).parameters
kwargs = {}
for param in params.values():
if hasattr(param.annotation, "_value_name"):
kwargs[param.name] = request.get(param.annotation._value_name)
if kwargs:
handler = partial(handler, **kwargs)
return call_next(request, handler)
def test_resolve_pattern_slash():
router = HttpRouter(not_found_handler=not_found_handler)
router.add(b"POST", b"/test/{user}", handler)
request = Request(path=b"/test/myuser/", method=b"POST", body=b"")
handler_res, data = router._resolve(request)
assert handler_res is handler
assert data["pattern"] == b"/test/{user}"
assert data["user"] == b"myuser"
async def _run_with_profile(self, request: Request, handler, call_next):
async with self._lock:
self._targets.remove(_request_hash(request))
profile = SimpleProfile(depth=request.get("depth", self.depth), memory=self.with_memory)
profile.add_target(handler)
handler = profile.trace(handler)
try:
return await call_next(request, handler)
finally:
self.callback(profile)
def test_resolve_pattern_re():
router = HttpRouter()
router.add(b"POST", re.compile(br"/test/(?P<user>\w+)/(?P<id>\d+)"),
handler)
request = Request(path=b"/test/myuser/10", method=b"POST", body=b"")
handler_res, data = router._resolve(request)
assert handler_res is handler
assert data["pattern"] == b"/test/{user}/{id}"
assert data["user"] == b"myuser"
assert data["id"] == b"10"
async def middleware(self, request: Request, handler, call_next):
if _request_hash(request) in self._targets and not self._lock.locked():
return await self._run_with_profile(request, handler, call_next)
start = self.get_time()
try:
return await call_next(request, handler)
finally:
if request.get("profile_condition", self.profile_condition)(
request, self.get_time() - start, self.threshold
):
request.logger.info("add to profile")
self._targets.append(_request_hash(request))
async def middleware(self, request: Request, handler,
call_next) -> Response:
request.set("logger", self._logger)
start = time.perf_counter()
response: Response = await call_next(request, handler)
self._logger.log(
self.level,
self.message_format,
{
"status": response.status,
"method": request.method.decode(),
"path": request.raw_path.decode(),
"protocol": request.protocol.decode(),
"body_size": len(response.body),
"time": str(time.perf_counter() - start)[:6],
"stream": request.stream,
"transport": request.get_transport_info(),
},
extra=self.extra,
)
return response
async def middleware(self, request: Request, handler,
call_next) -> Response:
request.set("add_push", self._create_add_push, lazy=True)
response: Response = await call_next(request, handler)
if request.get(self._scope_value):
response.pushes = request.get(self._scope_value)
if request.get("push"):
response.pushes.append(
_Push(path=request.get("push").format(
**request._scope).encode(), ))
return response
def resolve(self, path: str, method: str = "GET", code: bool = False):
"""
Return handler for given path and method
"""
handler, conditions_result = self._resolve(
Request(method=method.encode(), path=path.encode()))
pattern = ""
if "pattern" in conditions_result:
pattern = f"with pattern \"{conditions_result['pattern'].decode()}\""
base = (
f'Find handler "{handler.__name__}" {pattern} in '
f"{inspect.getsourcefile(handler)}:{handler.__code__.co_firstlineno} "
)
if code:
code = inspect.getsource(handler)
return f"{base}\n\n{code}"
if inspect.getdoc(handler):
return f"{base}\n\n{inspect.getdoc(handler)}"
return base