return "Hello World"

    client = TestClient(app)
    return client


@needs_py310
def test_no_query():
    client = get_client()
    response = client.post("/items/")
    assert response.status_code == 200
    assert response.json() == "Hello World"


@needs_py310
def test_q_fixedquery():
    client = get_client()
    response = client.post("/items/", data={"q": "fixedquery"})

    }

    /**
     * Constructor for SuggestSettings.
     * @param client The OpenSearch client.
     * @param settingsId The settings ID.
     * @param initialSettings The initial settings.
     * @param settingsIndexName The settings index name.
     * @param timeoutSettings The timeout settings.
     */
    public SuggestSettings(final Client client, final String settingsId, final Map<String, Object> initialSettings,

     * @param settings Suggest settings
     * @param client OpenSearch client
     * @param settingsIndexName Settings index name
     * @param settingsId Settings ID
     */
    protected ArraySettings(final SuggestSettings settings, final Client client, final String settingsIndexName, final String settingsId) {
        this.settings = settings;
        this.client = client;

@pytest.fixture(
    name="client",
    params=[
        "tutorial009_py310",
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.body_nested_models.{request.param}")

    client = TestClient(mod.app)
    return client


def test_post_body(client: TestClient):
    data = {"2": 2.2, "3": 3.3}
    response = client.post("/index-weights/", json=data)

def no_response_model_annotation_json_response_class() -> JSONResponse:
    return JSONResponse(content={"foo": "bar"})


client = TestClient(app)


def test_no_response_model_no_annotation_return_model():
    response = client.get("/no_response_model-no_annotation-return_model")
    assert response.status_code == 200, response.text
    assert response.json() == {"name": "John", "surname": "Doe"}

      enableTls()
      client =
        client
          .newBuilder()
          .protocols(listOf(protocol, Protocol.HTTP_1_1))
          .build()
      server.protocols = client.protocols
    }
  }

  private fun enableTls() {
    val handshakeCertificates = platform.localhostHandshakeCertificates()
    client =
      client
        .newBuilder()
        .sslSocketFactory(

    assert state.sub_router_shutdown is False
    with TestClient(app) as client:
        assert state.app_startup is True
        assert state.router_startup is True
        assert state.sub_router_startup is True
        assert state.app_shutdown is False
        assert state.router_shutdown is False
        assert state.sub_router_shutdown is False
        response = client.get("/")
        assert response.status_code == 200, response.text

    private final Client client;
    private final SuggestSettings settings;
    private final SuggestWriter suggestWriter;

    /**
     * Constructor.
     *
     * @param client The OpenSearch client
     * @param settings The suggest settings
     * @param suggestWriter The suggest writer for performing deletions
     */

@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
    "path",
    ["/required-str", "/model-required-str"],
)
def test_required_str_missing(path: str, json: dict[str, Any] | None):
    client = TestClient(app)
    response = client.post(path, json=json)
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "type": "missing",

)
def test_optional_list_missing(path: str):
    client = TestClient(app)
    response = client.post(path)
    assert response.status_code == 200, response.text
    assert response.json() == {"file_size": None}


@pytest.mark.parametrize(
    "path",
    [
        "/optional-list-bytes",
        "/optional-list-uploadfile",
    ],
)
def test_optional_list(path: str):
    client = TestClient(app)