import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.util.Locale;
import junit.framework.TestCase;

/**
 * Since annotations have some reusability issues that force copy and paste all over the place, it's
 * worth having a test to ensure that all our Feature enums have their annotations correctly set up.
 *
 * @author George van den Driessche
 */
public class FeatureEnumTest extends TestCase {

- Kubelet: when there are multi option lines in /etc/resolv.conf, merge all options into one line in a pod with the `Default` DNS policy. ([#112414](https://github.com/kubernetes/kubernetes/pull/112414), [@pacoxu](https://github.com/pacoxu)) [SIG Network and Node]

 *
 * @author mbechler
 */
public class Smb2WriteRequest extends ServerMessageBlock2Request<Smb2WriteResponse> implements RequestWithFileId {

    /**
     * The overhead size in bytes for an SMB2 write request packet.
     */
    public static final int OVERHEAD = Smb2Constants.SMB2_HEADER_LENGTH + 48;

    private byte[] data;
    private int dataOffset;
    private int dataLength;

    private byte[] fileId;

Un `Request` también tiene un `request.receive`, que es una función para "recibir" el cuerpo del request.

El `dict` `scope` y la función `receive` son ambos parte de la especificación ASGI.

Y esas dos cosas, `scope` y `receive`, son lo que se necesita para crear una nueva *Request instance*.

Pero **FastAPI** lo manejará, te dará los datos correctos en tu función, y validará y documentará el esquema correcto en la *path operation*.

También puedes declarar valores singulares para ser recibidos como parte del cuerpo.

Entonces, era un sistema completo adicional.

No es muy popular o usado hoy en día.

## OpenAPI { #openapi }

OpenAPI (anteriormente conocido como Swagger) es la especificación abierta para construir APIs (ahora parte de la Linux Foundation).

**FastAPI** se basa en **OpenAPI**.

Eso es lo que hace posible tener múltiples interfaces de documentación interactiva automática, generación de código, etc.

Um `Request` também tem um `request.receive`, que é uma função para "receber" o corpo da requisição.

O dicionário `scope` e a função `receive` são ambos parte da especificação ASGI.

E essas duas coisas, `scope` e `receive`, são o que é necessário para criar uma nova instância de `Request`.

Isso não é uma limitação do **FastAPI**, é parte do protocolo HTTP.

///

## Recapitulando { #recap }

Esto es similar a los códigos de estado HTTP 200 (de 200 a 299). Esos códigos de estado "200" significan que de alguna manera hubo un "éxito" en el request.

Los códigos de estado en el rango de 400 significan que hubo un error por parte del cliente.

¿Recuerdas todos esos errores de **"404 Not Found"** (y chistes)?

## Usa `HTTPException` { #use-httpexception }

Para devolver responses HTTP con errores al cliente, usa `HTTPException`.

* Kubernetes com um controlador Ingress como o Nginx
    * Com um componente externo como cert-manager para renovações de certificados
* Gerenciado internamente por um provedor de nuvem como parte de seus serviços (leia abaixo 👇)