under the License.
-->

<project>
    <!-- once we move past supporting modelVersion 4.0.0 we should update this version -->
    <modelVersion>3.9.9</modelVersion>
    <groupId>tests.project</groupId>
    <artifactId>past-model-version</artifactId>
    <version>1</version>

@app.get(
    "/simple_include",
    response_model=Model2,
    response_model_include={"baz": ..., "ref": {"foo"}},
)
def simple_include():
    return Model2(
        ref=Model1(foo="simple_include model foo", bar="simple_include model bar"),
        baz="simple_include model2 baz",
    )


@app.get(
    "/simple_include_dict",
    response_model=Model2,
    response_model_include={"baz": ..., "ref": {"foo"}},
)

from pydantic import BaseModel


class Model(BaseModel):
    name: str


app = FastAPI()


@app.get("/valid1", responses={"500": {"model": int}})
def valid1():
    pass


@app.get("/valid2", responses={"500": {"model": List[int]}})
def valid2():
    pass


@app.get("/valid3", responses={"500": {"model": Model}})
def valid3():
    pass

under the License.
-->

<project>
    <modelVersion>4.999.999</modelVersion>
    <!-- this should be a fake "future" version that only has modelVersion understood by us -->
    <coordinates>tests.project:future-model-version</coordinates>

            return name

    async def get_model_c() -> ModelC:
        return ModelC(username="test-user", password="test-password")

    @app.get("/model/{name}", response_model=ModelA)
    async def get_model_a(name: str, model_c=Depends(get_model_c)):
        return {"name": name, "description": "model-a-desc", "foo": model_c}

    client = TestClient(app)
    return client


@needs_pydanticv2

specific language governing permissions and limitations
under the License.
-->

<model>
  <groupId>foo</groupId>
  <artifactId>bar</artifactId>
  <name>Babar</name>
  <version>4.5</version>

  <!-- Build element should be inherited from the super model -->

    client = TestClient(app)
    return client


@needs_pydanticv1
def test_filter_sub_model(client: TestClient):
    response = client.get("/model/modelA")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "name": "modelA",
        "description": "model-a-desc",
        "model_b": {"username": "test-user"},
    }


@needs_pydanticv1

class PetDB(BaseModel):
    name: str
    owner: UserDB


class PetOut(BaseModel):
    name: str
    owner: User


@app.post("/users/", response_model=User)
async def create_user(user: UserCreate):
    return user


@app.get("/pets/{pet_id}", response_model=PetOut)
async def read_pet(pet_id: int):
    user = UserDB(
        email="******@****.***",
        hashed_password="secrethashed",
    )

class CustomModel(BaseModel):
    a: int


app = FastAPI()

callback_router = APIRouter(default_response_class=JSONResponse)


@callback_router.get(
    "{$callback_url}/callback/", responses={400: {"model": CustomModel}}
)
def callback_route():
    pass  # pragma: no cover


@app.post("/", callbacks=callback_router.routes)
def main_route(callback_url: HttpUrl):
    pass  # pragma: no cover

    @Test
    void testMergeModel_ModelVersion() {
        Model parent = Model.newBuilder().modelVersion("4.0.0").build();
        Model model = Model.newInstance();
        Model.Builder builder = Model.newBuilder(model);
        modelMerger.mergeModel_ModelVersion(builder, model, parent, false, null);
        assertNull(builder.build().getModelVersion());

        model = Model.newBuilder().modelVersion("5.0.0").build();