/// tip | Dica

Alguns editores de texto checam parâmetros de funções não utilizados, e os mostram como erros.

Utilizando `dependencies` no *decorador da operação de rota* você pode garantir que elas serão executadas enquanto evita erros de editores/ferramentas.

Essas funções existem (em vez de usar diretamente as classes) para que seu editor não marque erros sobre seus tipos.

Dessa forma, você pode usar seu editor e ferramentas de codificação normais sem precisar adicionar configurações personalizadas para desconsiderar esses erros.

* **`400 - 499`** são para respostas de "Erro do cliente". Este é o segundo tipo que você provavelmente mais usaria.
    * Um exemplo é `404`, para uma resposta "Não encontrado".
    * Para erros genéricos do cliente, você pode usar apenas `400`.

Você também pode combinar `dataclasses` com outras anotações de tipo para criar estruturas de dados aninhadas.

Em alguns casos, você ainda pode ter que usar a versão do Pydantic das `dataclasses`. Por exemplo, se você tiver erros com a documentação da API gerada automaticamente.

Nesse caso, você pode simplesmente trocar as `dataclasses` padrão por `pydantic.dataclasses`, que é um substituto direto:

<img src="/img/tutorial/body/image03.png">

Você também poderá receber verificações de erros para operações de tipos incorretas:

<img src="/img/tutorial/body/image04.png">

Isso não é por acaso, todo o framework foi construído em volta deste design.

/// tip | Dica

Para resolver esse mesmo problema, é provavelmente muito mais fácil usar o `body` em um manipulador personalizado para `RequestValidationError` ([Tratando Erros](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).

Mas esse exemplo ainda é valido e mostra como interagir com os componentes internos.

///

│   └── test_main.py
```

Digamos que agora o arquivo `main.py` com sua aplicação **FastAPI** tenha algumas outras **operações de rotas**.

Ele tem uma operação `GET` que pode retornar um erro.

Ele tem uma operação `POST` que pode retornar vários erros.

Ambas as *operações de rotas* requerem um cabeçalho `X-Token`.

{* ../../docs_src/app_testing/app_b_an_py310/main.py *}

### Arquivo de teste estendido { #extended-testing-file }

Dessa forma eu pude encontrar a melhor maneira de reduzir duplicação de código o máximo possível, ter preenchimento automático em todos os lugares, conferência de tipos e erros etc.

Tudo de uma forma que oferecesse a melhor experiência de desenvolvimento para todos os desenvolvedores.

## Requisitos { #requirements }

app = SomeASGIApp()

new_app = UnicornMiddleware(app, some_config="rainbow")
```

Mas, o FastAPI (na verdade, o Starlette) fornece uma maneira mais simples de fazer isso que garante que os middlewares internos lidem com erros do servidor e que os manipuladores de exceções personalizados funcionem corretamente.

Para isso, você usa `app.add_middleware()` (como no exemplo para CORS).

```Python
from fastapi import FastAPI

	context   string // additional error context
	pos       errPos
	atChar    byte
	readerErr error // underlying reader error, if any
}

// ReaderErr returns the underlying error.
func (e DecoderError) ReaderErr() error { return e.readerErr }

// Error returns a string representation of the error.
func (e DecoderError) Error() string {
	loc := fmt.Sprintf("%s [%d,%d]", quoteChar(e.atChar), e.pos[0], e.pos[1])