import org.junit.jupiter.api.Test
import org.mockserver.client.MockServerClient
import org.mockserver.configuration.Configuration
import org.mockserver.logging.MockServerLogger
import org.mockserver.model.HttpRequest.request
import org.mockserver.model.HttpResponse.response
import org.mockserver.socket.tls.KeyStoreFactory
import org.testcontainers.containers.MockServerContainer
import org.testcontainers.junit.jupiter.Container

import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.ParameterDisplay
import model.CIBuildModel
import model.PerformanceTestBuildSpec
import model.PerformanceTestType
import model.Stage

class PerformanceTest(
    model: CIBuildModel,
    stage: Stage,
    performanceTestBuildSpec: PerformanceTestBuildSpec,
    description: String,
    performanceSubProject: String,

## Additional Response with `model`

You can pass to your *path operation decorators* a parameter `responses`.

It receives a `dict`, the keys are status codes for each response, like `200`, and the values are other `dict`s with the information for each of them.

Each of those response `dict`s can have a key `model`, containing a Pydantic model, just like `response_model`.

import jetbrains.buildServer.configs.kotlin.buildSteps.script
import model.CIBuildModel
import model.Stage

/**
 * Build a Gradle distribution (dogfood-first) and use this distribution to build a distribution again (dogfood-second).
 * Use `dogfood-second` to run `test sanityCheck`.
 */
class Gradleception(
    model: CIBuildModel,
    stage: Stage,
    buildJvm: Jvm,
    jvmDescription: String,

    {!> ../../../docs_src/body/tutorial001_py310.py!}
    ```

=== "Python 3.8+"

    ```Python hl_lines="4"
    {!> ../../../docs_src/body/tutorial001.py!}
    ```

## Create your data model

Then you declare your data model as a class that inherits from `BaseModel`.

Use standard Python types for all the attributes:

=== "Python 3.10+"

    ```Python hl_lines="5-9"
    {!> ../../../docs_src/body/tutorial001_py310.py!}

Most source code in Gradle is arranged by which part(s) of the build state model it acts on.
This affects the lifecycle of the code and the set of services available for dependency injection.
When working on some source code it is important to be aware of the model it acts on.  

    ```

!!! info
    In Pydantic version 1 the method to get the JSON Schema for a model was called `Item.schema()`, in Pydantic version 2, the method is called `Item.model_json_schema()`.

Nevertheless, although we are not using the default integrated functionality, we are still using a Pydantic model to manually generate the JSON Schema for the data that we want to receive in YAML.

But you are not restricted to using some specific data model, class or type.

Do you want to have an `id` and `email` and not have any `username` in your model? Sure. You can use these same tools.

Do you want to just have a `str`? Or just a `dict`? Or a database class model instance directly? It all works the same way.

And if you declared a `response_model`, it will still be used to filter and convert the object you returned.

**FastAPI** will use that *temporal* response to extract the status code (also cookies and headers), and will put them in the final response that contains the value you returned, filtered by any `response_model`.

        "org/gradle/tooling/**",
        "org/gradle/swiftpm/**",
        "org/gradle/model/**",
        "org/gradle/testkit/**",
        "org/gradle/testing/**",
        "org/gradle/vcs/**",
        "org/gradle/work/**",
        "org/gradle/workers/**",
        "org/gradle/util/**", // contains Path that clashes with `org.gradle.api.model.Path` imported above. This line should not appear before "org/gradle/api/**"
    )