def test_several_generic_bases_functions(type_, func): with temp_registered(_FirstBase, st.builds(type_)), temp_registered( _SecondBase, st.builds(type_)): find_any(st.builds(func)) with temp_registered(type_, st.builds(type_)): find_any(st.builds(func))
def test_issue_2951_regression_two_params(): map_strat = st.builds(SpecificDict, st.dictionaries(st.integers(), st.integers())) expected = repr(st.from_type(Dict[int, int])) with temp_registered(SpecificDict, map_strat): assert st.from_type(SpecificDict) == map_strat assert expected == repr(st.from_type(Dict[int, int]))
def test_generic_origin_from_type(): with temp_registered(MyGeneric, st.builds(MyGeneric)): find_any(st.from_type(MyGeneric[T])) find_any(st.from_type(MyGeneric[int])) find_any(st.from_type(MyGeneric)) find_any(st.builds(using_generic)) find_any(st.builds(using_concrete_generic))
def test_typevars_can_be_redefine_with_factory(): """We test that one can register a custom strategy for all type vars.""" A = typing.TypeVar("A") with temp_registered(typing.TypeVar, lambda thing: st.just(thing.__name__)): assert_all_examples(st.from_type(A), lambda obj: obj == "A")
def test_errors_if_generic_resolves_empty(): with temp_registered(UnknownType, lambda _: st.nothing()): fails_1 = st.from_type(UnknownType) with pytest.raises(ResolutionFailed): fails_1.example() fails_2 = st.from_type(ParentUnknownType) with pytest.raises(ResolutionFailed): fails_2.example()
def test_issue_2951_regression(): lines_strat = st.builds(Lines, lines=st.lists(st.text())) with temp_registered(Lines, lines_strat): assert st.from_type(Lines) == lines_strat # Now let's test that the strategy for ``Sequence[int]`` did not # change just because we registered a strategy for ``Lines``: expected = "one_of(binary(), lists(integers()))" assert repr(st.from_type(Sequence[int])) == expected
def test_register_generic_typing_strats(): # I don't expect anyone to do this, but good to check it works as expected with temp_registered(typing.Sequence, types._global_type_lookup[typing.Set]): # We register sets for the abstract sequence type, which masks subtypes # from supertype resolution but not direct resolution assert_all_examples(from_type(typing.Sequence[int]), lambda ex: isinstance(ex, set)) assert_all_examples( from_type(typing.Container[int]), lambda ex: not isinstance(ex, typing.Sequence), ) assert_all_examples(from_type(typing.List[int]), lambda ex: isinstance(ex, list))
def test_my_mappable(source: st.DataObject) -> None: """ Checks that complex types with multiple inheritance levels and strings are fine. Regression test for https://github.com/HypothesisWorks/hypothesis/issues/3060 """ # In `returns` we register all types in `__mro__` # to be this exact type at the moment. But here, we only need `Mappable`. # Current `__mro__` is `MyFunctor / Kind / Mappable`: assert MyFunctor.__mro__[2] is MappableN with temp_registered( MyFunctor.__mro__[2], st.builds(MyFunctor), ): assert source.draw(st.builds(target_func)) is True
def test_lookup_overrides_defaults(): sentinel = object() with temp_registered(int, st.just(sentinel)): @given(from_type(typing.List[int])) def inner_1(ex): assert all(elem is sentinel for elem in ex) inner_1() @given(from_type(typing.List[int])) def inner_2(ex): assert all(isinstance(elem, int) for elem in ex) inner_2()
def test_mutually_recursive_types_with_typevar(data): # The previously-failing example from the issue A = Dict[bool, "B"] # noqa: F821 - an undefined name is the whole point! B = Union[List[bool], A] with pytest.raises(ResolutionFailed, match=r"Could not resolve ForwardRef\('B'\)"): data.draw(st.from_type(A)) with utils.temp_registered( ForwardRef("B"), lambda _: st.deferred(lambda: b_strategy), ): b_strategy = st.from_type(B) data.draw(b_strategy) data.draw(st.from_type(A)) data.draw(st.from_type(B))
def test_mutually_recursive_types_with_typevar_alternate(data): # It's not particularly clear why this version passed when the previous # test failed, but different behaviour means we add both to the suite. C = Union[List[bool], "D"] # noqa: F821 - an undefined name is the whole point! D = Dict[bool, C] with pytest.raises(ResolutionFailed, match=r"Could not resolve ForwardRef\('D'\)"): data.draw(st.from_type(C)) with utils.temp_registered( ForwardRef("D"), lambda _: st.deferred(lambda: d_strategy), ): d_strategy = st.from_type(D) data.draw(d_strategy) data.draw(st.from_type(C)) data.draw(st.from_type(D))
def test_abstract_resolver_fallback(): # We create our distinct strategies for abstract and concrete types gen_abstractbar = _from_type(AbstractBar) gen_concretebar = st.builds(ConcreteBar, x=st.none()) assert gen_abstractbar != gen_concretebar # And trying to generate an instance of the abstract type fails, # UNLESS the concrete type is currently resolvable with pytest.raises(ResolutionFailed): gen_abstractbar.example() with temp_registered(ConcreteBar, gen_concretebar): gen = gen_abstractbar.example() with pytest.raises(ResolutionFailed): gen_abstractbar.example() # which in turn means we resolve to the concrete subtype. assert isinstance(gen, ConcreteBar)
def test_lookup_overrides_defaults(typ): sentinel = object() with temp_registered(typ, st.just(sentinel)): assert st.from_type(typ).example() is sentinel assert st.from_type(typ).example() is not sentinel
def test_typevars_can_be_redefined(): """We test that one can register a custom strategy for all type vars.""" A = typing.TypeVar("A") with temp_registered(typing.TypeVar, st.just(1)): assert_all_examples(st.from_type(A), lambda obj: obj == 1)
def test_generic_origin_from_type(strat, type_): with temp_registered(MyGeneric, st.builds(MyGeneric)): find_any(strat(type_))
def test_custom_type_resolution(): sentinel = object() with temp_registered(UnknownType, st.just(sentinel)): assert st.from_type(UnknownType).example() is sentinel # Also covered by registration of child class assert st.from_type(ParentUnknownType).example() is sentinel
def test_bound_type_cheking_only_forward_ref_wrong_type(): """We should check ``ForwardRef`` parameter name correctly.""" with utils.temp_registered(ForwardRef("WrongType"), st.just(1)): with pytest.raises(ResolutionFailed): st.builds(typechecking_only_fun).example()
def test_bound_type_cheking_only_forward_ref(): """We should fallback to registering explicit ``ForwardRef`` when we have to.""" with utils.temp_registered(ForwardRef("ExcInfo"), st.just(1)): st.builds(typechecking_only_fun).example()
def test_resolving_recursive_type_with_registered_constraint(): with temp_registered(SomeClass, st.builds(SomeClass, value=st.integers(min_value=1))): find_any(st.from_type(SomeClass), lambda s: s.next_node is None) find_any(st.from_type(SomeClass), lambda s: s.next_node is not None)
def test_can_register_new_type_for_typeddicts(): sentinel = object() with temp_registered(C, st.just(sentinel)): assert st.from_type(C).example() is sentinel
def test_custom_type_resolution_with_function(): sentinel = object() with temp_registered(UnknownType, lambda _: st.just(sentinel)): assert st.from_type(UnknownType).example() is sentinel assert st.from_type(ParentUnknownType).example() is sentinel
def test_several_generic_bases_wrong_functions(func): with temp_registered(AllConcrete, st.builds(AllConcrete)): with pytest.raises(ResolutionFailed): st.builds(func).example()
def test_custom_type_resolution_with_function_non_strategy(): with temp_registered(UnknownType, lambda _: None): with pytest.raises(ResolutionFailed): st.from_type(UnknownType).example() with pytest.raises(ResolutionFailed): st.from_type(ParentUnknownType).example()
def test_several_generic_bases(type_): with temp_registered(_FirstBase, st.builds(type_)): find_any(st.builds(_FirstBase)) with temp_registered(_SecondBase, st.builds(type_)): find_any(st.builds(_SecondBase))
def test_generic_origin_concrete_builds(): with temp_registered(MyGeneric, st.builds(MyGeneric, st.integers())): assert_all_examples(st.builds(using_generic), lambda example: isinstance(example, int))
def test_generic_origin_without_type_args(generic): with temp_registered(generic, st.just("example")): pass