Enhancement: support creation of Hypothesis strategies
guacs opened this issue · 4 comments
Summary
I was playing around with hypothesis and noticed that it can't create strategies when there are constraints on the fields. So, I'm proposing that polyfactory
supports creation of strategies for a given model, with the constraints being respected.
Currently, there seems to be plans to support this as seen in this issue, however that would require the users use the annotated types for the constraints. Furthermore, while pydantic v1 did use to integrate with hypothesis, the latest version does not so as documented here.
Would this be something that would be helpful and worth implementing? Opinions, @litestar-org/members?
Basic Example
from typing import Annotated, Any
import msgspec
from hypothesis import given
from hypothesis import strategies as st
from hypothesis.strategies import SearchStrategy
from msgspec import Struct
from msgspec.structs import asdict
from polyfactory.factories.msgspec_factory import MsgspecFactory
from polyfactory.field_meta import FieldMeta
class Foo(Struct):
foo: Annotated[int, msgspec.Meta(ge=100)]
def handle_constrained_int(field_meta: FieldMeta) -> SearchStrategy[int]:
return st.integers(min_value=field_meta.constraints.get("ge"))
class FooFactory(MsgspecFactory[Foo]):
__model__ = Foo
@classmethod
def create_hypothesis_strategy(cls) -> SearchStrategy[Foo]:
st_kwargs: dict[str, SearchStrategy[Any]] = {}
for field in cls.get_model_fields():
if field.annotation is int:
st_kwargs[field.name] = handle_constrained_int(field)
return st.builds(cls.__model__, **st_kwargs)
polyfactory_foo_st = FooFactory.create_hypothesis_strategy()
hypothesis_foo_st = st.builds(Foo)
@given(polyfactory_foo_st)
def test_polyfactory_foo_st(foo: Foo):
foo_dict = asdict(foo)
_ = msgspec.convert(foo_dict, Foo)
@given(hypothesis_foo_st)
def test_hypothesis_foo_st(foo: Foo):
foo_dict = asdict(foo)
_ = msgspec.convert(foo_dict, Foo) # this will fail the msgspec validation
if __name__ == "__main__":
# test_polyfactory_foo_st()
test_hypothesis_foo_st()
Drawbacks and Impact
No response
Unresolved questions
No response
Funding
- If you would like to see an issue prioritized, make a pledge towards it!
- We receive the pledge once the issue is completed & verified
Yes :)
See my https://sobolevn.me/2021/02/make-tests-a-part-of-your-app article, feel free to assign some tasks on me.
Yes :)
See my https://sobolevn.me/2021/02/make-tests-a-part-of-your-app article, feel free to assign some tasks on me.
That's great! I'll try to get the basic structure ready for it, and then you can make improvements/changes in that branch?
Also, for the following case from your article:
import deal
@deal.pre(lambda a, b: a >= 0 and b >= 0)
@deal.raises(ZeroDivisionError) # this function can raise if `b=0`, it is ok
def div(a: int, b: int) -> float:
return a / b
Do you think at some point mypy
would be able to handle the annotated (maybe only for annotated-types
) constraints as well? So, I would expect something like the following:
def div(a: Annotated[int, Ge(0)], b: Annotated[int, Ge(0)]) -> float:
return a / b
a = -1
b = 23
div(a, b) # type check error
if a >= 0 and b >= 0:
div(a, b) # no type check error
By design mypy won't treat Annotated[T]
as something different from just T
. But! We have phantom-types for that :)
By design mypy won't treat
Annotated[T]
as something different from justT
. But! We have phantom-types for that :)
Oh this is really cool