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