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 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_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_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"
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
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
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 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 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 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 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_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_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 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
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_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_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_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_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_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
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
bp = Blueprint('my_blueprint')
@bp.route('/')
async def bp_root(request):
return json({'my': 'blueprint'})
@bp.middleware
async def print_on_request(request):
print("I am a spy")
@bp.middleware('request')
async def halt_request(request):
print('I halted the request')
@bp.middleware('response')
async def halt_response(request, response):
print('I halted the response')
@bp.exception(NotFound)
def ignore_404s(request, exception):
return text("Yep, I totally found the page: {}".format(request.url))
if __name__ == '__main__':
app.blueprint(bp)
app.run()
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(f"DELETE_{param}")
elif request.method == "PATCH":
return text(f"PATCH_{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.put("/v2/api/bp1/request_path")
assert response.status == 401
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
from ManjiApi.response import Response
from ManjiApi.sanic import ManjiApi
from ManjiApi.request.base import BaseRequest
from ManjiApi.request.frame_data import FrameDataRequest
from ManjiApi.request.yoshimitsu_gallery import YoshiGallRequest
from ManjiApi.api import api_endpoint
from aiohttp.client import ClientSession
from asyncio.events import AbstractEventLoop
from sanic.app import Sanic
manjiapi = Sanic("ManjiApi")
manjiapi.blueprint(api_endpoint)
@manjiapi.main_process_start
async def start(manjiapi: ManjiApi, loop: AbstractEventLoop) -> None:
manjiapi.config.FALLBACK_ERROR_FORMAT = "json"
manjiapi.ctx.base_request = BaseRequest(ClientSession())
manjiapi.ctx.yoshigall_request = await YoshiGallRequest.setup()
manjiapi.ctx.framedata_request = await FrameDataRequest.setup()
manjiapi.ctx.response = Response
@manjiapi.main_process_stop
async def stop(manjiapi: ManjiApi, loop: AbstractEventLoop) -> None:
await manjiapi.ctx.base_request.close()
await manjiapi.ctx.yoshigall_request.close()
await manjiapi.ctx.framedata_request.close()
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_1.route("/invalid")
def blueprint_1_error(request: Request):
raise InvalidUsage("Invalid")
@blueprint_2.route("/")
def blueprint_2_default_route(request):
return text("BP2_OK")
@blueprint_2.route("/error")
def blueprint_2_error(request: Request):
raise ServerError("Error")
blueprint_group_1 = Blueprint.group(
blueprint_1, blueprint_2, url_prefix="/bp"
)
blueprint_3 = Blueprint("blueprint_3", url_prefix="/bp3")
@blueprint_group_1.exception(InvalidUsage)
def handle_group_exception(request, exception):
return text("BP1_ERR_OK")
@blueprint_group_1.middleware("request")
def blueprint_group_1_middleware(request):
global MIDDLEWARE_INVOKE_COUNTER
MIDDLEWARE_INVOKE_COUNTER["request"] += 1
@blueprint_group_1.middleware
def blueprint_group_1_middleware_not_called(request):
global MIDDLEWARE_INVOKE_COUNTER
MIDDLEWARE_INVOKE_COUNTER["request"] += 1
@blueprint_group_1.on_request
def blueprint_group_1_convenience_1(request):
global MIDDLEWARE_INVOKE_COUNTER
MIDDLEWARE_INVOKE_COUNTER["request"] += 1
@blueprint_group_1.on_request()
def blueprint_group_1_convenience_2(request):
global MIDDLEWARE_INVOKE_COUNTER
MIDDLEWARE_INVOKE_COUNTER["request"] += 1
@blueprint_3.route("/")
def blueprint_3_default_route(request):
return text("BP3_OK")
@blueprint_3.route("/forbidden")
def blueprint_3_forbidden(request: Request):
raise Forbidden("Forbidden")
blueprint_group_2 = Blueprint.group(
blueprint_group_1, blueprint_3, url_prefix="/api"
)
@blueprint_group_2.exception(SanicException)
def handle_non_handled_exception(request, exception):
return text("BP2_ERR_OK")
@blueprint_group_2.middleware("response")
def blueprint_group_2_middleware(request, response):
global MIDDLEWARE_INVOKE_COUNTER
MIDDLEWARE_INVOKE_COUNTER["response"] += 1
@blueprint_group_2.on_response
def blueprint_group_2_middleware_convenience_1(request, response):
global MIDDLEWARE_INVOKE_COUNTER
MIDDLEWARE_INVOKE_COUNTER["response"] += 1
@blueprint_group_2.on_response()
def blueprint_group_2_middleware_convenience_2(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/bp1/invalid")
assert response.text == "BP1_ERR_OK"
_, response = app.test_client.get("/api/bp/bp2")
assert response.text == "BP2_OK"
_, response = app.test_client.get("/api/bp/bp2/error")
assert response.text == "BP2_ERR_OK"
_, response = app.test_client.get("/api/bp3")
assert response.text == "BP3_OK"
_, response = app.test_client.get("/api/bp3/forbidden")
assert response.text == "BP2_ERR_OK"
assert MIDDLEWARE_INVOKE_COUNTER["response"] == 18
assert MIDDLEWARE_INVOKE_COUNTER["request"] == 16
