From cb1410426e11886825fece1cdc10a781bbfd57b2 Mon Sep 17 00:00:00 2001 From: James Kaplan Date: Wed, 8 Jan 2020 13:22:14 -0800 Subject: [PATCH] :bug: Fix callback handling in sub-routers (#792) --- docs/src/openapi_callbacks/tutorial001.py | 3 +- docs/tutorial/openapi-callbacks.md | 6 +- fastapi/routing.py | 1 + tests/test_sub_callbacks.py | 230 ++++++++++++++++++++++ 4 files changed, 235 insertions(+), 5 deletions(-) create mode 100644 tests/test_sub_callbacks.py diff --git a/docs/src/openapi_callbacks/tutorial001.py b/docs/src/openapi_callbacks/tutorial001.py index b2838b0a2..717e981f8 100644 --- a/docs/src/openapi_callbacks/tutorial001.py +++ b/docs/src/openapi_callbacks/tutorial001.py @@ -25,8 +25,7 @@ invoices_callback_router = APIRouter(default_response_class=JSONResponse) @invoices_callback_router.post( - "{$callback_url}/invoices/{$request.body.id}", - response_model=InvoiceEventReceived, + "{$callback_url}/invoices/{$request.body.id}", response_model=InvoiceEventReceived, ) def invoice_notification(body: InvoiceEvent): pass diff --git a/docs/tutorial/openapi-callbacks.md b/docs/tutorial/openapi-callbacks.md index e48ee7f95..311767a6b 100644 --- a/docs/tutorial/openapi-callbacks.md +++ b/docs/tutorial/openapi-callbacks.md @@ -29,7 +29,7 @@ It will have a *path operation* that will receive an `Invoice` body, and a query This part is pretty normal, most of the code is probably already familiar to you: -```Python hl_lines="8 9 10 11 12 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54" +```Python hl_lines="8 9 10 11 12 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53" {!./src/openapi_callbacks/tutorial001.py!} ``` @@ -103,7 +103,7 @@ It should look just like a normal FastAPI *path operation*: * It should probably have a declaration of the body it should receive, e.g. `body: InvoiceEvent`. * And it could also have a declaration of the response it should return, e.g. `response_model=InvoiceEventReceived`. -```Python hl_lines="15 16 17 20 21 27 28 29 30 31 32" +```Python hl_lines="15 16 17 20 21 27 28 29 30 31" {!./src/openapi_callbacks/tutorial001.py!} ``` @@ -170,7 +170,7 @@ At this point you have the *callback path operation(s)* needed (the one(s) that Now use the parameter `callbacks` in *your API's path operation decorator* to pass the attribute `.routes` (that's actually just a `list` of routes/*path operations*) from that callback router: -```Python hl_lines="35" +```Python hl_lines="34" {!./src/openapi_callbacks/tutorial001.py!} ``` diff --git a/fastapi/routing.py b/fastapi/routing.py index ee75374b4..4e08c61b7 100644 --- a/fastapi/routing.py +++ b/fastapi/routing.py @@ -554,6 +554,7 @@ class APIRouter(routing.Router): response_class=route.response_class or default_response_class, name=route.name, route_class_override=type(route), + callbacks=route.callbacks, ) elif isinstance(route, routing.Route): self.add_route( diff --git a/tests/test_sub_callbacks.py b/tests/test_sub_callbacks.py new file mode 100644 index 000000000..5391a665d --- /dev/null +++ b/tests/test_sub_callbacks.py @@ -0,0 +1,230 @@ +from fastapi import APIRouter, FastAPI +from pydantic import BaseModel, HttpUrl +from starlette.responses import JSONResponse +from starlette.testclient import TestClient + +app = FastAPI() + + +class Invoice(BaseModel): + id: str + title: str = None + customer: str + total: float + + +class InvoiceEvent(BaseModel): + description: str + paid: bool + + +class InvoiceEventReceived(BaseModel): + ok: bool + + +invoices_callback_router = APIRouter(default_response_class=JSONResponse) + + +@invoices_callback_router.post( + "{$callback_url}/invoices/{$request.body.id}", response_model=InvoiceEventReceived, +) +def invoice_notification(body: InvoiceEvent): + pass + + +subrouter = APIRouter() + + +@subrouter.post("/invoices/", callbacks=invoices_callback_router.routes) +def create_invoice(invoice: Invoice, callback_url: HttpUrl = None): + """ + Create an invoice. + + This will (let's imagine) let the API user (some external developer) create an + invoice. + + And this path operation will: + + * Send the invoice to the client. + * Collect the money from the client. + * Send a notification back to the API user (the external developer), as a callback. + * At this point is that the API will somehow send a POST request to the + external API with the notification of the invoice event + (e.g. "payment successful"). + """ + # Send the invoice, collect the money, send the notification (the callback) + return {"msg": "Invoice received"} + + +app.include_router(subrouter) + +client = TestClient(app) + +openapi_schema = { + "openapi": "3.0.2", + "info": {"title": "Fast API", "version": "0.1.0"}, + "paths": { + "/invoices/": { + "post": { + "summary": "Create Invoice", + "description": 'Create an invoice.\n\nThis will (let\'s imagine) let the API user (some external developer) create an\ninvoice.\n\nAnd this path operation will:\n\n* Send the invoice to the client.\n* Collect the money from the client.\n* Send a notification back to the API user (the external developer), as a callback.\n * At this point is that the API will somehow send a POST request to the\n external API with the notification of the invoice event\n (e.g. "payment successful").', + "operationId": "create_invoice_invoices__post", + "parameters": [ + { + "required": False, + "schema": { + "title": "Callback Url", + "maxLength": 2083, + "minLength": 1, + "type": "string", + "format": "uri", + }, + "name": "callback_url", + "in": "query", + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": {"$ref": "#/components/schemas/Invoice"} + } + }, + "required": True, + }, + "responses": { + "200": { + "description": "Successful Response", + "content": {"application/json": {"schema": {}}}, + }, + "422": { + "description": "Validation Error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + }, + }, + "callbacks": { + "invoice_notification": { + "{$callback_url}/invoices/{$request.body.id}": { + "post": { + "summary": "Invoice Notification", + "operationId": "invoice_notification__callback_url__invoices___request_body_id__post", + "requestBody": { + "required": True, + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/InvoiceEvent" + } + } + }, + }, + "responses": { + "200": { + "description": "Successful Response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/InvoiceEventReceived" + } + } + }, + }, + "422": { + "description": "Validation Error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + }, + }, + } + } + } + }, + } + } + }, + "components": { + "schemas": { + "HTTPValidationError": { + "title": "HTTPValidationError", + "type": "object", + "properties": { + "detail": { + "title": "Detail", + "type": "array", + "items": {"$ref": "#/components/schemas/ValidationError"}, + } + }, + }, + "Invoice": { + "title": "Invoice", + "required": ["id", "customer", "total"], + "type": "object", + "properties": { + "id": {"title": "Id", "type": "string"}, + "title": {"title": "Title", "type": "string"}, + "customer": {"title": "Customer", "type": "string"}, + "total": {"title": "Total", "type": "number"}, + }, + }, + "InvoiceEvent": { + "title": "InvoiceEvent", + "required": ["description", "paid"], + "type": "object", + "properties": { + "description": {"title": "Description", "type": "string"}, + "paid": {"title": "Paid", "type": "boolean"}, + }, + }, + "InvoiceEventReceived": { + "title": "InvoiceEventReceived", + "required": ["ok"], + "type": "object", + "properties": {"ok": {"title": "Ok", "type": "boolean"}}, + }, + "ValidationError": { + "title": "ValidationError", + "required": ["loc", "msg", "type"], + "type": "object", + "properties": { + "loc": { + "title": "Location", + "type": "array", + "items": {"type": "string"}, + }, + "msg": {"title": "Message", "type": "string"}, + "type": {"title": "Error Type", "type": "string"}, + }, + }, + } + }, +} + + +def test_openapi(): + with client: + response = client.get("/openapi.json") + + assert response.json() == openapi_schema + + +def test_get(): + response = client.post( + "/invoices/", json={"id": "fooinvoice", "customer": "John", "total": 5.3} + ) + assert response.status_code == 200 + assert response.json() == {"msg": "Invoice received"} + + +def test_dummy_callback(): + # Just for coverage + invoice_notification({})