assertThat(chain.request().body).isNull()
            val response = chain.proceed(chain.request())
            assertThat(response.header("Connection")).isEqualTo("Upgrade")
            assertThat(response.body).isInstanceOf<UnreadableResponseBody>()
            interceptedCount.incrementAndGet()
            response
          },
        ).build()
    webServer.enqueue(
      MockResponse

import org.codelibs.fess.app.web.api.admin.FessApiAdminAction;
import org.codelibs.fess.opensearch.config.exentity.FileAuthentication;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;

import jakarta.annotation.Resource;

/**
 * API action for admin file authentication management.
 * Provides RESTful API endpoints for managing file authentication settings in the Fess search engine.

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": {
                "/user/": {
                    "post": {
                        "responses": {
                            "200": {

        // Mock successful but empty response
        when(treeHandle.send(any(), any(), (RequestParam[]) any())).thenAnswer(invocation -> {
            // The response is the second argument
            Object response = invocation.getArgument(1);
            // Return it unchanged (which will have default values = empty results)
            return response;
        });

        // When: Create iterator

  )

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may
   * proceed to read the response body with [Response.body]. The response is still live until its
   * response body is [closed][ResponseBody]. The recipient of the callback may consume the response
   * body on another thread.
   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not

    /**
     * Constructs a SMB2 query info response with the specified configuration and expected information types
     *
     * @param config
     *            the configuration to use for this response
     * @param expectInfoType
     *            the expected information type in the response
     * @param expectInfoClass
     *            the expected information class in the response
     */

     *
     * @param request The servlet request
     * @param response The servlet response
     * @param chain The filter chain
     * @throws IOException If an I/O error occurs
     * @throws ServletException If a servlet error occurs
     */
    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {

client = TestClient(app)


def test_get():
    response = client.get("/items/")
    assert response.status_code == 200, response.text
    assert response.json() == [{"item_id": "Foo"}]


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

    val response1 = client.newCall(request1).execute()
    assertThat(response1.code).isEqualTo(401)
    assertThat(response1.body.string())
      .isEqualTo("{\"error\":{\"message\":\"No auth credentials found\",\"code\":401}}")

    val request2 = request1.newBuilder().header("Authorization", "XYZ").build()
    val response2 = client.newCall(request2).execute()

client = TestClient(app)


def test_response_headers():
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert "X-Process-Time" in response.headers


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