<img src="/img/async/parallel-burgers/parallel-burgers-03.png" class="illustration">

Como você e seu _crush_ estão ocupados não permitindo que ninguém passe na frente e pegue seus hambúrgueres assim que estiverem prontos, você não pode dar atenção ao seu _crush_. 😞

│   ├── main.py
│   └── test_main.py
```

O arquivo `main.py` teria:

{* ../../docs_src/async_tests/app_a_py310/main.py *}

O arquivo `test_main.py` teria os testes para para o arquivo `main.py`, ele poderia ficar assim:

{* ../../docs_src/async_tests/app_a_py310/test_main.py *}

## Executá-lo { #run-it }

Você pode executar os seus testes normalmente via:

<div class="termy">

```console
$ pytest

---> 100%

/// tip | Dica

Normalmente você terá um desempenho muito melhor usando um [Modelo de resposta](../tutorial/response-model.md) do que retornando uma `JSONResponse` diretamente, pois assim ele serializa os dados usando o Pydantic, em Rust.

///

## Retornando uma `Response` { #return-a-response }

Você pode retornar uma `Response` ou qualquer subclasse dela.

/// info | Informação

```Python
say_hi()  # Ah, não, isso gera um erro! 😱
```

O parâmetro `name` continua obrigatório (não é opcional) porque não tem valor padrão. Ainda assim, `name` aceita `None` como valor:

```Python
say_hi(name=None)  # Isso funciona, None é válido 🎉
```

A boa notícia é que, na maioria dos casos, você poderá simplesmente usar `|` para definir uniões de tipos:

Usando apenas `BackgroundTasks` (e não `BackgroundTask`), é possível usá-la como um parâmetro de *função de operação de rota* e deixar o **FastAPI** cuidar do resto para você, assim como ao usar o objeto `Request` diretamente.

Ainda é possível usar `BackgroundTask` sozinho no FastAPI, mas você precisa criar o objeto no seu código e retornar uma `Response` da Starlette incluindo-o.

SSE é um padrão para transmitir dados do servidor para o cliente via HTTP.

Cada evento é um pequeno bloco de texto com “campos” como `data`, `event`, `id` e `retry`, separados por linhas em branco.

Fica assim:

```
data: {"name": "Portal Gun", "price": 999.99}

data: {"name": "Plumbus", "price": 32.99}

```

Por exemplo, se você tem um parâmetro de cabeçalho `save_data` no código, o cabeçalho HTTP esperado será `save-data`, e ele aparecerá assim na documentação.

Se por algum motivo você precisar desativar essa conversão automática, também poderá fazê-lo para modelos do Pydantic para parâmetros de cabeçalho.

Você pode configurar onde sua aplicação está localizada em um arquivo `pyproject.toml`, assim:

```toml
[tool.fastapi]
entrypoint = "main:app"
```

Esse `entrypoint` dirá ao comando `fastapi` que ele deve importar a aplicação assim:

```python
from main import app
```

Se o seu código estiver estruturado assim:

```
.
├── backend
│   ├── main.py
│   ├── __init__.py
```

O `RequestValidationError` contém o `body` que ele recebeu de dados inválidos.

Você pode utilizá-lo enquanto desenvolve seu app para registrar o *body* e debugá-lo, e assim retorná-lo ao usuário, etc.

{* ../../docs_src/handling_errors/tutorial005_py310.py hl[14] *}

Tente enviar um item inválido como este:

```JSON
{
  "title": "towel",
  "size": "XL"
}
```

/// info | Informação

Se você é um "Pythonista" muito rigoroso, pode não gostar do estilo do nome do parâmetro `tokenUrl` em vez de `token_url`.

Isso ocorre porque ele usa o mesmo nome da especificação do OpenAPI. Assim, se você precisar investigar mais sobre qualquer um desses esquemas de segurança, pode simplesmente copiar e colar para encontrar mais informações sobre isso.

///