with pytest.raises(RuntimeError):
        client.get("/server-error")


def test_override_server_error_exception_response():
    client = TestClient(app, raise_server_exceptions=False)
    response = client.get("/server-error")
    assert response.status_code == 500
    assert response.json() == {"exception": "server-error"}


def test_traceback_for_dependency_with_yield():
    client = TestClient(app, raise_server_exceptions=True)

    with client:
        response = client.get("/a/override")
    assert response.content == b"Hello A"
    assert response.headers["content-type"] == text_type


def test_router_a_a():
    with client:
        response = client.get("/a/a")
    assert response.json() == {"msg": "Hello A A"}
    assert response.headers["content-type"] == orjson_type


def test_router_a_a_override():
    with client:

		Secure:    s.secure,
		Transport: s.TestSuiteCommon.client.Transport,
	})
	if err != nil {
		c.Fatalf("Error initializing client: %v", err)
	}

	// Validate that the client from sts creds can access the bucket.
	c.mustListObjects(ctx, minioClient, bucket)

	// Create an madmin client with user creds
	userAdmClient, err := madmin.NewWithOptions(s.endpoint, &madmin.Options{

    dispatcher.maxRequests = 2
    client.newCall(newRequest("http://a/1")).enqueue(callback)
    client.newCall(newRequest("http://b/1")).enqueue(callback)
    client.newCall(newRequest("http://c/1")).enqueue(callback)
    client.newCall(newRequest("http://a/2")).enqueue(callback)
    client.newCall(newRequest("http://b/2")).enqueue(callback)

                        "400": {"description": "Client error level 0"},
                        "401": {"description": "Client error level 1"},
                        "402": {"description": "Client error level 2"},
                        "403": {"description": "Client error level 3"},
                        "404": {"description": "Client error level 4"},
                        "405": {"description": "Client error level 5"},

        .message("Intercepted!")
        .body("abc".toResponseBody("text/plain; charset=utf-8".toMediaType()))
        .build()
    client =
      client
        .newBuilder()
        .addInterceptor(Interceptor { chain: Interceptor.Chain? -> interceptorResponse })
        .build()
    val response = client.newCall(request).execute()
    assertThat(response).isSameInstanceAs(interceptorResponse)
  }

  @Test

    client = DummyClient()
    yield client
    await client.close()


Client = Annotated[DummyClient, Depends(get_client)]


@pytest.fixture(name="client")
def client_fixture() -> TestClient:
    app = FastAPI()

    @app.get("/")
    async def get_people(client: Client) -> list:
        return await client.get_people()

    client = TestClient(app)
    return client

   */
  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client
        .newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),

    response = client.get("/query/int/default")
    assert response.status_code == 200
    assert response.json() == "foo bar 10"


def test_query_int_default_query_50():
    response = client.get("/query/int/default?query=50")
    assert response.status_code == 200
    assert response.json() == "foo bar 50"


def test_query_int_default_query_foo():
    response = client.get("/query/int/default?query=foo")

        return {"username": "alice", "role": "admin"}

    client = TestClient(app)
    return client


@needs_py310
def test_get(client: TestClient):
    response = client.get("/users")
    assert response.json() == {"username": "alice", "role": "admin"}


@needs_py310
def test_openapi_schema(client: TestClient):
    response = client.get("openapi.json")
    assert response.json() == snapshot(
        {