Browse Source
* Use ASGI root_path when it is provided and openapi_prefix is empty. * Strip trailing slashes from root_path. * Please mypy. * Fix extending openapi test. * 📝 Add docs and tutorial for using root_path behind a proxy * ♻️ Refactor application root_path logic, use root_path, deprecate openapi_prefix * ✅ Add tests for Behind a Proxy with root_path * ♻️ Refactor test * 📝 Update/add docs for Sub-applications and Behind a Proxy * 📝 Update Extending OpenAPI with openapi_prefix parameter * ✅ Add test for deprecated openapi_prefix Co-authored-by: Sebastián Ramírez <[email protected]>pull/1555/head
Ingmar Steen
5 years ago
committed by
GitHub
GitHub
16 changed files with 527 additions and 114 deletions
@ -0,0 +1,281 @@ |
|||
# Behind a Proxy |
|||
|
|||
In some situations, you might need to use a **proxy** server like Traefik or Nginx with a configuration that adds an extra path prefix that is not seen by your application. |
|||
|
|||
In these cases you can use `root_path` to configure your application. |
|||
|
|||
The `root_path` is a mechanism provided by the ASGI specification (that FastAPI is built on, through Starlette). |
|||
|
|||
The `root_path` is used to handle these specific cases. |
|||
|
|||
And it's also used internally when mounting sub-applications. |
|||
|
|||
## Proxy with a stripped path prefix |
|||
|
|||
Having a proxy with a stripped path prefix, in this case, means that you could declare a path at `/app` in your code, but then, you add a layer on top (the proxy) that would put your **FastAPI** application under a path like `/api/v1`. |
|||
|
|||
In this case, the original path `/app` would actually be served at `/api/v1/app`. |
|||
|
|||
Even though all your code is written assuming there's just `/app`. |
|||
|
|||
And the proxy would be **"stripping"** the **path prefix** on the fly before transmitting the request to Uvicorn, keep your application convinced that it is serving at `/app`, so that you don't have to update all your code to include the prefix `/api/v1`. |
|||
|
|||
Up to here, everything would work as normally. |
|||
|
|||
But then, when you open the integrated docs UI (the frontend), it would expect to get the OpenAPI schema at `/openapi.json`, instead of `/api/v1/openapi.json`. |
|||
|
|||
So, the frontend (that runs in the browser) would try to reach `/openapi.json` and wouldn't be able to get the OpenAPI schema. |
|||
|
|||
Because we have a proxy with a path prefix of `/api/v1` for our app, the frontend needs to fetch the OpenAPI schema at `/api/v1/openapi.json`. |
|||
|
|||
```mermaid |
|||
graph LR |
|||
|
|||
browser("Browser") |
|||
proxy["Proxy on http://0.0.0.0:9999/api/v1/app"] |
|||
server["Server on http://127.0.0.1:8000/app"] |
|||
|
|||
browser --> proxy |
|||
proxy --> server |
|||
``` |
|||
|
|||
!!! tip |
|||
The IP `0.0.0.0` is commonly used to mean that the program listens on all the IPs available in that machine/server. |
|||
|
|||
The docs UI would also need that the JSON payload with the OpenAPI schema has the path defined as `/api/v1/app` (behind the proxy) instead of `/app`. For example, something like: |
|||
|
|||
```JSON hl_lines="5" |
|||
{ |
|||
"openapi": "3.0.2", |
|||
// More stuff here |
|||
"paths": { |
|||
"/api/v1/app": { |
|||
// More stuff here |
|||
} |
|||
} |
|||
} |
|||
``` |
|||
|
|||
In this example, the "Proxy" could be something like **Traefik**. And the server would be something like **Uvicorn**, running your FastAPI application. |
|||
|
|||
### Providing the `root_path` |
|||
|
|||
To achieve this, you can use the command line option `--root-path` like: |
|||
|
|||
<div class="termy"> |
|||
|
|||
```console |
|||
$ uvicorn main:app --root-path /api/v1 |
|||
|
|||
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
|||
``` |
|||
|
|||
</div> |
|||
|
|||
If you use Hypercorn, it also has the option `--root-path`. |
|||
|
|||
!!! note "Technical Details" |
|||
The ASGI specification defines a `root_path` for this use case. |
|||
|
|||
And the `--root-path` command line option provides that `root_path`. |
|||
|
|||
### Checking the current `root_path` |
|||
|
|||
You can get the current `root_path` used by your application for each request, it is part of the `scope` dictionary (that's part of the ASGI spec). |
|||
|
|||
Here we are including it in the message just for demonstration purposes. |
|||
|
|||
```Python hl_lines="8" |
|||
{!../../../docs_src/behind_a_proxy/tutorial001.py!} |
|||
``` |
|||
|
|||
Then, if you start Uvicorn with: |
|||
|
|||
<div class="termy"> |
|||
|
|||
```console |
|||
$ uvicorn main:app --root-path /api/v1 |
|||
|
|||
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
|||
``` |
|||
|
|||
</div> |
|||
|
|||
The response would be something like: |
|||
|
|||
```JSON |
|||
{ |
|||
"message": "Hello World", |
|||
"root_path": "/api/v1" |
|||
} |
|||
``` |
|||
|
|||
### Setting the `root_path` in the FastAPI app |
|||
|
|||
Alternatively, if you don't have a way to provide a command line option like `--root-path` or equivalent, you can set the `root_path` parameter when creating your FastAPI app: |
|||
|
|||
```Python hl_lines="3" |
|||
{!../../../docs_src/behind_a_proxy/tutorial002.py!} |
|||
``` |
|||
|
|||
Passing the `root_path` to `FastAPI` would be the equivalent of passing the `--root-path` command line option to Uvicorn or Hypercorn. |
|||
|
|||
### About `root_path` |
|||
|
|||
Have in mind that the server (Uvicorn) won't use that `root_path` for anything else than passing it to the app. |
|||
|
|||
But if you go with your browser to <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000/app</a> you will see the normal response: |
|||
|
|||
```JSON |
|||
{ |
|||
"message": "Hello World", |
|||
"root_path": "/api/v1" |
|||
} |
|||
``` |
|||
|
|||
So, it won't expect to be accessed at `http://127.0.0.1:8000/api/v1/app`. |
|||
|
|||
Uvicorn will expect the proxy to access Uvicorn at `http://127.0.0.1:8000/app`, and then it would be the proxy's responsibility to add the extra `/api/v1` prefix on top. |
|||
|
|||
## About proxies with a stripped path prefix |
|||
|
|||
Have in mind that a proxy with stripped path prefix is only one of the ways to configure it. |
|||
|
|||
Probably in many cases the default will be that the proxy doesn't have a stripped path prefix. |
|||
|
|||
In a case like that (without a stripped path prefix), the proxy would listen on something like `https://myawesomeapp.com`, and then if the browser goes to `https://myawesomeapp.com/api/v1/app` and your server (e.g. Uvicorn) listens on `http://127.0.0.1:8000` the proxy (without a stripped path prefix) would access Uvicorn at the same path: `http://127.0.0.1:8000/api/v1/app`. |
|||
|
|||
## Testing locally with Traefik |
|||
|
|||
You can easily run the experiment locally with a stripped path prefix using <a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a>. |
|||
|
|||
<a href="https://github.com/containous/traefik/releases" class="external-link" target="_blank">Download Traefik</a>, it's a single binary, you can extract the compressed file and run it directly from the terminal. |
|||
|
|||
Then create a file `traefik.toml` with: |
|||
|
|||
```TOML hl_lines="3" |
|||
[entryPoints] |
|||
[entryPoints.http] |
|||
address = ":9999" |
|||
|
|||
[providers] |
|||
[providers.file] |
|||
filename = "routes.toml" |
|||
``` |
|||
|
|||
This tells Traefik to listen on port 9999 and to use another file `routes.toml`. |
|||
|
|||
!!! tip |
|||
We are using port 9999 instead of the standard HTTP port 80 so that you don't have to run it with admin (`sudo`) privileges. |
|||
|
|||
Now create that other file `routes.toml`: |
|||
|
|||
```TOML hl_lines="5 12 20" |
|||
[http] |
|||
[http.middlewares] |
|||
|
|||
[http.middlewares.api-stripprefix.stripPrefix] |
|||
prefixes = ["/api/v1"] |
|||
|
|||
[http.routers] |
|||
|
|||
[http.routers.app-http] |
|||
entryPoints = ["http"] |
|||
service = "app" |
|||
rule = "PathPrefix(`/api/v1`)" |
|||
middlewares = ["api-stripprefix"] |
|||
|
|||
[http.services] |
|||
|
|||
[http.services.app] |
|||
[http.services.app.loadBalancer] |
|||
[[http.services.app.loadBalancer.servers]] |
|||
url = "http://127.0.0.1:8000" |
|||
``` |
|||
|
|||
This file configures Traefik to use the path prefix `/api/v1`. |
|||
|
|||
And then it will redirect its requests to your Uvicorn running on `http://127.0.0.1:8000`. |
|||
|
|||
Now start Traefik: |
|||
|
|||
<div class="termy"> |
|||
|
|||
```console |
|||
$ ./traefik --configFile=traefik.toml |
|||
|
|||
INFO[0000] Configuration loaded from file: /home/user/awesomeapi/traefik.toml |
|||
``` |
|||
|
|||
</div> |
|||
|
|||
And now start your app with Uvicorn, using the `--root-path` option: |
|||
|
|||
<div class="termy"> |
|||
|
|||
```console |
|||
$ uvicorn main:app --root-path /api/v1 |
|||
|
|||
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
|||
``` |
|||
|
|||
</div> |
|||
|
|||
### Check the responses |
|||
|
|||
Now, if you go to the URL with the port for Uvicorn: <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a>, you will see the normal response: |
|||
|
|||
```JSON |
|||
{ |
|||
"message": "Hello World", |
|||
"root_path": "/api/v1" |
|||
} |
|||
``` |
|||
|
|||
!!! tip |
|||
Notice that even though you are accessing it at `http://127.0.0.1:8000/app` it shows the `root_path` of `/api/v1`, taken from the option `--root-path`. |
|||
|
|||
And now open the URL with the port for Traefik, including the path prefix: <a href="http://127.0.0.1:9999/api/v1/app" class="external-link" target="_blank">http://127.0.0.1:9999/api/vi/app</a>. |
|||
|
|||
We get the same response: |
|||
|
|||
```JSON |
|||
{ |
|||
"message": "Hello World", |
|||
"root_path": "/api/v1" |
|||
} |
|||
``` |
|||
|
|||
but this time at the URL with the prefix path provided by the proxy: `/api/v1`. |
|||
|
|||
Of course, the idea here is that everyone would access the app through the proxy, so the version with the path prefix `/app/v1` is the "correct" one. |
|||
|
|||
And the version without the path prefix (`http://127.0.0.1:8000/app`), provided by Uvicorn directly, would be exclusively for the _proxy_ (Traefik) to access it. |
|||
|
|||
That demonstrates how the Proxy (Traefik) uses the path prefix and how the server (Uvicorn) uses the `root_path` from the option `--root-path`. |
|||
|
|||
### Check the docs UI |
|||
|
|||
But here's the fun part. ✨ |
|||
|
|||
The "official" way to access the app would be through the proxy with the path prefix that we defined. So, as we would expect, if you try the docs UI served by Uvicorn directly, without the path prefix in the URL, it won't work, because it expects to be accessed through the proxy. |
|||
|
|||
You can check it at <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>: |
|||
|
|||
<img src="/img/tutorial/behind-a-proxy/image01.png"> |
|||
|
|||
But if we access the docs UI at the "official" URL using the proxy, at `/api/v1/docs`, it works correctly! 🎉 |
|||
|
|||
Right as we wanted it. ✔️ |
|||
|
|||
This is because FastAPI uses this `root_path` internally to tell the docs UI to use the URL for OpenAPI with the path prefix provided by `root_path`. |
|||
|
|||
You can check it at <a href="http://127.0.0.1:9999/api/v1/docs" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/docs</a>: |
|||
|
|||
<img src="/img/tutorial/behind-a-proxy/image02.png"> |
|||
|
|||
## Mounting a sub-application |
|||
|
|||
If you need to mount a sub-application (as described in [Sub Applications - Mounts](./sub-applications.md){.internal-link target=_blank}) while also using a proxy with `root_path`, you can do it normally, as you would expect. |
|||
|
|||
FastAPI will internally use the `root_path` smartly, so it will just work. ✨ |
|||
@ -1,100 +0,0 @@ |
|||
# Sub Applications - Behind a Proxy, Mounts |
|||
|
|||
There are at least two situations where you could need to create your **FastAPI** application using some specific paths. |
|||
|
|||
But then you need to set them up to be served with a path prefix. |
|||
|
|||
It could happen if you have a: |
|||
|
|||
* **Proxy** server. |
|||
* You are "**mounting**" a FastAPI application inside another FastAPI application (or inside another ASGI application, like Starlette). |
|||
|
|||
## Proxy |
|||
|
|||
Having a proxy in this case means that you could declare a path at `/app`, but then, you could need to add a layer on top (the Proxy) that would put your **FastAPI** application under a path like `/api/v1`. |
|||
|
|||
In this case, the original path `/app` will actually be served at `/api/v1/app`. |
|||
|
|||
Even though your application "thinks" it is serving at `/app`. |
|||
|
|||
And the Proxy could be re-writing the path "on the fly" to keep your application convinced that it is serving at `/app`. |
|||
|
|||
Up to here, everything would work as normally. |
|||
|
|||
But then, when you open the integrated docs, they would expect to get the OpenAPI schema at `/openapi.json`, instead of `/api/v1/openapi.json`. |
|||
|
|||
So, the frontend (that runs in the browser) would try to reach `/openapi.json` and wouldn't be able to get the OpenAPI schema. |
|||
|
|||
So, it's needed that the frontend looks for the OpenAPI schema at `/api/v1/openapi.json`. |
|||
|
|||
And it's also needed that the returned JSON OpenAPI schema has the defined path at `/api/v1/app` (behind the proxy) instead of `/app`. |
|||
|
|||
--- |
|||
|
|||
For these cases, you can declare an `openapi_prefix` parameter in your `FastAPI` application. |
|||
|
|||
See the section below, about "mounting", for an example. |
|||
|
|||
## Mounting a **FastAPI** application |
|||
|
|||
"Mounting" means adding a complete "independent" application in a specific path, that then takes care of handling all the sub-paths. |
|||
|
|||
You could want to do this if you have several "independent" applications that you want to separate, having their own independent OpenAPI schema and user interfaces. |
|||
|
|||
### Top-level application |
|||
|
|||
First, create the main, top-level, **FastAPI** application, and its *path operations*: |
|||
|
|||
```Python hl_lines="3 6 7 8" |
|||
{!../../../docs_src/sub_applications/tutorial001.py!} |
|||
``` |
|||
|
|||
### Sub-application |
|||
|
|||
Then, create your sub-application, and its *path operations*. |
|||
|
|||
This sub-application is just another standard FastAPI application, but this is the one that will be "mounted". |
|||
|
|||
When creating the sub-application, use the parameter `openapi_prefix`. In this case, with a prefix of `/subapi`: |
|||
|
|||
```Python hl_lines="11 14 15 16" |
|||
{!../../../docs_src/sub_applications/tutorial001.py!} |
|||
``` |
|||
|
|||
### Mount the sub-application |
|||
|
|||
In your top-level application, `app`, mount the sub-application, `subapi`. |
|||
|
|||
Here you need to make sure you use the same path that you used for the `openapi_prefix`, in this case, `/subapi`: |
|||
|
|||
```Python hl_lines="11 19" |
|||
{!../../../docs_src/sub_applications/tutorial001.py!} |
|||
``` |
|||
|
|||
## Check the automatic API docs |
|||
|
|||
Now, run `uvicorn`, if your file is at `main.py`, it would be: |
|||
|
|||
<div class="termy"> |
|||
|
|||
```console |
|||
$ uvicorn main:app --reload |
|||
|
|||
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
|||
``` |
|||
|
|||
</div> |
|||
|
|||
And open the docs at <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>. |
|||
|
|||
You will see the automatic API docs for the main app, including only its own paths: |
|||
|
|||
<img src="/img/tutorial/sub-applications/image01.png"> |
|||
|
|||
And then, open the docs for the sub-application, at <a href="http://127.0.0.1:8000/subapi/docs" class="external-link" target="_blank">http://127.0.0.1:8000/subapi/docs</a>. |
|||
|
|||
You will see the automatic API docs for the sub-application, including only its own sub-paths, with their correct prefix: |
|||
|
|||
<img src="/img/tutorial/sub-applications/image02.png"> |
|||
|
|||
If you try interacting with any of the two user interfaces, they will work, because the browser will be able to talk to the correct path (or sub-path). |
|||
@ -0,0 +1,73 @@ |
|||
# Sub Applications - Mounts |
|||
|
|||
If you need to have two independent FastAPI applications, with their own independent OpenAPI and their own docs UIs, you can have a main app and "mount" one (or more) sub-application(s). |
|||
|
|||
## Mounting a **FastAPI** application |
|||
|
|||
"Mounting" means adding a completely "independent" application in a specific path, that then takes care of handling all everything under that path, with the _path operations_ declared in that sub-application. |
|||
|
|||
### Top-level application |
|||
|
|||
First, create the main, top-level, **FastAPI** application, and its *path operations*: |
|||
|
|||
```Python hl_lines="3 6 7 8" |
|||
{!../../../docs_src/sub_applications/tutorial001.py!} |
|||
``` |
|||
|
|||
### Sub-application |
|||
|
|||
Then, create your sub-application, and its *path operations*. |
|||
|
|||
This sub-application is just another standard FastAPI application, but this is the one that will be "mounted": |
|||
|
|||
```Python hl_lines="11 14 15 16" |
|||
{!../../../docs_src/sub_applications/tutorial001.py!} |
|||
``` |
|||
|
|||
### Mount the sub-application |
|||
|
|||
In your top-level application, `app`, mount the sub-application, `subapi`. |
|||
|
|||
In this case, it will be mounted at the path `/subapi`: |
|||
|
|||
```Python hl_lines="11 19" |
|||
{!../../../docs_src/sub_applications/tutorial001.py!} |
|||
``` |
|||
|
|||
### Check the automatic API docs |
|||
|
|||
Now, run `uvicorn` with the main app, if your file is `main.py`, it would be: |
|||
|
|||
<div class="termy"> |
|||
|
|||
```console |
|||
$ uvicorn main:app --reload |
|||
|
|||
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
|||
``` |
|||
|
|||
</div> |
|||
|
|||
And open the docs at <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>. |
|||
|
|||
You will see the automatic API docs for the main app, including only its own _path operations_: |
|||
|
|||
<img src="/img/tutorial/sub-applications/image01.png"> |
|||
|
|||
And then, open the docs for the sub-application, at <a href="http://127.0.0.1:8000/subapi/docs" class="external-link" target="_blank">http://127.0.0.1:8000/subapi/docs</a>. |
|||
|
|||
You will see the automatic API docs for the sub-application, including only its own _path operations_, all under the correct sub-path prefix `/subapi`: |
|||
|
|||
<img src="/img/tutorial/sub-applications/image02.png"> |
|||
|
|||
If you try interacting with any of the two user interfaces, they will work correctly, because the browser will be able to talk to each specific app or sub-app. |
|||
|
|||
### Technical Details: `root_path` |
|||
|
|||
When you mount a sub-application as described above, FastAPI will take care of communicating the mount path for the sub-application using a mechanism from the ASGI specification called a `root_path`. |
|||
|
|||
That way, the sub-application will know to use that path prefix for the docs UI. |
|||
|
|||
And the sub-application could also have its own mounted sub-applications and everything would work correctly, because FastAPI handles all these `root_path`s automatically. |
|||
|
|||
You will learn more about the `root_path` and how to use it explicitly in the section about [Behind a Proxy](./behind-a-proxy.md){.internal-link target=_blank}. |
|||
|
After Width: | Height: | Size: 59 KiB |
|
After Width: | Height: | Size: 28 KiB |
@ -0,0 +1,8 @@ |
|||
from fastapi import FastAPI, Request |
|||
|
|||
app = FastAPI() |
|||
|
|||
|
|||
@app.get("/app") |
|||
def read_main(request: Request): |
|||
return {"message": "Hello World", "root_path": request.scope.get("root_path")} |
|||
@ -0,0 +1,8 @@ |
|||
from fastapi import FastAPI, Request |
|||
|
|||
app = FastAPI(root_path="/api/v1") |
|||
|
|||
|
|||
@app.get("/app") |
|||
def read_main(request: Request): |
|||
return {"message": "Hello World", "root_path": request.scope.get("root_path")} |
|||
@ -0,0 +1,43 @@ |
|||
from fastapi import FastAPI, Request |
|||
from fastapi.testclient import TestClient |
|||
|
|||
app = FastAPI(openapi_prefix="/api/v1") |
|||
|
|||
|
|||
@app.get("/app") |
|||
def read_main(request: Request): |
|||
return {"message": "Hello World", "root_path": request.scope.get("root_path")} |
|||
|
|||
|
|||
client = TestClient(app) |
|||
|
|||
openapi_schema = { |
|||
"openapi": "3.0.2", |
|||
"info": {"title": "FastAPI", "version": "0.1.0"}, |
|||
"paths": { |
|||
"/api/v1/app": { |
|||
"get": { |
|||
"summary": "Read Main", |
|||
"operationId": "read_main_app_get", |
|||
"responses": { |
|||
"200": { |
|||
"description": "Successful Response", |
|||
"content": {"application/json": {"schema": {}}}, |
|||
} |
|||
}, |
|||
} |
|||
} |
|||
}, |
|||
} |
|||
|
|||
|
|||
def test_openapi(): |
|||
response = client.get("/openapi.json") |
|||
assert response.status_code == 200 |
|||
assert response.json() == openapi_schema |
|||
|
|||
|
|||
def test_main(): |
|||
response = client.get("/app") |
|||
assert response.status_code == 200 |
|||
assert response.json() == {"message": "Hello World", "root_path": "/api/v1"} |
|||
@ -0,0 +1,36 @@ |
|||
from fastapi.testclient import TestClient |
|||
|
|||
from behind_a_proxy.tutorial001 import app |
|||
|
|||
client = TestClient(app, root_path="/api/v1") |
|||
|
|||
openapi_schema = { |
|||
"openapi": "3.0.2", |
|||
"info": {"title": "FastAPI", "version": "0.1.0"}, |
|||
"paths": { |
|||
"/api/v1/app": { |
|||
"get": { |
|||
"summary": "Read Main", |
|||
"operationId": "read_main_app_get", |
|||
"responses": { |
|||
"200": { |
|||
"description": "Successful Response", |
|||
"content": {"application/json": {"schema": {}}}, |
|||
} |
|||
}, |
|||
} |
|||
} |
|||
}, |
|||
} |
|||
|
|||
|
|||
def test_openapi(): |
|||
response = client.get("/openapi.json") |
|||
assert response.status_code == 200 |
|||
assert response.json() == openapi_schema |
|||
|
|||
|
|||
def test_main(): |
|||
response = client.get("/app") |
|||
assert response.status_code == 200 |
|||
assert response.json() == {"message": "Hello World", "root_path": "/api/v1"} |
|||
@ -0,0 +1,36 @@ |
|||
from fastapi.testclient import TestClient |
|||
|
|||
from behind_a_proxy.tutorial002 import app |
|||
|
|||
client = TestClient(app) |
|||
|
|||
openapi_schema = { |
|||
"openapi": "3.0.2", |
|||
"info": {"title": "FastAPI", "version": "0.1.0"}, |
|||
"paths": { |
|||
"/api/v1/app": { |
|||
"get": { |
|||
"summary": "Read Main", |
|||
"operationId": "read_main_app_get", |
|||
"responses": { |
|||
"200": { |
|||
"description": "Successful Response", |
|||
"content": {"application/json": {"schema": {}}}, |
|||
} |
|||
}, |
|||
} |
|||
} |
|||
}, |
|||
} |
|||
|
|||
|
|||
def test_openapi(): |
|||
response = client.get("/openapi.json") |
|||
assert response.status_code == 200 |
|||
assert response.json() == openapi_schema |
|||
|
|||
|
|||
def test_main(): |
|||
response = client.get("/app") |
|||
assert response.status_code == 200 |
|||
assert response.json() == {"message": "Hello World", "root_path": "/api/v1"} |
|||
Loading…
Reference in new issue