Fix: Use correct field_meta for constrained union types when building field values for coverage

Author: bullfest

polyfactory/factories/base.py

@@ -902,6 +902,9 @@ def get_field_value_coverage(  # noqa: C901,PLR0912
         for unwrapped_annotation in flatten_annotation(field_meta.annotation):
             unwrapped_annotation = cls._resolve_forward_references(unwrapped_annotation)  # noqa: PLW2901
 
+            unwrapped_annotation_meta = next(
+                (meta for meta in (field_meta.children or []) if meta.annotation == unwrapped_annotation), field_meta
+            )
             if unwrapped_annotation in (None, NoneType):
                 yield None
 
@@ -911,11 +914,11 @@ def get_field_value_coverage(  # noqa: C901,PLR0912
             elif isinstance(unwrapped_annotation, EnumMeta):
                 yield CoverageContainer(list(unwrapped_annotation))
 
-            elif field_meta.constraints:
+            elif unwrapped_annotation_meta.constraints:
                 yield CoverageContainerCallable(
                     cls.get_constrained_field_value,
                     annotation=unwrapped_annotation,
-                    field_meta=field_meta,
+                    field_meta=unwrapped_annotation_meta,
                 )
 
             elif BaseFactory.is_factory_type(annotation=unwrapped_annotation):

tests/test_pydantic_factory.py

@@ -12,7 +12,7 @@
 from uuid import UUID
 
 import pytest
-from annotated_types import Ge, Gt, Le, LowerCase, MinLen, UpperCase
+from annotated_types import Ge, Gt, Le, LowerCase, MaxLen, MinLen, UpperCase
 from typing_extensions import Annotated, TypeAlias
 
 import pydantic
@@ -717,18 +717,50 @@ class C(BaseModel):
     assert CFactory.build()
 
 
-def test_constrained_union_types() -> None:
+@pytest.mark.skipif(IS_PYDANTIC_V2, reason="pydantic 1 only test")
+def test_constrained_union_types_pydantic_v1() -> None:
     class A(BaseModel):
         a: Union[Annotated[List[str], MinLen(100)], Annotated[int, Ge(1000)]]
         b: Union[List[Annotated[str, MinLen(100)]], int]
         c: Union[Annotated[List[int], MinLen(100)], None]
-        d: Union[Annotated[List[int], MinLen(100)], Annotated[List[str], MinLen(100)]]
-        e: Optional[Union[Annotated[List[int], MinLen(10)], Annotated[List[str], MinLen(10)]]]
+        d: Union[Annotated[List[int], MinLen(100)], Annotated[List[str], MaxLen(99)]]
+        e: Optional[Union[Annotated[List[int], MinLen(10)], Annotated[List[str], MaxLen(9)]]]
         f: Optional[Union[Annotated[List[int], MinLen(10)], List[str]]]
+        g: Optional[
+            Union[
+                Annotated[List[int], MinLen(10)],
+                Union[Annotated[List[str], MaxLen(9)], Annotated[Decimal, Field(max_digits=4, decimal_places=2)]],
+            ]
+        ]
+
+    AFactory = ModelFactory.create_factory(A, __allow_none_optionals__=False)
+
+    assert AFactory.build()
+    assert list(AFactory.coverage())
+
+
+@pytest.mark.skipif(IS_PYDANTIC_V1, reason="pydantic 2 only test")
+def test_constrained_union_types_pydantic_v2() -> None:
+    class A(BaseModel):
+        a: Union[Annotated[List[str], MinLen(100)], Annotated[int, Ge(1000)]]
+        b: Union[List[Annotated[str, MinLen(100)]], int]
+        c: Union[Annotated[List[int], MinLen(100)], None]
+        d: Union[Annotated[List[int], MinLen(100)], Annotated[List[str], MaxLen(99)]]
+        e: Optional[Union[Annotated[List[int], MinLen(10)], Annotated[List[str], MaxLen(9)]]]
+        f: Optional[Union[Annotated[List[int], MinLen(10)], List[str]]]
+        g: Optional[
+            Union[
+                Annotated[List[int], MinLen(10)],
+                Union[Annotated[List[str], MaxLen(9)], Annotated[Decimal, Field(max_digits=4, decimal_places=2)]],
+            ]
+        ]
+        # This annotation is not allowed in pydantic 1
+        h: Annotated[Union[List[int], List[str]], MinLen(10)]
 
     AFactory = ModelFactory.create_factory(A, __allow_none_optionals__=False)
 
     assert AFactory.build()
+    assert list(AFactory.coverage())
 
 
 @pytest.mark.parametrize("allow_none", (True, False))