@Test
  fun connectionPooling_Async() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))
    server.enqueue(MockResponse(body = "ghi"))
    client.newCall(Request.Builder().url(server.url("/a")).build()).enqueue(callback)
    callback.await(server.url("/a")).assertBody("abc")
    client.newCall(Request.Builder().url(server.url("/b")).build()).enqueue(callback)

Si vous avez un groupe de paramètres de requête liés, vous pouvez créer un modèle Pydantic pour les déclarer.

Cela vous permet de réutiliser le modèle à plusieurs endroits et aussi de déclarer des validations et des métadonnées pour tous les paramètres en une seule fois. 😎

/// note | Remarque

Pris en charge depuis FastAPI version `0.115.0`. 🤓

///

  }

  @Test
  fun misdirectedRequestResponseCode() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("seed connection")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(421)
        .body("misdirected!")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("after misdirect")

          .build(),
      )
    }
  }

  private fun testServerClosesOutput(mockResponse: MockResponse) {
    server.enqueue(mockResponse)
    val responseAfter = MockResponse(body = "This comes after a busted connection")
    server.enqueue(responseAfter)
    server.enqueue(responseAfter) // Enqueue 2x because the broken connection may be reused.
    val response1 = getResponse(newRequest("/a"))
    response1.body
      .source()

  }

  @Test
  fun singleTimeoutForAllFollowUpRequests() {
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", "/b")
        .headersDelay(100, TimeUnit.MILLISECONDS)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)

* Prise en charge de l'éditeur (évidemment)
* <dfn title="conversion de la chaîne provenant d'une requête HTTP en données Python">« parsing »</dfn> des données
* Validation des données
* Documentation automatique

## Valeurs par défaut { #defaults }

Comme les paramètres de requête ne sont pas une partie fixe d'un chemin, ils peuvent être optionnels et avoir des valeurs par défaut.

* Décompresser des corps de requête compressés en gzip.
* Journaliser automatiquement tous les corps de requête.

## Gérer les encodages personnalisés du corps de la requête { #handling-custom-request-body-encodings }

Voyons comment utiliser une sous-classe personnalisée de `Request` pour décompresser des requêtes gzip.

Et une sous-classe d'`APIRoute` pour utiliser cette classe de requête personnalisée.

  }

  @Test
  fun http2OneBadHostOneGoodRetryOnConnectionFailure() {
    enableProtocol(Protocol.HTTP_2)

    val request = Request(server1.url("/"))

    server1.enqueue(refusedStream)
    server1.enqueue(refusedStream)
    server2.enqueue(bodyResponse)

    dns[server1.hostName] = listOf(ipv6, ipv4)
    socketFactory[ipv6] = server1.socketAddress
    socketFactory[ipv4] = server2.socketAddress

    client =

  fun redirectToCachedResult() {
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Cache-Control: max-age=60")
        .body("ABC")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_PERM)
        .addHeader("Location: /foo")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()

      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8("<element/>")
        sink.flush()
      }
    }

    server.enqueue(MockResponse(code = 201))
    server.enqueue(MockResponse(code = 204))
    server.enqueue(MockResponse(code = 204))

    val endpointUrl = server.url("/endpoint")

    var request =
      Request
        .Builder()
        .url(endpointUrl)