fix: update resolution order to favour provider types (litestar-org#832)

Author: adhtruong

polyfactory/factories/base.py

@@ -784,6 +784,10 @@ def get_field_value(  # noqa: C901, PLR0911, PLR0912
 
             return cls.get_field_value(cls.__random__.choice(children), field_build_parameters, build_context)
 
+        provider_map = cls.get_provider_map()
+        if provider := (provider_map.get(field_meta.annotation) or provider_map.get(unwrapped_annotation)):
+            return provider()
+
         if BaseFactory.is_factory_type(annotation=unwrapped_annotation):
             if not field_build_parameters and unwrapped_annotation in build_context["seen_models"]:
                 return None if is_optional(field_meta.annotation) else Null
@@ -844,10 +848,6 @@ def get_field_value(  # noqa: C901, PLR0911, PLR0912
                 build_context=build_context,
             )
 
-        provider_map = cls.get_provider_map()
-        if provider := (provider_map.get(field_meta.annotation) or provider_map.get(unwrapped_annotation)):
-            return provider()
-
         if is_type_var(unwrapped_annotation):
             return create_random_string(cls.__random__, min_length=1, max_length=10)
 
@@ -913,6 +913,12 @@ def get_field_value_coverage(  # noqa: C901,PLR0912
                     field_meta=unwrapped_annotation_meta,
                 )
 
+            elif provider := (
+                (provider_map := cls.get_provider_map()).get(field_meta.annotation)
+                or provider_map.get(unwrapped_annotation)
+            ):
+                yield CoverageContainerCallable(provider)
+
             elif BaseFactory.is_factory_type(annotation=unwrapped_annotation):
                 yield CoverageContainer(
                     cls._get_or_create_factory(model=unwrapped_annotation).coverage(
@@ -935,12 +941,6 @@ def get_field_value_coverage(  # noqa: C901,PLR0912
 
                 yield handle_collection_type_coverage(child_meta, origin, cls, build_context=build_context)
 
-            elif provider := (
-                (provider_map := cls.get_provider_map()).get(field_meta.annotation)
-                or provider_map.get(unwrapped_annotation)
-            ):
-                yield CoverageContainerCallable(provider)
-
             elif is_type_var(unwrapped_annotation):
                 yield create_random_string(cls.__random__, min_length=1, max_length=10)
 

tests/test_provider_map.py

@@ -3,9 +3,12 @@
 
 import pytest
 
+from pydantic import BaseModel
+
 from polyfactory.exceptions import ParameterException
 from polyfactory.factories.base import BaseFactory
 from polyfactory.factories.dataclass_factory import DataclassFactory
+from polyfactory.factories.pydantic_factory import ModelFactory
 
 
 def test_provider_map() -> None:
@@ -60,6 +63,46 @@ def get_provider_map(cls) -> dict[Any, Callable[[], Any]]:
     assert all(result.foo == "any" for result in coverage_result)
 
 
+def test_provider_map_takes_priority_over_factory_type() -> None:
+    """Custom providers should take precedence over built-in factory type resolution."""
+
+    @dataclass
+    class Inner:
+        value: str
+
+    @dataclass
+    class Outer:
+        inner: Inner
+
+    sentinel = Inner(value="from_provider")
+
+    class OuterFactory(DataclassFactory[Outer]):
+        @classmethod
+        def get_provider_map(cls) -> dict[Any, Callable[[], Any]]:
+            return {Inner: lambda: sentinel, **super().get_provider_map()}
+
+    assert OuterFactory.build().inner is sentinel
+    assert all(result.inner is sentinel for result in OuterFactory.coverage())
+
+
+def test_provider_map_takes_priority_over_pydantic_factory_type() -> None:
+    """Custom providers should take precedence for Pydantic model fields."""
+
+    class InnerModel(BaseModel):
+        value: str
+
+    class OuterModel(BaseModel):
+        inner: InnerModel
+
+    class OuterFactory(ModelFactory[OuterModel]):
+        @classmethod
+        def get_provider_map(cls) -> dict[Any, Callable[[], Any]]:
+            return {InnerModel: lambda: InnerModel(value="from_provider"), **super().get_provider_map()}
+
+    assert OuterFactory.build().inner.value == "from_provider"
+    assert all(result.inner.value == "from_provider" for result in OuterFactory.coverage())
+
+
 def test_add_custom_provider() -> None:
     class CustomType:
         def __init__(self, _: Any) -> None: