def test_resolves_NewType(): typ = typing.NewType('T', int) nested = typing.NewType('NestedT', typ) uni = typing.NewType('UnionT', typing.Optional[int]) assert isinstance(from_type(typ).example(), integer_types) assert isinstance(from_type(nested).example(), integer_types) assert isinstance(from_type(uni).example(), integer_types + (type(None),))
def test_register_generic_typing_strats(): # I don't expect anyone to do this, but good to check it works as expected try: # We register sets for the abstract sequence type, which masks subtypes # from supertype resolution but not direct resolution st.register_type_strategy( typing.Sequence, types._global_type_lookup[typing.Set] ) @given(from_type(typing.Sequence[int])) def inner_1(ex): assert isinstance(ex, set) @given(from_type(typing.Container[int])) def inner_2(ex): assert not isinstance(ex, typing.Sequence) @given(from_type(typing.List[int])) def inner_3(ex): assert isinstance(ex, list) inner_1() inner_2() inner_3() finally: types._global_type_lookup.pop(typing.Sequence) st.from_type.__clear_cache()
def test_cannot_resolve_bare_forward_reference(thing): with pytest.raises(InvalidArgument): t = thing["int"] if type(getattr(t, "__args__", [None])[0]) != ForwardRef: assert sys.version_info[:2] == (3, 5) pytest.xfail("python 3.5 typing module is really weird") st.from_type(t).example()
def test_variable_length_tuples(n): type_ = typing.Tuple[int, ...] try: from_type(type_).filter(lambda ex: len(ex) == n).example() except NoExamples: if sys.version_info[:2] < (3, 6): pytest.skip() raise
def test_custom_type_resolution_with_function_non_strategy(): try: st.register_type_strategy(UnknownType, lambda _: None) with pytest.raises(ResolutionFailed): st.from_type(UnknownType).example() with pytest.raises(ResolutionFailed): st.from_type(ParentUnknownType).example() finally: types._global_type_lookup.pop(UnknownType)
def test_custom_type_resolution_with_function(): sentinel = object() try: st.register_type_strategy(UnknownType, lambda _: st.just(sentinel)) assert st.from_type(UnknownType).example() is sentinel assert st.from_type(ParentUnknownType).example() is sentinel finally: types._global_type_lookup.pop(UnknownType) st.from_type.__clear_cache()
def test_lookup_overrides_defaults(typ): sentinel = object() try: strat = types._global_type_lookup[typ] st.register_type_strategy(typ, st.just(sentinel)) assert st.from_type(typ).example() is sentinel finally: st.register_type_strategy(typ, strat) st.from_type.__clear_cache() assert st.from_type(typ).example() is not sentinel
def test_custom_type_resolution(): sentinel = object() try: st.register_type_strategy(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 finally: types._global_type_lookup.pop(UnknownType) st.from_type.__clear_cache() assert UnknownType not in types._global_type_lookup
def test_errors_if_generic_resolves_empty(): try: st.register_type_strategy(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() finally: types._global_type_lookup.pop(UnknownType) st.from_type.__clear_cache()
def from_typing_type(thing): # We start with special-case support for Union and Tuple - the latter # isn't actually a generic type. Support for Callable may be added to # this section later. # We then explicitly error on non-Generic types, which don't carry enough # information to sensibly resolve to strategies at runtime. # Finally, we run a variation of the subclass lookup in st.from_type # among generic types in the lookup. import typing # Under 3.6 Union is handled directly in st.from_type, as the argument is # not an instance of `type`. However, under Python 3.5 Union *is* a type # and we have to handle it here, including failing if it has no parameters. if hasattr(thing, '__union_params__'): # pragma: no cover args = sorted(thing.__union_params__ or (), key=type_sorting_key) if not args: raise ResolutionFailed('Cannot resolve Union of no types.') return st.one_of([st.from_type(t) for t in args]) if isinstance(thing, typing.TupleMeta): elem_types = getattr(thing, '__tuple_params__', None) or () elem_types += getattr(thing, '__args__', None) or () if getattr(thing, '__tuple_use_ellipsis__', False) or \ len(elem_types) == 2 and elem_types[-1] is Ellipsis: return st.lists(st.from_type(elem_types[0])).map(tuple) return st.tuples(*map(st.from_type, elem_types)) # Now, confirm that we're dealing with a generic type as we expected if not isinstance(thing, typing.GenericMeta): # pragma: no cover raise ResolutionFailed('Cannot resolve %s to a strategy' % (thing,)) # Parametrised generic types have their __origin__ attribute set to the # un-parametrised version, which we need to use in the subclass checks. # e.g.: typing.List[int].__origin__ == typing.List mapping = {k: v for k, v in _global_type_lookup.items() if isinstance(k, typing.GenericMeta) and try_issubclass(k, getattr(thing, '__origin__', None) or thing)} if typing.Dict in mapping: # The subtype relationships between generic and concrete View types # are sometimes inconsistent under Python 3.5, so we pop them out to # preserve our invariant that all examples of from_type(T) are # instances of type T - and simplify the strategy for abstract types # such as Container for t in (typing.KeysView, typing.ValuesView, typing.ItemsView): mapping.pop(t, None) strategies = [v if isinstance(v, st.SearchStrategy) else v(thing) for k, v in mapping.items() if sum(try_issubclass(k, T) for T in mapping) == 1] empty = ', '.join(repr(s) for s in strategies if s.is_empty) if empty or not strategies: # pragma: no cover raise ResolutionFailed( 'Could not resolve %s to a strategy; consider using ' 'register_type_strategy' % (empty or thing,)) return st.one_of(strategies)
def everything_except(excluded_types): """Recipe copied from the docstring of ``from_type``""" return ( st.from_type(type) .flatmap(st.from_type) .filter(lambda x: not isinstance(x, excluded_types)) )
def test_typevar_type_is_consistent(data, var, expected): strat = st.from_type(var) v1 = data.draw(strat) v2 = data.draw(strat) assume(v1 != v2) # Values may vary, just not types assert type(v1) == type(v2) assert isinstance(v1, expected)
def wrapped_test(*arguments, **kwargs): # Tell pytest to omit the body of this function from tracebacks __tracebackhide__ = True settings = wrapped_test._hypothesis_internal_use_settings random = get_random_for_wrapped_test(test, wrapped_test) if infer in generator_kwargs.values(): hints = get_type_hints(test) for name in [name for name, value in generator_kwargs.items() if value is infer]: if name not in hints: raise InvalidArgument( 'passed %s=infer for %s, but %s has no type annotation' % (name, test.__name__, name)) generator_kwargs[name] = st.from_type(hints[name]) processed_args = process_arguments_to_given( wrapped_test, arguments, kwargs, generator_arguments, generator_kwargs, argspec, test, settings ) arguments, kwargs, test_runner, search_strategy = processed_args execute_explicit_examples( test_runner, test, wrapped_test, settings, arguments, kwargs ) if settings.max_examples <= 0: return if not ( Phase.reuse in settings.phases or Phase.generate in settings.phases ): return try: perform_health_checks( random, settings, test_runner, search_strategy) state = StateForActualGivenExecution( test_runner, search_strategy, test, settings, random) state.run() except: generated_seed = \ wrapped_test._hypothesis_internal_use_generated_seed if generated_seed is not None: if running_under_pytest: report(( 'You can add @seed(%(seed)d) to this test or run ' 'pytest with --hypothesis-seed=%(seed)d to ' 'reproduce this failure.') % { 'seed': generated_seed},) else: report(( 'You can add @seed(%d) to this test to reproduce ' 'this failure.') % (generated_seed,)) raise
def test_cannot_register_empty(): # Cannot register and did not register with pytest.raises(InvalidArgument): st.register_type_strategy(UnknownType, st.nothing()) fails = st.from_type(UnknownType) with pytest.raises(ResolutionFailed): fails.example() assert UnknownType not in types._global_type_lookup
def test_resolve_core_strategies(typ): @given(st.from_type(typ)) def inner(ex): if PY2 and issubclass(typ, integer_types): assert isinstance(ex, integer_types) else: assert isinstance(ex, typ) inner()
def resolve_Callable(thing): # Generated functions either accept no arguments, or arbitrary arguments. # This is looser than ideal, but anything tighter would generally break # use of keyword arguments and we'd rather not force positional-only. if not thing.__args__: # pragma: no cover # varies by minor version return st.functions() return st.functions( like=(lambda: None) if len(thing.__args__) == 1 else (lambda *a, **k: None), returns=st.from_type(thing.__args__[-1]), )
def test_36_specialised_collection_types(): @given(from_type(typing.DefaultDict[int, int])) def inner(ex): if sys.version_info[:2] >= (3, 6): assume(ex) assert isinstance(ex, collections.defaultdict) assert all(isinstance(elem, int) for elem in ex) assert all(isinstance(elem, int) for elem in ex.values()) inner()
def test_lookup_overrides_defaults(): sentinel = object() try: st.register_type_strategy(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() finally: st.register_type_strategy(int, st.integers()) st.from_type.__clear_cache() @given(from_type(typing.List[int])) def inner_2(ex): assert all(isinstance(elem, int) for elem in ex) inner_2()
def test_ItemsView(): @given(from_type(typing.ItemsView[int, int])) def inner(ex): # See https://github.com/python/typing/issues/177 if sys.version_info[:2] >= (3, 6): assume(ex) assert isinstance(ex, type({}.items())) assert all(isinstance(elem, tuple) and len(elem) == 2 for elem in ex) assert all(all(isinstance(e, int) for e in elem) for elem in ex) inner()
def types_to_strategy(attrib, types): """Find all the type metadata for this attribute, reconcile it, and infer a strategy from the mess.""" # If we know types from the validator(s), that's sufficient. if len(types) == 1: typ, = types if isinstance(typ, tuple): return st.one_of(*map(st.from_type, typ)) return st.from_type(typ) elif types: # We have a list of tuples of types, and want to find a type # (or tuple of types) that is a subclass of all of of them. type_tuples = [k if isinstance(k, tuple) else (k,) for k in types] # Flatten the list, filter types that would fail validation, and # sort so that ordering is stable between runs and shrinks well. allowed = [ t for t in set(sum(type_tuples, ())) if all(issubclass(t, tup) for tup in type_tuples) ] allowed.sort(key=type_sorting_key) return st.one_of([st.from_type(t) for t in allowed]) # Otherwise, try the `type` attribute as a fallback, and finally try # the type hints on a converter (desperate!) before giving up. if isinstance(getattr(attrib, "type", None), type): # The convoluted test is because variable annotations may be stored # in string form; attrs doesn't evaluate them and we don't handle them. # See PEP 526, PEP 563, and Hypothesis issue #1004 for details. return st.from_type(attrib.type) converter = getattr(attrib, "converter", None) if isinstance(converter, type): return st.from_type(converter) elif callable(converter): hints = get_type_hints(converter) if "return" in hints: return st.from_type(hints["return"]) return st.nothing()
def test_specialised_collection_types(typ, coll_type, instance_of): @given(from_type(typ)) def inner(ex): if sys.version_info[:2] >= (3, 6): assume(ex) assert isinstance(ex, coll_type) assert all(isinstance(elem, instance_of) for elem in ex) try: inner() except (ResolutionFailed, AssertionError): if sys.version_info[:2] < (3, 6): pytest.skip('Hard-to-reproduce bug (early version of typing?)') raise
def test_resolve_typing_module(typ): @given(from_type(typ)) def inner(ex): if typ in (typing.BinaryIO, typing.TextIO): assert isinstance(ex, io.IOBase) elif typ is typing.Tuple: # isinstance is incompatible with Tuple on early 3.5 assert ex == () elif isinstance(typ, typing._ProtocolMeta): pass else: try: assert isinstance(ex, typ) except TypeError: if sys.version_info[:2] < (3, 6): pytest.skip() raise inner()
def test_resolve_typing_module(typ): @settings(suppress_health_check=[HealthCheck.too_slow, HealthCheck.filter_too_much]) @given(from_type(typ)) def inner(ex): if typ in (typing.BinaryIO, typing.TextIO): assert isinstance(ex, io.IOBase) elif typ is typing.Tuple: # isinstance is incompatible with Tuple on early 3.5 assert ex == () elif isinstance(typ, typing._ProtocolMeta): pass elif typ is typing.Type and not isinstance(typing.Type, type): assert isinstance(ex, typing.TypeVar) else: try: assert isinstance(ex, typ) except TypeError: if sys.version_info[:2] < (3, 6): pytest.skip() raise inner()
def _from_hashable_type(type_): if type_ in ALWAYS_HASHABLE_TYPES: return st.from_type(type_) else: return st.from_type(type_).filter(_can_hash)
def resolve_Dict(thing): # If thing is a Collection instance, we need to fill in the values keys_vals = thing.__args__ * 2 return st.dictionaries( _from_hashable_type(keys_vals[0]), st.from_type(keys_vals[1]) )
def test_resolves_forwardrefs_to_builtin_types(t): v = st.from_type(typing.ForwardRef(t.__name__)).example() assert isinstance(v, t)
def resolve_List(thing): return st.lists(st.from_type(thing.__args__[0]))
def test_repr_passthrough(typ, repr_): assert repr(st.from_type(typ)) == repr_
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_can_register_NewType(): Name = typing.NewType("Name", str) st.register_type_strategy(Name, st.just("Eric Idle")) assert st.from_type(Name).example() == "Eric Idle"
def test_cannot_resolve_bare_forward_reference(thing): with pytest.raises(InvalidArgument): t = thing["ConcreteFoo"] st.from_type(t).example()
def resolve_KeysView(thing): return st.dictionaries(st.from_type(thing.__args__[0]), st.none() ).map(dict.keys)
def resolve_Iterator(thing): return st.iterables(st.from_type(thing.__args__[0]))
def resolve_FrozenSet(thing): return st.frozensets(st.from_type(thing.__args__[0]))
def test_bytestring_is_valid_sequence_of_int_and_parent_classes(type_): find_any( st.from_type(typing.Sequence[type_]), lambda val: isinstance(val, typing.ByteString), )
def test_resolves_type_of_builtin_types(t): v = st.from_type(typing.Type[t.__name__]).example() assert v is t
def resolve_ValuesView(thing): return st.dictionaries(st.integers(), st.from_type(thing.__args__[0])).map( dict.values )
def test_resolves_weird_types(typ): from_type(typ).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_from_type_can_be_default_or_annotation(): find_any(st.from_type(AnnotatedAndDefault), lambda x: x.foo is None) find_any(st.from_type(AnnotatedAndDefault), lambda x: isinstance(x.foo, bool))
def test_specialised_scalar_types(data, typ, instance_of): ex = data.draw(from_type(typ)) assert isinstance(ex, instance_of)
def test_typing_Type_int(): assert from_type(typing.Type[int]).example() is int
def test_generic_collections_only_use_hashable_elements(typ, data): data.draw(from_type(typ))
def test_timezone_lookup(type_): assert issubclass(type_, datetime.tzinfo) assert_all_examples(st.from_type(type_), lambda t: isinstance(t, type_))
def everything_except( excluded_types: Union[type, Tuple[type, ...]]) -> st.SearchStrategy[Any]: return (st.from_type(type).flatmap( st.from_type).filter(lambda x: not isinstance(x, excluded_types)))
def test_resolves_builtin_types(t): v = st.from_type(t).example() assert isinstance(v, t)
def test_variable_length_tuples(n): type_ = typing.Tuple[int, ...] from_type(type_).filter(lambda ex: len(ex) == n).example()
import decimal import typing as t from hypothesis import given, strategies as st import pytest from genbu import Param, InvalidOption from genbu.params import default_aggregator @pytest.mark.parametrize("dest,optargs", [ ("foo", ["--foo=bar"]), ("bar", ["--bar baz"]), ]) def test_param_with_invalid_option(dest: str, optargs: t.List[str]) -> None: """Param should raise InvalidOption if option dest has = or whitespace.""" with pytest.raises(InvalidOption): Param(dest=dest, optargs=optargs) assert Param(dest=dest) @given( st.lists( st.from_type(object).filter( lambda x: type(x) not in (complex, float, decimal.Decimal), ), min_size=1, ), ) def test_default_aggregator(lst: t.List[t.Any]) -> None: """default_aggregator should return last element.""" assert default_aggregator(lst) == lst[-1]
@attr.s class Required(object): a = attr.ib() @attr.s class UnhelpfulConverter(object): a = attr.ib(converter=lambda x: x) @given(st.builds(Inferrables, has_default=infer, has_default_factory=infer)) def test_attrs_inference_builds(c): pass @given(st.from_type(Inferrables)) def test_attrs_inference_from_type(c): pass @pytest.mark.parametrize("c", [Required, UnhelpfulConverter]) def test_cannot_infer(c): with pytest.raises(ResolutionFailed): st.builds(c).example() def test_cannot_infer_takes_self(): with pytest.raises(ResolutionFailed): st.builds(Inferrables, has_default_factory_takes_self=infer).example()
def from_typing_type(thing): # We start with special-case support for Union and Tuple - the latter # isn't actually a generic type. Then we handle Literal since it doesn't # support `isinstance`. # # We then explicitly error on non-Generic types, which don't carry enough # information to sensibly resolve to strategies at runtime. # Finally, we run a variation of the subclass lookup in `st.from_type` # among generic types in the lookup. if getattr(thing, "__origin__", None) == tuple or isinstance( thing, getattr(typing, "TupleMeta", ()) ): elem_types = getattr(thing, "__tuple_params__", None) or () elem_types += getattr(thing, "__args__", None) or () if ( getattr(thing, "__tuple_use_ellipsis__", False) or len(elem_types) == 2 and elem_types[-1] is Ellipsis ): return st.lists(st.from_type(elem_types[0])).map(tuple) elif len(elem_types) == 1 and elem_types[0] == (): return st.tuples() # Empty tuple; see issue #1583 return st.tuples(*map(st.from_type, elem_types)) if hasattr(typing, "Final") and getattr(thing, "__origin__", None) == typing.Final: return st.one_of([st.from_type(t) for t in thing.__args__]) if is_typing_literal(thing): args_dfs_stack = list(thing.__args__) literals = [] while args_dfs_stack: arg = args_dfs_stack.pop() if is_typing_literal(arg): args_dfs_stack.extend(reversed(arg.__args__)) else: literals.append(arg) return st.sampled_from(literals) # Now, confirm that we're dealing with a generic type as we expected if not isinstance(thing, typing_root_type): # pragma: no cover raise ResolutionFailed("Cannot resolve %s to a strategy" % (thing,)) # Some "generic" classes are not generic *in* anything - for example both # Hashable and Sized have `__args__ == ()` on Python 3.7 or later. # (In 3.6 they're just aliases for the collections.abc classes) origin = getattr(thing, "__origin__", thing) if ( typing.Hashable is not collections.abc.Hashable and origin in vars(collections.abc).values() and len(getattr(thing, "__args__", None) or []) == 0 ): return st.from_type(origin) # Parametrised generic types have their __origin__ attribute set to the # un-parametrised version, which we need to use in the subclass checks. # e.g.: typing.List[int].__origin__ == typing.List mapping = { k: v for k, v in _global_type_lookup.items() if is_generic_type(k) and try_issubclass(k, thing) } if typing.Dict in mapping: # ItemsView can cause test_lookup.py::test_specialised_collection_types # to fail, due to weird isinstance behaviour around the elements. mapping.pop(typing.ItemsView, None) if sys.version_info[:2] == (3, 6): # pragma: no cover # `isinstance(dict().values(), Container) is False` on py36 only -_- mapping.pop(typing.ValuesView, None) if len(mapping) > 1: # issubclass treats bytestring as a kind of sequence, which it is, # but treating it as such breaks everything else when it is presumed # to be a generic sequence or container that could hold any item. # Except for sequences of integers, or unions which include integer! # See https://github.com/HypothesisWorks/hypothesis/issues/2257 # # This block drops ByteString from the types that can be generated # if there is more than one allowed type, and the element type is # not either `int` or a Union with `int` as one of its elements. elem_type = (getattr(thing, "__args__", None) or ["not int"])[0] if getattr(elem_type, "__origin__", None) is typing.Union: union_elems = elem_type.__args__ else: union_elems = () if not any( isinstance(T, type) and issubclass(int, T) for T in list(union_elems) + [elem_type] ): mapping.pop(typing.ByteString, None) strategies = [ v if isinstance(v, st.SearchStrategy) else v(thing) for k, v in mapping.items() if sum(try_issubclass(k, T) for T in mapping) == 1 ] empty = ", ".join(repr(s) for s in strategies if s.is_empty) if empty or not strategies: raise ResolutionFailed( "Could not resolve %s to a strategy; consider using " "register_type_strategy" % (empty or thing,) ) return st.one_of(strategies)
st.just("reason")), enumerate: st.builds(enumerate, st.just(())), filter: st.builds(filter, st.just(lambda _: None), st.just( ())), # type: ignore map: st.builds(map, st.just(lambda _: None), st.just(())), # type: ignore reversed: st.builds(reversed, st.just(())), # type: ignore classmethod: st.builds(classmethod, st.just(lambda self: self)), staticmethod: st.builds(staticmethod, st.just(lambda self: self)), super: st.builds(super, st.from_type(type)), # Pull requests with more types welcome! } if zoneinfo is not None: # pragma: no branch _global_type_lookup[zoneinfo.ZoneInfo] = st.timezones() if PYPY: _global_type_lookup[builtins.sequenceiterator] = st.builds( iter, st.tuples()) # type: ignore _global_type_lookup[type] = st.sampled_from( [type(None)] + sorted(_global_type_lookup, key=str)) if sys.version_info[:2] >= (3, 7): # pragma: no branch _global_type_lookup[re.Match] = (st.text().map( lambda c: re.match(".", c, flags=re.DOTALL)).filter(bool)) _global_type_lookup[re.Pattern] = st.builds(re.compile,
def test_does_not_resolve_special_cases(typ): with pytest.raises(InvalidArgument): from_type(typ).example()
def resolve_Dict(thing): # If thing is a Collection instance, we need to fill in the values keys_vals = [st.from_type(t) for t in thing.__args__] * 2 return st.dictionaries(keys_vals[0], keys_vals[1])
def resolve_Counter(thing): return st.dictionaries( keys=st.from_type(thing.__args__[0]), values=st.integers(), ).map(collections.Counter)
def resolve_ValuesView(thing): return st.dictionaries(st.integers(), st.from_type(thing.__args__[0]) ).map(dict.values)
def resolve_deque(thing): return st.lists(st.from_type(thing.__args__[0])).map(collections.deque)
def wrapped_test(*arguments, **kwargs): # Tell pytest to omit the body of this function from tracebacks __tracebackhide__ = True test = wrapped_test.hypothesis.inner_test if getattr(test, 'is_hypothesis_test', False): note_deprecation(( 'You have applied @given to test: %s more than once. In ' 'future this will be an error. Applying @given twice ' 'wraps the test twice, which can be extremely slow. A ' 'similar effect can be gained by combining the arguments ' 'of the two calls to given. For example, instead of ' '@given(booleans()) @given(integers()), you could write ' '@given(booleans(), integers())') % (test.__name__, ) ) settings = wrapped_test._hypothesis_internal_use_settings random = get_random_for_wrapped_test(test, wrapped_test) if infer in generator_kwargs.values(): hints = get_type_hints(test) for name in [name for name, value in generator_kwargs.items() if value is infer]: if name not in hints: raise InvalidArgument( 'passed %s=infer for %s, but %s has no type annotation' % (name, test.__name__, name)) generator_kwargs[name] = st.from_type(hints[name]) processed_args = process_arguments_to_given( wrapped_test, arguments, kwargs, generator_arguments, generator_kwargs, argspec, test, settings ) arguments, kwargs, test_runner, search_strategy = processed_args runner = getattr(search_strategy, 'runner', None) if isinstance(runner, TestCase) and test.__name__ in dir(TestCase): msg = ('You have applied @given to the method %s, which is ' 'used by the unittest runner but is not itself a test.' ' This is not useful in any way.' % test.__name__) fail_health_check(settings, msg, HealthCheck.not_a_test_method) if bad_django_TestCase(runner): # pragma: no cover # Covered by the Django tests, but not the pytest coverage task raise InvalidArgument( 'You have applied @given to a method on %s, but this ' 'class does not inherit from the supported versions in ' '`hypothesis.extra.django`. Use the Hypothesis variants ' 'to ensure that each example is run in a separate ' 'database transaction.' % qualname(type(runner)) ) state = StateForActualGivenExecution( test_runner, search_strategy, test, settings, random, had_seed=wrapped_test._hypothesis_internal_use_seed ) reproduce_failure = \ wrapped_test._hypothesis_internal_use_reproduce_failure if reproduce_failure is not None: expected_version, failure = reproduce_failure if expected_version != __version__: raise InvalidArgument(( 'Attempting to reproduce a failure from a different ' 'version of Hypothesis. This failure is from %s, but ' 'you are currently running %r. Please change your ' 'Hypothesis version to a matching one.' ) % (expected_version, __version__)) try: state.execute(ConjectureData.for_buffer( decode_failure(failure)), print_example=True, is_final=True, ) raise DidNotReproduce( 'Expected the test to raise an error, but it ' 'completed successfully.' ) except StopTest: raise DidNotReproduce( 'The shape of the test data has changed in some way ' 'from where this blob was defined. Are you sure ' "you're running the same test?" ) except UnsatisfiedAssumption: raise DidNotReproduce( 'The test data failed to satisfy an assumption in the ' 'test. Have you added it since this blob was ' 'generated?' ) execute_explicit_examples( test_runner, test, wrapped_test, settings, arguments, kwargs ) if settings.max_examples <= 0: return if not ( Phase.reuse in settings.phases or Phase.generate in settings.phases ): return try: if isinstance(runner, TestCase) and hasattr(runner, 'subTest'): subTest = runner.subTest try: setattr(runner, 'subTest', fake_subTest) state.run() finally: setattr(runner, 'subTest', subTest) else: state.run() except BaseException: generated_seed = \ wrapped_test._hypothesis_internal_use_generated_seed if generated_seed is not None and not state.failed_normally: with local_settings(settings): if running_under_pytest: report( 'You can add @seed(%(seed)d) to this test or ' 'run pytest with --hypothesis-seed=%(seed)d ' 'to reproduce this failure.' % { 'seed': generated_seed}) else: report( 'You can add @seed(%d) to this test to ' 'reproduce this failure.' % (generated_seed,)) raise
def resolve_Generator(thing): yields, _, returns = thing.__args__ return GeneratorStrategy(st.from_type(yields), st.from_type(returns))