{* ../../docs_src/query_param_models/tutorial002_an_py310.py hl[10] *}

Wenn ein Client versucht, einige **zusätzliche** Daten in den **Query-Parametern** zu senden, erhält er eine **Error-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**.

Wenn der Client beispielsweise versucht, einen `tool` Query-Parameter mit dem Wert `plumbus` zu senden, wie:

```http

```mermaid
sequenceDiagram

participant client as Client
participant handler as Exceptionhandler
participant dep as Abhängigkeit mit yield
participant operation as Pfadoperation
participant tasks as Hintergrundtasks

    Note over client,operation: Kann Exceptions auslösen, inklusive HTTPException
    client ->> dep: Startet den Request
    Note over dep: Führt den Code bis zum yield aus

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server =
    MockWebServer().apply {
      protocols = listOf(protocol)
    }

  private var client =
    clientTestRule
      .newClientBuilder()
      .protocols(listOf(protocol))
      .build()

  @Test
  fun largeStatusLine() {
    assumeTrue(protocol == Protocol.HTTP_1_1)

    server.enqueue(

        final LlmClientManager llmClientManager = ComponentUtil.getComponent("llmClientManager");
        for (final LlmClient client : llmClientManager.getClients()) {
            final Map<String, String> map = new HashMap<>();
            map.put(Constants.ITEM_LABEL, client.getName());
            map.put(Constants.ITEM_VALUE, client.getName());
            itemList.add(map);
        }
        return itemList;
    }

        "ref2": {
            "ref": {"foo": "mixed_dict model foo", "bar": "mixed_dict model bar"},
            "baz": "mixed_dict model2 baz",
        },
    }


client = TestClient(app)


def test_nested_include_simple():
    response = client.get("/simple_include")

    assert response.status_code == 200, response.text

    assert response.json() == {
        "baz": "simple_include model2 baz",

@app.get("/indirectCookie")
def get_indirect_cookie(dep: str = Depends(set_indirect_cookie)):
    return {"dep": dep}


client = TestClient(app)


def test_cookie_is_set_once():
    direct_response = client.get("/directCookie")
    indirect_response = client.get("/indirectCookie")
    assert (
        direct_response.headers["set-cookie"] == indirect_response.headers["set-cookie"]

			for {
				select {
				case <-ctx.Done():
					return
				case <-timer.C:
					client.DescribeKey(ctx, defaultKey)
				}
			}
		}()

		return &KMS{
			Type:       MinKES,
			DefaultKey: env.Get(EnvKESDefaultKey, ""),
			conn: &kesConn{
				defaultKeyID: env.Get(EnvKESDefaultKey, ""),
				client:       client,
			},
			latencyBuckets: defaultLatencyBuckets,

        Dns.SYSTEM.lookup(server.hostName)
      }

    val client =
      clientTestRule
        .newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).dns(dns)
        .build()

    server.enqueue(MockResponse())

    val call =
      client.newCall(
        Request(

    }

    @Test
    @DisplayName("Should handle constructor with context")
    void testConstructor() {
        // When
        NameServiceClientImpl client = new NameServiceClientImpl(mockContext);

        // Then
        assertNotNull(client, "Should create client instance");
    }

    @Test
    @DisplayName("Should handle constructor with null context")
    void testConstructorWithNullContext() {

client = TestClient(
    app,
    base_url="https://example.com",
    follow_redirects=False,
)


def test_redirect() -> None:
    response = client.get("/items")
    assert response.status_code == 307
    assert response.headers["location"] == "https://example.com/items/"


def test_no_redirect() -> None:
    response = client.get("/items/")
    assert response.status_code == 200