def test_blueprint_group_insert(): blueprint_1 = Blueprint( "blueprint_1", url_prefix="/bp1", strict_slashes=True, version=1 ) blueprint_2 = Blueprint("blueprint_2", url_prefix="/bp2") blueprint_3 = Blueprint("blueprint_3", url_prefix=None) group = BlueprintGroup( url_prefix="/test", version=1.3, strict_slashes=False ) group.insert(0, blueprint_1) group.insert(0, blueprint_2) group.insert(0, blueprint_3) @blueprint_1.route("/") def blueprint_1_default_route(request): return text("BP1_OK") @blueprint_2.route("/") def blueprint_2_default_route(request): return text("BP2_OK") @blueprint_3.route("/") def blueprint_3_default_route(request): return text("BP3_OK") app = Sanic("PropTest") app.blueprint(group) app.router.finalize() routes = [(route.path, route.strict) for route in app.router.routes] assert len(routes) == 3 assert ("v1/test/bp1/", True) in routes assert ("v1.3/test/bp2", False) in routes assert ("v1.3/test", False) in routes
def setUp(self): modules.flags_manager.remove_all_flags() self.app = Sanic() self.app.add_route(test_api, '/test', methods=['POST']) init_sanic('test_app', self.app, setup_kuber_config_loader=False) flags.DEFINE_INTEGER_FLAG("test") self.loader = KuberConfigLoader("test_service") self.loader.load_config( config_pb2.GlobalConfig( flags=[{ "name": "test", "type": "INTEGER", "value": { "base_value": { "number_value": 1 } } }], experiments={ 2: ExperimentDefinition( id=2, flag_values={ "test": FlagValue(base_value={"number_value": 2}) }) })) self.server = Process(target=self.app.run, args=("127.0.0.1", 8008)) self.server.start() sleep(1)
def test_static_blueprintp_mw(app: Sanic, static_file_directory, file_name): current_file = inspect.getfile(inspect.currentframe()) with open(current_file, "rb") as file: file.read() triggered = False bp = Blueprint(name="test_mw", url_prefix="") @bp.middleware("request") def bp_mw1(request): nonlocal triggered triggered = True bp.static( "/test.file", get_file_path(static_file_directory, file_name), strict_slashes=True, name="static", ) app.blueprint(bp) uri = app.url_for("test_mw.static") assert uri == "/test.file" _, response = app.test_client.get("/test.file") assert triggered is True
def test_blueprint_middleware_with_args(app: Sanic): bp = Blueprint(name="with_args_bp", url_prefix="/wa") @bp.middleware def middleware_with_no_tag(request: Request): if request.headers.get("content-type") == "application/json": request.headers["accepts"] = "plain/text" else: request.headers["accepts"] = "application/json" @bp.route("/") def default_route(request): if request.headers.get("accepts") == "application/json": return json({"test": "value"}) else: return text("value") app.blueprint(bp) _, response = app.test_client.get( "/wa", headers={"content-type": "application/json"}) assert response.text == "value" _, response = app.test_client.get("/wa", headers={"content-type": "plain/text"}) assert response.json.get("test") == "value"
def test_blueprint_middleware_with_args(app: Sanic): bp = Blueprint(name="with_args_bp", url_prefix="/wa") @bp.middleware def middleware_with_no_tag(request: Request): if request.headers.get("content-type") == "application/json": request.headers["accepts"] = "plain/text" else: request.headers["accepts"] = "application/json" @bp.route("/") def default_route(request): if request.headers.get("accepts") == "application/json": return json({"test": "value"}) else: return text("value") app.blueprint(bp) _, response = app.test_client.get( "/wa", headers={"content-type": "application/json"} ) assert response.text == "value" _, response = app.test_client.get( "/wa", headers={"content-type": "plain/text"} ) assert response.json.get("test") == "value" d = {}
def test_static_blueprint_name(static_file_directory, file_name): app = Sanic("app") current_file = inspect.getfile(inspect.currentframe()) with open(current_file, "rb") as file: file.read() bp = Blueprint(name="static", url_prefix="/static", strict_slashes=False) bp.static( "/test.file/", get_file_path(static_file_directory, file_name), name="static.testing", strict_slashes=True, ) app.blueprint(bp) uri = app.url_for("static", name="static.testing") assert uri == "/static/test.file/" _, response = app.test_client.get("/static/test.file") assert response.status == 404 _, response = app.test_client.get("/static/test.file/") assert response.status == 200
async def test_add_task_with_name(app: Sanic): task = app.add_task(dummy(), name="dummy") assert isinstance(task, Task) assert len(app._task_registry) == 1 assert task is app.get_task("dummy") for task in app.tasks: assert task in app._task_registry.values()
def test_bp_group(app: Sanic): blueprint_1 = Blueprint("blueprint_1", url_prefix="/bp1") blueprint_2 = Blueprint("blueprint_2", url_prefix="/bp2") @blueprint_1.route("/") def blueprint_1_default_route(request): return text("BP1_OK") @blueprint_2.route("/") def blueprint_2_default_route(request): return text("BP2_OK") blueprint_group_1 = Blueprint.group( blueprint_1, blueprint_2, url_prefix="/bp" ) blueprint_3 = Blueprint("blueprint_3", url_prefix="/bp3") @blueprint_group_1.middleware("request") def blueprint_group_1_middleware(request): global MIDDLEWARE_INVOKE_COUNTER MIDDLEWARE_INVOKE_COUNTER["request"] += 1 @blueprint_3.route("/") def blueprint_3_default_route(request): return text("BP3_OK") blueprint_group_2 = Blueprint.group( blueprint_group_1, blueprint_3, url_prefix="/api" ) @blueprint_group_2.middleware("response") def blueprint_group_2_middleware(request, response): global MIDDLEWARE_INVOKE_COUNTER MIDDLEWARE_INVOKE_COUNTER["response"] += 1 app.blueprint(blueprint_group_2) @app.route("/") def app_default_route(request): return text("APP_OK") _, response = app.test_client.get("/") assert response.text == "APP_OK" _, response = app.test_client.get("/api/bp/bp1") assert response.text == "BP1_OK" _, response = app.test_client.get("/api/bp/bp2") assert response.text == "BP2_OK" _, response = app.test_client.get("/api/bp3") assert response.text == "BP3_OK" assert MIDDLEWARE_INVOKE_COUNTER["response"] == 4 assert MIDDLEWARE_INVOKE_COUNTER["request"] == 4
def test_bp_group(app: Sanic): blueprint_1 = Blueprint("blueprint_1", url_prefix="/bp1") blueprint_2 = Blueprint("blueprint_2", url_prefix="/bp2") @blueprint_1.route("/") def blueprint_1_default_route(request): return text("BP1_OK") @blueprint_2.route("/") def blueprint_2_default_route(request): return text("BP2_OK") blueprint_group_1 = Blueprint.group(blueprint_1, blueprint_2, url_prefix="/bp") blueprint_3 = Blueprint("blueprint_3", url_prefix="/bp3") @blueprint_group_1.middleware("request") def blueprint_group_1_middleware(request): global MIDDLEWARE_INVOKE_COUNTER MIDDLEWARE_INVOKE_COUNTER["request"] += 1 @blueprint_3.route("/") def blueprint_3_default_route(request): return text("BP3_OK") blueprint_group_2 = Blueprint.group(blueprint_group_1, blueprint_3, url_prefix="/api") @blueprint_group_2.middleware("response") def blueprint_group_2_middleware(request, response): global MIDDLEWARE_INVOKE_COUNTER MIDDLEWARE_INVOKE_COUNTER["response"] += 1 app.blueprint(blueprint_group_2) @app.route("/") def app_default_route(request): return text("APP_OK") _, response = app.test_client.get("/") assert response.text == "APP_OK" _, response = app.test_client.get("/api/bp/bp1") assert response.text == "BP1_OK" _, response = app.test_client.get("/api/bp/bp2") assert response.text == "BP2_OK" _, response = app.test_client.get("/api/bp3") assert response.text == "BP3_OK" assert MIDDLEWARE_INVOKE_COUNTER["response"] == 3 assert MIDDLEWARE_INVOKE_COUNTER["request"] == 2
async def test_purge_tasks(app: Sanic): app.add_task(dummy(3), name="dummy") await app.cancel_task("dummy") assert len(app._task_registry) == 1 app.purge_tasks() assert len(app._task_registry) == 0
def load_api(app: Sanic): from service.resources.movies import MoviesResource api_prefix = f"/{app.config.get('SERVICE_NAME')}/v1" api = Blueprint("v1", url_prefix=api_prefix, strict_slashes=False) # get the endpoints here api.add_route(MoviesResource.as_view(), "/movies", strict_slashes=False) app.blueprint(api)
def create_app(): app = Sanic(DEFAULT_SERVICE_NAME) api_prefix = f'/{DEFAULT_SERVICE_NAME}' api = Blueprint('whreports', url_prefix=api_prefix) api.add_route(SmokeResource.as_view(), "/smoke") api.add_route(GenerateReportResource.as_view(), "/report") api.add_route(StatusReportResource.as_view(), "/report/status/<task_id>") api.add_route(DownloadReportResource.as_view(), "/report/download/<task_id>") app.blueprint(api) import os return app
def __init__( self, client_public_key: str, token: str, uri: str = "discord_interaction", production: bool = False, ) -> None: self.sanic = Sanic("hiyobot") self.uri = uri self.token = token self.client_public_key = client_public_key self.__setup()
def load_api(app: Sanic): api_v1 = Blueprint("v1", url_prefix=api_prefix) api_v1.add_route(RegisterResource.as_view(), "/register") api_v1.add_route(LoginResource.as_view(), "/login") api_v1.add_route(LogoutResource.as_view(), "/logout") api_v1.add_route(UserResource.as_view(), f"/user/<user_id:{uuid_regex}>") api_v1.add_route(PetitionResource.as_view(), "/petition") api_v1.add_route(PetitionResource.as_view(), f"/petition/<petition_id:{uuid_regex}>") app.blueprint(api_v1)
def add_doc_route( app: Sanic, prefix: str = "/", pin_code: str = "", title: str = "Pait Doc", open_api_tag_list: Optional[List[Dict[str, Any]]] = None, ) -> None: if pin_code: logging.info(f"doc route start pin code:{pin_code}") def _get_request_pin_code(request: Request) -> Optional[str]: r_pin_code: Optional[str] = request.args.get("pin_code", None) if pin_code: if r_pin_code != pin_code: raise NotFound return r_pin_code def _get_open_json_url(request: Request) -> str: r_pin_code: Optional[str] = _get_request_pin_code(request) openapi_json_url: str = f"http://{request.host}{'/'.join(request.path.split('/')[:-1])}/openapi.json" if r_pin_code: openapi_json_url += f"?pin_code={r_pin_code}" return openapi_json_url def get_redoc_html(request: Request) -> HTTPResponse: return response.html( _get_redoc_html(_get_open_json_url(request), title)) def get_swagger_ui_html(request: Request) -> HTTPResponse: return response.html( _get_swagger_ui_html(_get_open_json_url(request), title)) def openapi_route(request: Request) -> HTTPResponse: _get_request_pin_code(request) pait_dict: Dict[str, PaitCoreModel] = load_app(request.app) pait_openapi: PaitOpenApi = PaitOpenApi( pait_dict, title=title, open_api_server_list=[{ "url": f"http://{request.host}", "description": "" }], open_api_tag_list=open_api_tag_list, ) return response.json(pait_openapi.open_api_dict) blueprint: Blueprint = Blueprint("api doc", prefix) blueprint.add_route(get_redoc_html, "/redoc", methods={"GET"}) blueprint.add_route(get_swagger_ui_html, "/swagger", methods={"GET"}) blueprint.add_route(openapi_route, "/openapi.json", methods={"GET"}) app.blueprint(blueprint)
def test_websocket_route(app: Sanic): event = asyncio.Event() async def websocket_handler(request, ws): assert ws.subprotocol is None event.set() bp = Blueprint(name="handler", url_prefix="/ws") bp.add_websocket_route(websocket_handler, "/test", name="test") app.blueprint(bp) _, response = app.test_client.websocket("/ws/test") assert response.opened is True assert event.is_set()
def __init__(self): self.app = mock.Mock() self.app.callable = Sanic("test_gunicorn_worker") self.servers = {} self.exit_code = 0 self.cfg = mock.Mock() self.notify = mock.Mock()
def create_auxiliary_app(): app = Sanic("SANIC_DEV_AUX_APP") @app.route("/") def aux_home(request): return json({"status": "ok"}) return app
def __init__(self, service, name: str = None, setting_prefix: str = None): """ :param service: :type service: :param name: :type name: str :param setting_prefix: :type setting_prefix: str """ super(Web, self).__init__(service, name, setting_prefix) self.app = Sanic(self.name) self.app.config["SERVICE"] = self.service # configure normal route self.app.add_route(self.home, "/") self.server = None # type: ignore
def test_blueprint_group_versioning(): app = Sanic(name="blueprint-group-test") bp1 = Blueprint(name="bp1", url_prefix="/bp1") bp2 = Blueprint(name="bp2", url_prefix="/bp2", version=2) bp3 = Blueprint(name="bp3", url_prefix="/bp3") @bp3.get("/r1") async def bp3_r1(request): return json({"from": "bp3/r1"}) @bp1.get("/pre-group") async def pre_group(request): return json({"from": "bp1/pre-group"}) group = Blueprint.group([bp1, bp2], url_prefix="/group1", version=1) group2 = Blueprint.group([bp3]) @bp1.get("/r1") async def r1(request): return json({"from": "bp1/r1"}) @bp2.get("/r2") async def r2(request): return json({"from": "bp2/r2"}) @bp2.get("/r3", version=3) async def r3(request): return json({"from": "bp2/r3"}) app.blueprint([group, group2]) assert app.test_client.get("/v1/group1/bp1/r1/")[1].status == 200 assert app.test_client.get("/v2/group1/bp2/r2")[1].status == 200 assert app.test_client.get("/v1/group1/bp1/pre-group")[1].status == 200 assert app.test_client.get("/v3/group1/bp2/r3")[1].status == 200 assert app.test_client.get("/bp3/r1")[1].status == 200 assert group.version == 1 assert group2.strict_slashes is None
def load_api(app: Sanic): from service_api.resources import ( SmokeResources, HelloWorldView, # AllDataResourceView, ) api_prefix = "/{service_name}/v1".format( service_name=app.config.get("SERVICE_NAME")) api_v1 = Blueprint("v1", url_prefix=api_prefix) # get the endpoints here api_v1.add_route(SmokeResources.as_view(), "/smoke", strict_slashes=False) api_v1.add_route(HelloWorldView.as_view(), "/hello-world", strict_slashes=False) # api_v1.add_route(AllDataResourceView.as_view(), '/all/<collection>', # strict_slashes=False) app.blueprint(api_v1) app.blueprint(openapi_blueprint) app.blueprint(swagger_blueprint)
def test_bp_group_properties(): blueprint_1 = Blueprint("blueprint_1", url_prefix="/bp1") blueprint_2 = Blueprint("blueprint_2", url_prefix="/bp2") group = Blueprint.group( blueprint_1, blueprint_2, version=1, version_prefix="/api/v", url_prefix="/grouped", strict_slashes=True, ) primary = Blueprint.group(group, url_prefix="/primary") @blueprint_1.route("/") def blueprint_1_default_route(request): return text("BP1_OK") @blueprint_2.route("/") def blueprint_2_default_route(request): return text("BP2_OK") app = Sanic("PropTest") app.blueprint(group) app.blueprint(primary) app.router.finalize() routes = [route.path for route in app.router.routes] assert len(routes) == 4 assert "api/v1/grouped/bp1/" in routes assert "api/v1/grouped/bp2/" in routes assert "api/v1/primary/grouped/bp1" in routes assert "api/v1/primary/grouped/bp2" in routes
def test_websocket_route(app: Sanic): event = asyncio.Event() async def websocket_handler(request, ws): assert ws.subprotocol is None event.set() bp = Blueprint(name="handler", url_prefix="/ws") bp.add_websocket_route(websocket_handler, "/test", name="test") app.blueprint(bp) _, response = app.test_client.get("/ws/test", headers={ 'Upgrade': 'websocket', 'Connection': 'upgrade', 'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ==', 'Sec-WebSocket-Version': '13' }) assert response.status == 101 assert event.is_set()
def test_blueprint_registered_multiple_apps(): app1 = Sanic("app1") app2 = Sanic("app2") bp = Blueprint("bp") @bp.get("/") async def handler(request): return text(request.route.name) app1.blueprint(bp) app2.blueprint(bp) for app in (app1, app2): _, response = app.test_client.get("/") assert response.text == f"{app.name}.bp.handler"
def test_route_handler_add(app: Sanic): view = CompositionView() async def get_handler(request): return json({"response": "OK"}) view.add(["GET"], get_handler, stream=False) async def default_handler(request): return text("OK") bp = Blueprint(name="handler", url_prefix="/handler") bp.add_route(default_handler, uri="/default/", strict_slashes=True) bp.add_route(view, uri="/view", name="test") app.blueprint(bp) _, response = app.test_client.get("/handler/default/") assert response.text == "OK" _, response = app.test_client.get("/handler/view") assert response.json["response"] == "OK"
def test_websocket_route(app: Sanic): event = asyncio.Event() async def websocket_handler(request, ws): assert ws.subprotocol is None event.set() bp = Blueprint(name="handler", url_prefix="/ws") bp.add_websocket_route(websocket_handler, "/test", name="test") app.blueprint(bp) _, response = app.test_client.get( "/ws/test", headers={ "Upgrade": "websocket", "Connection": "upgrade", "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==", "Sec-WebSocket-Version": "13", }, ) assert response.status == 101 assert event.is_set()
def test_static_blueprint_name(app: Sanic, static_file_directory, file_name): current_file = inspect.getfile(inspect.currentframe()) with open(current_file, "rb") as file: current_file_contents = file.read() bp = Blueprint(name="static", url_prefix="/static", strict_slashes=False) bp.static( "/test.file/", get_file_path(static_file_directory, file_name), name="static.testing", strict_slashes=True, ) app.blueprint(bp) uri = app.url_for("static", name="static.testing") assert uri == "/static/test.file" _, response = app.test_client.get("/static/test.file") assert response.status == 404 _, response = app.test_client.get("/static/test.file/") assert response.status == 200
async def test_cancel_task(app: Sanic): task = app.add_task(dummy(3), name="dummy") assert task assert not task.done() assert not task.cancelled() await asyncio.sleep(0.1) assert not task.done() assert not task.cancelled() await app.cancel_task("dummy") assert task.cancelled()
def create_app(): app = Sanic(DEFAULT_SERVICE_NAME) api_prefix = f'/{DEFAULT_SERVICE_NAME}' api = Blueprint('warehouse', url_prefix=api_prefix) api.add_route(SmokeResource.as_view(), "/smoke") api.add_route(ClientAllResource().as_view(), "/client") api.add_route(ClientResource().as_view(), "/client/<client_id>") api.add_route(ParcelTypeAllResource().as_view(), "/parceltype") api.add_route(ParcelTypeResource().as_view(), "/parceltype/<type_id>") api.add_route(StorageAllResource().as_view(), "/storage") api.add_route(StorageResource().as_view(), "/storage/<storage_id>") api.add_route(ParcelAllResource().as_view(), "/parcel") api.add_route(ParcelResource().as_view(), "/parcel/<parcel_id>") api.add_route(ParcelQueryResource().as_view(), "/parcel/<parcel_type>/<storage_id>") api.add_route(ParcelReportResource().as_view(), "/parcel/report") api.add_route(SupplyAllResource().as_view(), "/supply") api.add_route(SupplyResource().as_view(), "/supply/<supply_id>") app.blueprint(api) return app
def create_app() -> Sanic: app: Sanic = Sanic(name="pait") add_doc_route(app) app.add_route(test_get, "/api/get/<age>", methods={"GET"}) app.add_route(test_check_param, "/api/check_param", methods={"GET"}) app.add_route(test_check_resp, "/api/check_resp", methods={"GET"}) app.add_route(test_post, "/api/post", methods={"POST"}) app.add_route(test_depend, "/api/depend", methods={"POST"}) app.add_route(test_other_field, "/api/other_field", methods={"POST"}) app.add_route(test_raise_tip, "/api/raise_tip", methods={"POST"}) app.add_route(TestCbv.as_view(), "/api/cbv") app.add_route(test_pait_model, "/api/pait_model", methods={"POST"}) app.exception(PaitBaseException)(api_exception) app.exception(ValidationError)(api_exception) return app
def app(): app = Sanic("test_sanic_app") @app.route("/test_get", methods=['GET']) async def test_get(request): return response.json({"GET": True}) @app.route("/test_post", methods=['POST']) async def test_post(request): return response.json({"POST": True}) @app.route("/test_put", methods=['PUT']) async def test_put(request): return response.json({"PUT": True}) @app.route("/test_delete", methods=['DELETE']) async def test_delete(request): return response.json({"DELETE": True}) @app.route("/test_patch", methods=['PATCH']) async def test_patch(request): return response.json({"PATCH": True}) @app.route("/test_options", methods=['OPTIONS']) async def test_options(request): return response.json({"OPTIONS": True}) @app.route("/test_head", methods=['HEAD']) async def test_head(request): return response.json({"HEAD": True}) @app.websocket("/test_ws") async def test_ws(request, ws): data = await ws.recv() await ws.send(data) @app.route("/test_passing_headers", methods=['GET']) async def test_get(request): return response.json({"headers": dict(request.headers)}) @app.listener('before_server_start') async def mock_init_db(app, loop): await asyncio.sleep(0.01) yield app
def test_blueprint_group_strict_slashes(): app = Sanic(name="blueprint-group-test") bp1 = Blueprint(name="bp1", url_prefix=None, strict_slashes=False) bp2 = Blueprint(name="bp2", version=3, url_prefix="/bp2", strict_slashes=None) bp3 = Blueprint(name="bp3", version=None, url_prefix="/bp3/", strict_slashes=None) @bp1.get("/r1") async def bp1_r1(request): return json({"from": "bp1/r1"}) @bp2.get("/r1") async def bp2_r1(request): return json({"from": "bp2/r1"}) @bp2.get("/r2/") async def bp2_r2(request): return json({"from": "bp2/r2"}) @bp3.get("/r1") async def bp3_r1(request): return json({"from": "bp3/r1"}) group = Blueprint.group( [bp1, bp2], url_prefix="/slash-check/", version=1.3, strict_slashes=True, ) group2 = Blueprint.group([bp3], url_prefix="/other-prefix/", version="v2", strict_slashes=False) app.blueprint(group) app.blueprint(group2) assert app.test_client.get("/v1.3/slash-check/r1")[1].status == 200 assert app.test_client.get("/v1.3/slash-check/r1/")[1].status == 200 assert app.test_client.get("/v3/slash-check/bp2/r1")[1].status == 200 assert app.test_client.get("/v3/slash-check/bp2/r1/")[1].status == 404 assert app.test_client.get("/v3/slash-check/bp2/r2")[1].status == 404 assert app.test_client.get("/v3/slash-check/bp2/r2/")[1].status == 200 assert app.test_client.get("/v2/other-prefix/bp3/r1")[1].status == 200
def test_strict_slashes_behavior_adoption(): app = Sanic("app") app.strict_slashes = True bp = Blueprint("bp") bp2 = Blueprint("bp2", strict_slashes=False) @app.get("/test") def handler_test(request): return text("Test") @app.get("/f1", strict_slashes=False) def f1(request): return text("f1") @bp.get("/one", strict_slashes=False) def one(request): return text("one") @bp.get("/second") def second(request): return text("second") @bp2.get("/third") def third(request): return text("third") app.blueprint(bp) app.blueprint(bp2) assert app.test_client.get("/test")[1].status == 200 assert app.test_client.get("/test/")[1].status == 404 assert app.test_client.get("/one")[1].status == 200 assert app.test_client.get("/one/")[1].status == 200 assert app.test_client.get("/second")[1].status == 200 assert app.test_client.get("/second/")[1].status == 404 assert app.test_client.get("/third")[1].status == 200 assert app.test_client.get("/third/")[1].status == 200 assert app.test_client.get("/f1")[1].status == 200 assert app.test_client.get("/f1/")[1].status == 200
pass else: url_bytes = b"%s?%s" % (url_bytes, environ['QUERY_STRING']) version = environ['VERSION'].decode('utf-8') method = environ['METHOD'].decode('utf-8') if app is None: app = set_request.app if transport is None: transport = DummyTransport() r = SanicRequest(url_bytes, headers, version, method, transport, app) with mock.patch.dict(extract_params.__globals__, {'request': r}): yield set_request.app = Sanic("sanic_reques_app") class UtilsTestSuite(unittest.TestCase): def test_extract_params(self): with set_request({'QUERY_STRING': b'test=foo&foo=bar'}): uri, http_method, body, headers = extract_params() self.assertEquals(uri, 'http://127.0.0.1/?test=foo&foo=bar') self.assertEquals(http_method, 'GET') self.assertEquals(body, {}) self.assertEquals(headers, Header({'Host': '127.0.0.1'})) def test_extract_params_with_urlencoded_json(self): wsgi_environ = { 'QUERY_STRING': b'state=%7B%22t%22%3A%22a%22%2C%22i%22%3A%22l%22%7D'
def test_bp_group_with_additional_route_params(app: Sanic): blueprint_1 = Blueprint("blueprint_1", url_prefix="/bp1") blueprint_2 = Blueprint("blueprint_2", url_prefix="/bp2") @blueprint_1.route( "/request_path", methods=frozenset({"PUT", "POST"}), version=2 ) def blueprint_1_v2_method_with_put_and_post(request: Request): if request.method == "PUT": return text("PUT_OK") elif request.method == "POST": return text("POST_OK") @blueprint_2.route( "/route/<param>", methods=frozenset({"DELETE", "PATCH"}), name="test" ) def blueprint_2_named_method(request: Request, param): if request.method == "DELETE": return text("DELETE_{}".format(param)) elif request.method == "PATCH": return text("PATCH_{}".format(param)) blueprint_group = Blueprint.group( blueprint_1, blueprint_2, url_prefix="/api" ) @blueprint_group.middleware("request") def authenticate_request(request: Request): global AUTH auth = request.headers.get("authorization") if auth: # Dummy auth check. We can have anything here and it's fine. if AUTH not in auth: return text("Unauthorized", status=401) else: return text("Unauthorized", status=401) @blueprint_group.middleware("response") def enhance_response_middleware(request: Request, response: HTTPResponse): response.headers.add("x-test-middleware", "value") app.blueprint(blueprint_group) header = {"authorization": " ".join(["Basic", AUTH])} _, response = app.test_client.put( "/v2/api/bp1/request_path", headers=header ) assert response.text == "PUT_OK" assert response.headers.get("x-test-middleware") == "value" _, response = app.test_client.post( "/v2/api/bp1/request_path", headers=header ) assert response.text == "POST_OK" _, response = app.test_client.delete("/api/bp2/route/bp2", headers=header) assert response.text == "DELETE_bp2" _, response = app.test_client.patch("/api/bp2/route/bp2", headers=header) assert response.text == "PATCH_bp2" _, response = app.test_client.get("/v2/api/bp1/request_path") assert response.status == 401