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_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_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 __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 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 create_auxiliary_app():
app = Sanic("SANIC_DEV_AUX_APP")
@app.route("/")
def aux_home(request):
return json({"status": "ok"})
return 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 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 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_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 __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 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
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'
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()
import asyncio
from sanic.app import Sanic
from sanic.response import json
from sanic.response import stream
import yaaredis
app = Sanic()
@app.route('/')
async def test(_request):
return json({'hello': 'world'})
@app.route('/notifications')
async def notification(_request):
async def _stream(res):
redis = yaaredis.StrictRedis()
pub = redis.pubsub()
await pub.subscribe('test')
end_time = app.loop.time() + 30
while app.loop.time() < end_time:
await redis.publish('test', 111)
message = None
while not message:
message = await pub.get_message()
res.write(message)
await asyncio.sleep(0.1)
from sanic.app import Sanic from service_api import api_v1 from service_api.config import runtime_config from service_api.constants import DEFAULT_SERVICE_NAME from service_api.exceptions import setup_exception_handler app = Sanic(DEFAULT_SERVICE_NAME) app.config.from_object(runtime_config()) api_v1.load_api(app) setup_exception_handler(app)
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(__name__)
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, {'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'