* this method to use a custom {@link Executor}, which may configure its worker thread with a
   * specific name, thread group or priority. The returned executor's {@link
   * Executor#execute(Runnable) execute()} method is called when this service is started, and should
   * return promptly.
   *
   * <p>The default implementation returns a new {@link Executor} that sets the name of its threads

            doc.put("boost", 1.0f);
            doc.put("role", "Rguest");
            documents.add(doc);
        }

        requestBody.put("documents", documents);

        // Execute bulk create
        checkMethodBase(requestBody).put(API_PATH + "/" + BULK_ENDPOINT).then().body("response.status", equalTo(0));
        refresh();

        // Verify documents were created

 * it is invoked using this executor once the future's computation is {@linkplain Future#isDone()
 * complete}. If the computation has already completed when the listener is added, the listener will
 * execute immediately.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/ListenableFutureExplained">{@code
 * ListenableFuture}</a>.
 *
 * <p>This class is GWT-compatible.
 *

   * propagated. If, on the other hand, the time limit is reached, we attempt to abort the call to
   * the target, and throw a {@link TimeoutException} to the caller.
   *
   * @param callable the Callable to execute
   * @param timeoutDuration with timeoutUnit, the maximum length of time to wait
   * @param timeoutUnit with timeoutDuration, the maximum length of time to wait
   * @return the result returned by the Callable

                        .endObject()
                        .endObject())
                .execute()
                .actionGet();

        client.admin().indices().prepareRefresh(SUGGEST_INDEX).execute().actionGet();
    }

    @Test
    public void testConstructor() {
        // Test constructor initialization

    //                                                                      Search Execute
    //                                                                      ==============

    /**
     * Displays the wizard index page.
     *
     * @return HTML response for the wizard main page
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse index() {
        return asIndexHtml();

    server.enqueue(MockResponse())
    server.start()

    val request = Request.Builder().url(server.url("/")).build()

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
    }

    while (client.connectionPool.connectionCount() > 0) {
      Thread.sleep(1000)
    }
  }

  @Test
  fun testHttpRequest() {

    testRequest {
      val client = OkHttpClient()

      val response =
        client
          .newCall(
            Request((mockServer.endpoint + "/person?name=peter").toHttpUrl()),
          ).execute()

      assertThat(response.body.string()).contains("Peter the person")
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_1_1)
    }
  }

  @Test
  fun testOkHttpProxied() {
    testRequest {

   * this method to use a custom {@link Executor}, which may configure its worker thread with a
   * specific name, thread group or priority. The returned executor's {@link
   * Executor#execute(Runnable) execute()} method is called when this service is started and
   * stopped, and should return promptly.
   */
  protected Executor executor() {
    return command -> newThread(threadNameSupplier.get(), command).start();

* Il peut alors faire quelque chose avec cette **requête** ou exécuter tout code nécessaire.
* Ensuite, il transmet la **requête** pour qu’elle soit traitée par le reste de l’application (par un *chemin d'accès*).
* Puis il récupère la **réponse** générée par l’application (par un *chemin d'accès*).
* Il peut faire quelque chose avec cette **réponse** ou exécuter tout code nécessaire.
* Enfin, il renvoie la **réponse**.