🔥 Remove tests for Pydantic v1

Author: tiangolo

tests/conftest.py

@@ -10,7 +10,6 @@
 import pytest
 from pydantic import BaseModel
 from sqlmodel import SQLModel
-from sqlmodel._compat import IS_PYDANTIC_V2
 from sqlmodel.main import default_registry
 
 top_level_path = Path(__file__).resolve().parent.parent
@@ -87,9 +86,6 @@ def print_mock_fixture() -> Generator[PrintMock, None, None]:
         yield print_mock
 
 
-needs_pydanticv2 = pytest.mark.skipif(not IS_PYDANTIC_V2, reason="requires Pydantic v2")
-needs_pydanticv1 = pytest.mark.skipif(IS_PYDANTIC_V2, reason="requires Pydantic v1")
-
 needs_py310 = pytest.mark.skipif(
     sys.version_info < (3, 10), reason="requires python3.10+"
 )

tests/test_aliases.py

@@ -4,9 +4,6 @@
 from pydantic import BaseModel, ValidationError
 from pydantic import Field as PField
 from sqlmodel import Field, SQLModel
-from sqlmodel._compat import IS_PYDANTIC_V2
-
-from tests.conftest import needs_pydanticv1, needs_pydanticv2
 
 """
 Alias tests for SQLModel and Pydantic compatibility
@@ -22,23 +19,12 @@ class SQLModelUser(SQLModel):
 
 
 # Models with config (validate_by_name=True)
-if IS_PYDANTIC_V2:
-
-    class PydanticUserWithConfig(PydanticUser):
-        model_config = {"validate_by_name": True}
-
-    class SQLModelUserWithConfig(SQLModelUser):
-        model_config = {"validate_by_name": True}
-
-else:
+class PydanticUserWithConfig(PydanticUser):
+    model_config = {"validate_by_name": True}
 
-    class PydanticUserWithConfig(PydanticUser):
-        class Config:
-            allow_population_by_field_name = True
 
-    class SQLModelUserWithConfig(SQLModelUser):
-        class Config:
-            allow_population_by_field_name = True
+class SQLModelUserWithConfig(SQLModelUser):
+    model_config = {"validate_by_name": True}
 
 
 @pytest.mark.parametrize("model", [PydanticUser, SQLModelUser])
@@ -84,10 +70,7 @@ def test_dict_default_uses_field_names(
     model: Union[type[PydanticUser], type[SQLModelUser]],
 ):
     user = model(fullName="Dana")
-    if IS_PYDANTIC_V2 or isinstance(user, SQLModel):
-        data = user.model_dump()
-    else:
-        data = user.dict()
+    data = user.model_dump()
     assert "full_name" in data
     assert "fullName" not in data
     assert data["full_name"] == "Dana"
@@ -98,10 +81,7 @@ def test_dict_by_alias_uses_aliases(
     model: Union[type[PydanticUser], type[SQLModelUser]],
 ):
     user = model(fullName="Dana")
-    if IS_PYDANTIC_V2 or isinstance(user, SQLModel):
-        data = user.model_dump(by_alias=True)
-    else:
-        data = user.dict(by_alias=True)
+    data = user.model_dump(by_alias=True)
     assert "fullName" in data
     assert "full_name" not in data
     assert data["fullName"] == "Dana"
@@ -112,48 +92,19 @@ def test_json_by_alias(
     model: Union[type[PydanticUser], type[SQLModelUser]],
 ):
     user = model(fullName="Frank")
-    if IS_PYDANTIC_V2:
-        json_data = user.model_dump_json(by_alias=True)
-    else:
-        json_data = user.json(by_alias=True)
+    json_data = user.model_dump_json(by_alias=True)
     assert ('"fullName":"Frank"' in json_data) or ('"fullName": "Frank"' in json_data)
     assert "full_name" not in json_data
 
 
-if IS_PYDANTIC_V2:
-
-    class PydanticUserV2(BaseModel):
-        first_name: str = PField(
-            validation_alias="firstName", serialization_alias="f_name"
-        )
-
-    class SQLModelUserV2(SQLModel):
-        first_name: str = Field(
-            validation_alias="firstName", serialization_alias="f_name"
-        )
-else:
-    # Dummy classes for Pydantic v1 to prevent import errors
-    PydanticUserV2 = None
-    SQLModelUserV2 = None
+class PydanticUserV2(BaseModel):
+    first_name: str = PField(validation_alias="firstName", serialization_alias="f_name")
 
 
-@needs_pydanticv1
-def test_validation_alias_runtimeerror_pydantic_v1():
-    with pytest.raises(
-        RuntimeError, match="validation_alias is not supported in Pydantic v1"
-    ):
-        Field(validation_alias="foo")
+class SQLModelUserV2(SQLModel):
+    first_name: str = Field(validation_alias="firstName", serialization_alias="f_name")
 
 
-@needs_pydanticv1
-def test_serialization_alias_runtimeerror_pydantic_v1():
-    with pytest.raises(
-        RuntimeError, match="serialization_alias is not supported in Pydantic v1"
-    ):
-        Field(serialization_alias="bar")
-
-
-@needs_pydanticv2
 @pytest.mark.parametrize("model", [PydanticUserV2, SQLModelUserV2])
 def test_create_with_validation_alias(
     model: Union[type[PydanticUserV2], type[SQLModelUserV2]],
@@ -162,7 +113,6 @@ def test_create_with_validation_alias(
     assert user.first_name == "John"
 
 
-@needs_pydanticv2
 @pytest.mark.parametrize("model", [PydanticUserV2, SQLModelUserV2])
 def test_serialize_with_serialization_alias(
     model: Union[type[PydanticUserV2], type[SQLModelUserV2]],
@@ -175,7 +125,6 @@ def test_serialize_with_serialization_alias(
     assert data["f_name"] == "Jane"
 
 
-@needs_pydanticv2
 def test_schema_extra_validation_alias_sqlmodel_v2():
     class M(SQLModel):
         f: str = Field(schema_extra={"validation_alias": "f_alias"})
@@ -184,7 +133,6 @@ class M(SQLModel):
     assert m.f == "asd"
 
 
-@needs_pydanticv2
 def test_schema_extra_serialization_alias_sqlmodel_v2():
     class M(SQLModel):
         f: str = Field(schema_extra={"serialization_alias": "f_out"})
@@ -196,23 +144,6 @@ class M(SQLModel):
     assert data["f_out"] == "x"
 
 
-@needs_pydanticv1
-def test_schema_extra_validation_alias_runtimeerror_pydantic_v1():
-    with pytest.raises(
-        RuntimeError, match="validation_alias is not supported in Pydantic v1"
-    ):
-        Field(schema_extra={"validation_alias": "x"})
-
-
-@needs_pydanticv1
-def test_schema_extra_serialization_alias_runtimeerror_pydantic_v1():
-    with pytest.raises(
-        RuntimeError, match="serialization_alias is not supported in Pydantic v1"
-    ):
-        Field(schema_extra={"serialization_alias": "y"})
-
-
-@needs_pydanticv2
 def test_alias_plus_validation_alias_prefers_validation_alias_sqlmodel_v2():
     class M(SQLModel):
         first_name: str = Field(alias="fullName", validation_alias="v_name")
@@ -221,7 +152,6 @@ class M(SQLModel):
     assert m.first_name == "B"
 
 
-@needs_pydanticv2
 def test_alias_plus_serialization_alias_prefers_serialization_alias_sqlmodel_v2():
     class M(SQLModel):
         first_name: str = Field(alias="fullName", serialization_alias="f_name")
@@ -233,7 +163,6 @@ class M(SQLModel):
     assert data["f_name"] == "Z"
 
 
-@needs_pydanticv2
 def test_alias_generator_works_sqlmodel_v2():
     class M(SQLModel):
         model_config = {"alias_generator": lambda s: "gen_" + s}
@@ -245,7 +174,6 @@ class M(SQLModel):
     assert "gen_f" in data and data["gen_f"] == "ok"
 
 
-@needs_pydanticv2
 def test_alias_generator_with_explicit_alias_prefers_field_alias_sqlmodel_v2():
     class M(SQLModel):
         model_config = {"alias_generator": lambda s: "gen_" + s}

tests/test_annotated_uuid.py

@@ -3,10 +3,7 @@
 
 from sqlmodel import Field, Session, SQLModel, create_engine, select
 
-from tests.conftest import needs_pydanticv2
 
-
-@needs_pydanticv2
 def test_annotated_optional_types(clear_sqlmodel) -> None:
     from pydantic import UUID4
 

tests/test_enums.py

@@ -6,7 +6,6 @@
 from sqlmodel import SQLModel
 
 from . import test_enums_models
-from .conftest import needs_pydanticv1, needs_pydanticv2
 
 """
 Tests related to Enums
@@ -55,49 +54,6 @@ def test_sqlite_ddl_sql(clear_sqlmodel, capsys: pytest.CaptureFixture[str]):
     assert "CREATE TYPE" not in captured.out
 
 
-@needs_pydanticv1
-def test_json_schema_flat_model_pydantic_v1():
-    assert test_enums_models.FlatModel.schema() == {
-        "title": "FlatModel",
-        "type": "object",
-        "properties": {
-            "id": {"title": "Id", "type": "string", "format": "uuid"},
-            "enum_field": {"$ref": "#/definitions/MyEnum1"},
-        },
-        "required": ["id", "enum_field"],
-        "definitions": {
-            "MyEnum1": {
-                "title": "MyEnum1",
-                "description": "An enumeration.",
-                "enum": ["A", "B"],
-                "type": "string",
-            }
-        },
-    }
-
-
-@needs_pydanticv1
-def test_json_schema_inherit_model_pydantic_v1():
-    assert test_enums_models.InheritModel.schema() == {
-        "title": "InheritModel",
-        "type": "object",
-        "properties": {
-            "id": {"title": "Id", "type": "string", "format": "uuid"},
-            "enum_field": {"$ref": "#/definitions/MyEnum2"},
-        },
-        "required": ["id", "enum_field"],
-        "definitions": {
-            "MyEnum2": {
-                "title": "MyEnum2",
-                "description": "An enumeration.",
-                "enum": ["C", "D"],
-                "type": "string",
-            }
-        },
-    }
-
-
-@needs_pydanticv2
 def test_json_schema_flat_model_pydantic_v2():
     assert test_enums_models.FlatModel.model_json_schema() == {
         "title": "FlatModel",
@@ -113,7 +69,6 @@ def test_json_schema_flat_model_pydantic_v2():
     }
 
 
