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_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
