"input": 0,
                "ctx": {"gt": 0},
            },
        ],
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == snapshot(
        {
            "openapi": "3.1.0",
            "info": {"title": "FastAPI", "version": "0.1.0"},
            "paths": {

    end
```

/// info | Información

Solo **un response** será enviado al cliente. Podría ser uno de los responses de error o será el response de la *path operation*.

Después de que se envíe uno de esos responses, no se podrá enviar ningún otro response.

///

/// tip | Consejo

      null
    } else {
      responseBuilder
    }
  }

  override fun reportedContentLength(response: Response): Long =
    when {
      !response.promisesBody() -> 0L
      else -> response.headersContentLength()
    }

  override fun openResponseBodySource(response: Response): Source = stream!!.source

  override fun peekTrailers(): Headers? = stream!!.peekTrailers()

  override fun cancel() {

    with patch("json.loads", side_effect=Exception):
        response = client.post("/items/", json={"test": "test2"})
        assert response.status_code == 400, response.text


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == snapshot(
        {
            "openapi": "3.1.0",

    )
    val call1 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response1 = call1.execute()
    assertThat(response1.body.string()).isEqualTo("abc")
    response1.close()

    // Force a fresh connection for the next request.
    client.connectionPool.evictAll()

                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a ListBody from a DictionaryFile for API responses.
     *
     * @param dictionaryFile the dictionary file to convert
     * @return the converted ListBody object
     */
    protected ListBody createListBody(final DictionaryFile<? extends DictionaryItem> dictionaryFile) {

    class ConstructorTests {

        @Test
        @DisplayName("Should create response with configuration")
        void testConstructor() {
            Smb2EchoResponse response = new Smb2EchoResponse(mockConfig);
            assertNotNull(response);
            assertEquals(mockConfig, response.getConfig());
        }

        @Test
        @DisplayName("Should extend ServerMessageBlock2Response")

async def middleware(request, call_next):
    response: StreamingResponse = await call_next(request)
    response.headers["x-state"] = json.dumps(state.copy())
    return response


client = TestClient(app)


def test_async_state():
    assert state["/async"] == "asyncgen not started"
    response = client.get("/async")
    assert response.status_code == 200, response.text
    assert response.json() == "asyncgen started"

Si una request entrante no se valida correctamente, se enviará un response `400`.

## `GZipMiddleware` { #gzipmiddleware }

Maneja responses GZip para cualquier request que incluya `"gzip"` en el header `Accept-Encoding`.

El middleware manejará tanto responses estándar como en streaming.

{* ../../docs_src/advanced_middleware/tutorial003_py310.py hl[2,6] *}

import org.codelibs.fess.dict.kuromoji.KuromojiFile;
import org.codelibs.fess.dict.kuromoji.KuromojiItem;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;
import org.lastaflute.web.response.StreamResponse;

import jakarta.annotation.Resource;

/**
 * API action for admin Kuromoji dictionary management.