@GitHK review: split tests and adds xfail

Author: pcrespov

services/api-server/src/simcore_service_api_server/models/_utils_pydantic.py

@@ -12,22 +12,27 @@ class BaseConfig:
 
 
 class UriSchema:
-    """
-    Use with HttpUrl to produce schema with uri format such as
-    {
-        "format": "uri",
-        "maxLength": 2083,
-        "minLength": 1,
-        "type": "string",
-    }
-
-    SEE # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-7.3.5
+    """Metadata class to modify openapi schemas of Url fields
+
+    Usage:
+        class TestModel(BaseModel):
+            url: Annotated[HttpUrl, UriSchema()]
+
+
+    will produce a schema for url field property as a string with a format
+        {
+            "format": "uri",
+            "type": "string",
+        }
+
+    SEE https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-7.3.5
     """
 
     @classmethod
     def __get_pydantic_json_schema__(
         cls, core_schema: CoreSchema, handler: GetJsonSchemaHandler
     ) -> JsonSchemaValue:
+        # SEE https://docs.pydantic.dev/2.10/concepts/json_schema/#implementing-__get_pydantic_json_schema__
         json_schema = deepcopy(handler(core_schema))
 
         if (schema := core_schema.get("schema", {})) and schema.get("type") == "url":
@@ -36,6 +41,8 @@ def __get_pydantic_json_schema__(
                 format="uri",
             )
             if max_length := schema.get("max_length"):
+                # SEE https://docs.pydantic.dev/2.10/api/networks/#pydantic.networks.UrlConstraints
+                # adds limits if schema UrlConstraints includes it (e.g HttUrl includes )
                 json_schema.update(maxLength=max_length, minLength=1)
 
         return json_schema

services/api-server/tests/test_utils_pydantic.py

@@ -2,31 +2,46 @@
 # pylint: disable=unused-argument
 # pylint: disable=unused-variable
 # pylint: disable=too-many-arguments
-from typing import Annotated
 
+from typing import Annotated, Any
+
+import fastapi
+import pydantic
+import pytest
 from fastapi import FastAPI
-from pydantic import BaseModel, HttpUrl
+from pydantic import (
+    AnyHttpUrl,
+    AnyUrl,
+    BaseModel,
+    HttpUrl,
+    TypeAdapter,
+    ValidationError,
+)
 from simcore_service_api_server.models._utils_pydantic import UriSchema
 
 
-def test_annotated_url_in_pydantic_changes_in_fastapi():
-    class TestModel(BaseModel):
-        urls0: list[HttpUrl]
-        urls1: list[Annotated[HttpUrl, UriSchema()]]
+class _FakeModel(BaseModel):
+    urls0: list[HttpUrl]
+    urls1: list[Annotated[HttpUrl, UriSchema()]]
+
+    # with and w/o
+    url0: HttpUrl
+    url1: Annotated[HttpUrl, UriSchema()]
+
+    # # including None inside/outside annotated
+    url2: Annotated[HttpUrl, UriSchema()] | None
+    url3: Annotated[HttpUrl | None, UriSchema()]
 
-        # with and w/o
-        url0: HttpUrl
-        url1: Annotated[HttpUrl, UriSchema()]
+    # # mistake
+    int0: Annotated[int, UriSchema()]
 
-        # # including None inside/outside annotated
-        url2: Annotated[HttpUrl, UriSchema()] | None
-        url3: Annotated[HttpUrl | None, UriSchema()]
 
-        # # mistake
-        int0: Annotated[int, UriSchema()]
+@pytest.fixture
+def pydantic_schema() -> dict[str, Any]:
+    return _FakeModel.model_json_schema()
 
-    pydantic_schema = TestModel.model_json_schema()
 
+def test_pydantic_json_schema(pydantic_schema: dict[str, Any]):
     assert pydantic_schema["properties"] == {
         "int0": {"title": "Int0", "type": "integer"},
         "url0": {
@@ -79,14 +94,20 @@ class TestModel(BaseModel):
         },
     }
 
+
+@pytest.fixture
+def fastapi_schema() -> dict[str, Any]:
     app = FastAPI()
 
-    @app.get("/", response_model=TestModel)
+    @app.get("/", response_model=_FakeModel)
     def _h():
         ...
 
     openapi = app.openapi()
-    fastapi_schema = openapi["components"]["schemas"]["TestModel"]
+    return openapi["components"]["schemas"][_FakeModel.__name__]
+
+
+def test_fastapi_openapi_component_schemas(fastapi_schema: dict[str, Any]):
 
     assert fastapi_schema["properties"] == {
         "int0": {"title": "Int0", "type": "integer"},
@@ -119,5 +140,66 @@ def _h():
         },
     }
 
+
+@pytest.mark.xfail(
+    reason=f"{pydantic.__version__=} and {fastapi.__version__=} produce different json-schemas for the same model"
+)
+def test_compare_pydantic_vs_fastapi_schemas(
+    fastapi_schema: dict[str, Any], pydantic_schema: dict[str, Any]
+):
+
     # NOTE @all: I cannot understand this?!
     assert fastapi_schema["properties"] != pydantic_schema["properties"]
+
+
+def test_differences_between_new_pydantic_url_types():
+    # SEE https://docs.pydantic.dev/2.10/api/networks/
+
+    # | **URL**                       | **AnyUrl** | **HttpUrl** | **AnyHttpUrl** |
+    # |-------------------------------|------------|-------------|----------------|
+    # | `http://example.com`          | ✅          | ✅           | ✅              |
+    # | `https://example.com/resource`| ✅          | ✅           | ✅              |
+    # | `ftp://example.com`           | ✅          | ❌           | ❌              |
+    # | `http://localhost`            | ✅          | ✅           | ✅              |
+    # | `http://127.0.0.1`            | ✅          | ✅           | ✅              |
+    # | `http://127.0.0.1:8080`       | ✅          | ✅           | ✅              |
+    # | `customscheme://example.com`  | ✅          | ❌           | ❌              |
+
+    url = "http://example.com"
+    TypeAdapter(AnyUrl).validate_python(url)
+    TypeAdapter(HttpUrl).validate_python(url)
+    TypeAdapter(AnyHttpUrl).validate_python(url)
+
+    url = "https://example.com/resource"
+    TypeAdapter(AnyUrl).validate_python(url)
+    TypeAdapter(HttpUrl).validate_python(url)
+    TypeAdapter(AnyHttpUrl).validate_python(url)
+
+    url = "ftp://example.com"
+    TypeAdapter(AnyUrl).validate_python(url)
+    with pytest.raises(ValidationError):
+        TypeAdapter(HttpUrl).validate_python(url)
+    with pytest.raises(ValidationError):
+        TypeAdapter(AnyHttpUrl).validate_python(url)
+
+    url = "http://localhost"
+    TypeAdapter(AnyUrl).validate_python(url)
+    TypeAdapter(HttpUrl).validate_python(url)
+    TypeAdapter(AnyHttpUrl).validate_python(url)
+
+    url = "http://127.0.0.1"
+    TypeAdapter(AnyUrl).validate_python(url)
+    TypeAdapter(HttpUrl).validate_python(url)
+    TypeAdapter(AnyHttpUrl).validate_python(url)
+
+    url = "http://127.0.0.1:8080"
+    TypeAdapter(AnyUrl).validate_python(url)
+    TypeAdapter(HttpUrl).validate_python(url)
+    TypeAdapter(AnyHttpUrl).validate_python(url)
+
+    url = "customscheme://example.com"
+    TypeAdapter(AnyUrl).validate_python(url)
+    with pytest.raises(ValidationError):
+        TypeAdapter(HttpUrl).validate_python(url)
+    with pytest.raises(ValidationError):
+        TypeAdapter(AnyHttpUrl).validate_python(url)