-@needs_pydanticv2
 def test_json_schema_inherit_model_pydantic_v2():
     assert test_enums_models.InheritModel.model_json_schema() == {
         "title": "InheritModel",

tests/test_validation.py

@@ -4,39 +4,7 @@
 from pydantic.error_wrappers import ValidationError
 from sqlmodel import SQLModel
 
-from .conftest import needs_pydanticv1, needs_pydanticv2
 
-
-@needs_pydanticv1
-def test_validation_pydantic_v1(clear_sqlmodel):
-    """Test validation of implicit and explicit None values.
-
-    # For consistency with pydantic, validators are not to be called on
-    # arguments that are not explicitly provided.
-
-    https://github.com/tiangolo/sqlmodel/issues/230
-    https://github.com/samuelcolvin/pydantic/issues/1223
-
-    """
-    from pydantic import validator
-
-    class Hero(SQLModel):
-        name: Optional[str] = None
-        secret_name: Optional[str] = None
-        age: Optional[int] = None
-
-        @validator("name", "secret_name", "age")
-        def reject_none(cls, v):
-            assert v is not None
-            return v
-
-    Hero.validate({"age": 25})
-
-    with pytest.raises(ValidationError):
-        Hero.validate({"name": None, "age": 25})
-
-
-@needs_pydanticv2
 def test_validation_pydantic_v2(clear_sqlmodel):
     """Test validation of implicit and explicit None values.