def user(request):
username = request.path_params["username"]
return PlainTextResponse("Hello, %s!" % username)
def test_protocol_switch(test_client_factory):
client = test_client_factory(mixed_protocol_app)
response = client.get("/")
assert response.status_code == 200
assert response.text == "URL: http://testserver/"
with client.websocket_connect("/") as session:
assert session.receive_json() == {"URL": "ws://testserver/"}
with pytest.raises(WebSocketDisconnect):
with client.websocket_connect("/404"):
pass # pragma: nocover
ok = PlainTextResponse("OK")
def test_mount_urls(test_client_factory):
mounted = Router([Mount("/users", ok, name="users")])
client = test_client_factory(mounted)
assert client.get("/users").status_code == 200
assert client.get("/users").url == "http://testserver/users/"
assert client.get("/users/").status_code == 200
assert client.get("/users/a").status_code == 200
assert client.get("/usersa").status_code == 404
def test_reverse_mount_urls():
mounted = Router([Mount("/users", ok, name="users")])
assert mounted.url_path_for("users", path="/a") == "/users/a"
def test_standalone_route_does_not_match(test_client_factory):
app = Route("/", PlainTextResponse("Hello, World!"))
client = test_client_factory(app)
response = client.get("/invalid")
assert response.status_code == 404
assert response.text == "Not Found"
async def validation_exception_handler(request, exc):
return PlainTextResponse(str(exc), status_code=400)
async def hello(request):
with async_capture_span("test"):
pass
return PlainTextResponse("ok")
def homepage(request):
return PlainTextResponse("Homepage", status_code=200)
async def database_updates(request):
num_queries = get_num_queries(request)
updates = [(row_id, randint(1, 10000))
for row_id in sample(range(1, 10000), num_queries)]
worlds = [{
'id': row_id,
'randomNumber': number
} for row_id, number in updates]
async with connection_pool.acquire() as connection:
statement = await connection.prepare(READ_ROW_SQL)
for row_id, number in updates:
await statement.fetchval(row_id)
await connection.executemany(WRITE_ROW_SQL, updates)
return JSONResponse(worlds)
routes = [
Route('/json', JSONResponse({'message': 'Hello, world!'})),
Route('/db', single_database_query),
Route('/queries', multiple_database_queries),
Route('/fortunes', fortunes),
Route('/updates', database_updates),
Route('/plaintext', PlainTextResponse(b'Hello, world!')),
]
app = Starlette(routes=routes, on_startup=[setup_database])
def homepage(request):
return PlainTextResponse("Hello, world!")
def http_exception(self, request: Request, exc: HTTPException) -> Response:
if exc.status_code in {204, 304}:
return Response(b"", status_code=exc.status_code)
return PlainTextResponse(exc.detail, status_code=exc.status_code)
async def ping(_: Request) -> Response:
return PlainTextResponse("Pong!")
def error_response(self, request: Request, exc: Exception) -> Response:
return PlainTextResponse("Internal Server Error", status_code=500)
def health(_):
return PlainTextResponse("ok")
def home(_):
return PlainTextResponse("hi")
def user_me(request):
username = "******"
return PlainTextResponse("Hello, %s!" % username)
async def plaintext():
return PlainTextResponse(b'Hello, world!')
def add_peer_get_config(peer_add: schemas.WGPeerConfigAdd,
sess: Session = Depends(middleware.get_db)):
wg_peer: schemas.WGPeer = add_peer(peer_add, sess)
return PlainTextResponse(wg_peer.configuration)
def homepage(request):
return PlainTextResponse("Homepage",
status_code=200,
headers={"Vary": "Accept-Encoding"})
async def example(request: Request) -> Response:
return PlainTextResponse("Hello, world!")
def catcher(request, exc):
return PlainTextResponse("Suppressed error", 500)
async def child(request: Request) -> Response:
tracer: Tracer = request["ddtrace_asgi.tracer"]
with tracer.trace("asgi.request.child", resource="child") as span:
span.set_tag("hello", "world")
return PlainTextResponse("Hello, child!")
def __call__(self, scope: Scope) -> ASGIInstance:
if self.methods and scope["method"] not in self.methods:
if "app" in scope:
raise HTTPException(status_code=405)
return PlainTextResponse("Method Not Allowed", status_code=405)
return self.app(scope)
def hello_world(request):
return PlainTextResponse('Hello World!!!')
async def hi_name(request):
name = request.path_params["name"]
return PlainTextResponse("Hi {}".format(name))
async def root(request):
conn = await request["connection"].get_raw_connection()
# noinspection PyProtectedMember
assert (conn._holder._max_inactive_time ==
_MAX_INACTIVE_CONNECTION_LIFETIME)
return PlainTextResponse("Hello, world!")
async def without_slash(request):
return PlainTextResponse("Hi {}".format(request.path_params["name"]))
def ok(request):
return PlainTextResponse("OK")
def test_standalone_route_matches(test_client_factory):
app = Route("/", PlainTextResponse("Hello, World!"))
client = test_client_factory(app)
response = client.get("/")
assert response.status_code == 200
assert response.text == "Hello, World!"
async def index(request):
async with aiohttp.ClientSession() as session:
data = await fetch(session, f"http://{HELLO_ADDR}")
message = greet(data["name"])
return PlainTextResponse(message)
async def hello_world(request):
return PlainTextResponse("hello, world")
async def error(request):
await localfunc('func_arg1', 'func_arg2', 1)
return PlainTextResponse("You shouldn't be seeing this")
