fix(pydantic): Check for unused strawberry.auto fields when converting BaseModel

RELEASE.MD

@@ -0,0 +1,18 @@
+Release type: patch
+
+ This release checks for AutoFieldsNotInBaseModelError when converting from pydantic models.
+ It is raised when strawberry.auto is used, but the pydantic model does not have
+the particular field defined.
+
+```{python}
+class User(BaseModel):
+    age: int
+
+@strawberry.experimental.pydantic.type(User)
+class UserType:
+    age: strawberry.auto
+    password: strawberry.auto
+```
+
+Previously no errors would be raised, and the password field would not appear on graphql schema.
+Such mistakes could be common during refactoring. Now, AutoFieldsNotInBaseModelError is raised.

strawberry/experimental/pydantic/exceptions.py

@@ -1,4 +1,4 @@
-from typing import Any, Type
+from typing import Any, List, Type
 
 from pydantic import BaseModel
 from pydantic.typing import NoArgAnyCallable
@@ -35,3 +35,13 @@ def __init__(self, default: Any, default_factory: NoArgAnyCallable):
         )
 
         super().__init__(message)
+
+
+class AutoFieldsNotInBaseModelError(Exception):
+    def __init__(self, fields: List[str], cls_name: str, model: Type[BaseModel]):
+        message = (
+            f"{cls_name} defines {fields} with strawberry.auto. "
+            f"Field(s) not present in {model.__name__} BaseModel."
+        )
+
+        super().__init__(message)

strawberry/experimental/pydantic/object_type.py

@@ -18,6 +18,7 @@
 from strawberry.experimental.pydantic.fields import get_basic_type
 from strawberry.experimental.pydantic.utils import (
     DataclassCreationFields,
+    ensure_all_auto_fields_in_pydantic,
     get_default_factory_for_field,
     get_private_fields,
     sort_creation_fields,
@@ -111,6 +112,10 @@ def wrap(cls):
         if not fields_set:
             raise MissingFieldsListError(cls)
 
+        ensure_all_auto_fields_in_pydantic(
+            model=model, auto_fields=fields_set, cls_name=cls.__name__
+        )
+
         all_model_fields: List[DataclassCreationFields] = [
             DataclassCreationFields(
                 name=field_name,

strawberry/experimental/pydantic/utils.py

@@ -1,12 +1,14 @@
 import dataclasses
-from typing import Any, List, NamedTuple, Tuple, Type, Union, cast
+from typing import Any, List, NamedTuple, NoReturn, Set, Tuple, Type, Union, cast
 
+from pydantic import BaseModel
 from pydantic.fields import ModelField
 from pydantic.typing import NoArgAnyCallable
 from pydantic.utils import smart_deepcopy
 
 from strawberry.arguments import UNSET, _Unset, is_unset  # type: ignore
 from strawberry.experimental.pydantic.exceptions import (
+    AutoFieldsNotInBaseModelError,
     BothDefaultAndDefaultFactoryDefinedError,
     UnregisteredTypeException,
 )
@@ -118,3 +120,19 @@ def get_default_factory_for_field(field: ModelField) -> Union[NoArgAnyCallable,
         return lambda: None
 
     return UNSET
+
+
+def ensure_all_auto_fields_in_pydantic(
+    model: Type[BaseModel], auto_fields: Set[str], cls_name: str
+) -> Union[NoReturn, None]:
+    # Raise error if user defined a strawberry.auto field not present in the model
+    pydantic_fields = set(field_name for field_name, _ in model.__fields__.items())
+    undefined = [
+        field_name for field_name in auto_fields if field_name not in pydantic_fields
+    ]
+    if len(undefined) > 0:
+        raise AutoFieldsNotInBaseModelError(
+            fields=undefined, cls_name=cls_name, model=model
+        )
+    else:
+        return None

tests/experimental/pydantic/schema/test_basic.py

@@ -332,7 +332,7 @@ class BranchAType:
     class BranchBType:
         pass
 
-    @strawberry.experimental.pydantic.type(User, fields=["age", "union_field"])
+    @strawberry.experimental.pydantic.type(User, fields=["union_field"])
     class UserType:
         pass
 
@@ -370,7 +370,7 @@ class BranchAType:
     class BranchBType:
         pass
 
-    @strawberry.experimental.pydantic.type(User, fields=["age", "union_field"])
+    @strawberry.experimental.pydantic.type(User, fields=["union_field"])
     class UserType:
         pass
 
@@ -446,7 +446,7 @@ class BranchAType(BaseType):
     class BranchBType(BaseType):
         pass
 
-    @strawberry.experimental.pydantic.type(User, fields=["age", "interface_field"])
+    @strawberry.experimental.pydantic.type(User, fields=["interface_field"])
     class UserType:
         pass
 

tests/experimental/pydantic/test_conversion.py

@@ -1,3 +1,4 @@
+import re
 from enum import Enum
 from typing import Any, List, Optional, Union, cast
 
@@ -10,6 +11,7 @@
 import strawberry
 from strawberry.arguments import UNSET
 from strawberry.experimental.pydantic.exceptions import (
+    AutoFieldsNotInBaseModelError,
     BothDefaultAndDefaultFactoryDefinedError,
 )
 from strawberry.experimental.pydantic.utils import (
@@ -55,6 +57,66 @@ class UserType:
     assert user.password == "abc"
 
 
+def test_cannot_convert_pydantic_type_to_strawberry_missing_field():
+    class User(BaseModel):
+        age: int
+
+    with pytest.raises(
+        AutoFieldsNotInBaseModelError,
+        match=re.escape(
+            "UserType defines ['password'] with strawberry.auto."
+            " Field(s) not present in User BaseModel."
+        ),
+    ):
+
+        @strawberry.experimental.pydantic.type(User)
+        class UserType:
+            age: strawberry.auto
+            password: strawberry.auto
+
+
+def test_cannot_convert_pydantic_type_to_strawberry_property_auto():
+    class User(BaseModel):
+        age: int
+
+        @property
+        def password(self) -> str:
+            return "hunter2"
+
+    with pytest.raises(
+        AutoFieldsNotInBaseModelError,
+        match=re.escape(
+            "UserType defines ['password'] with strawberry.auto."
+            " Field(s) not present in User BaseModel."
+        ),
+    ):
+
+        @strawberry.experimental.pydantic.type(User)
+        class UserType:
+            age: strawberry.auto
+            password: strawberry.auto
+
+
+def test_can_convert_pydantic_type_to_strawberry_property():
+    class User(BaseModel):
+        age: int
+
+        @property
+        def password(self) -> str:
+            return "hunter2"
+
+    @strawberry.experimental.pydantic.type(User)
+    class UserType:
+        age: strawberry.auto
+        password: str
+
+    origin_user = User(age=1)
+    user = UserType.from_pydantic(origin_user)
+
+    assert user.age == 1
+    assert user.password == "hunter2"
+
+
 def test_can_convert_alias_pydantic_field_to_strawberry():
     class UserModel(BaseModel):
         age_: int = Field(..., alias="age")