def process_arguments_to_given(wrapped_test, arguments, kwargs,
generator_arguments, generator_kwargs, argspec,
test, settings):
selfy = None
arguments, kwargs = convert_positional_arguments(wrapped_test, arguments,
kwargs)
# If the test function is a method of some kind, the bound object
# will be the first named argument if there are any, otherwise the
# first vararg (if any).
if argspec.args:
selfy = kwargs.get(argspec.args[0])
elif arguments:
selfy = arguments[0]
# Ensure that we don't mistake mocks for self here.
# This can cause the mock to be used as the test runner.
if is_mock(selfy):
selfy = None
test_runner = new_style_executor(selfy)
arguments = tuple(arguments)
search_strategy = st.tuples(
st.just(arguments),
st.fixed_dictionaries(generator_kwargs).map(
lambda args: dict(args, **kwargs)))
if selfy is not None:
search_strategy = WithRunner(search_strategy, selfy)
search_strategy.validate()
return arguments, kwargs, test_runner, search_strategy
def test_is_mock_with_negative_cases():
assert not is_mock(None)
assert not is_mock(1234)
assert not is_mock(is_mock)
assert not is_mock(BittySnowman())
assert not is_mock("foobar")
assert not is_mock(Mock(spec=BittySnowman))
assert not is_mock(MagicMock(spec=BittySnowman))
def test_is_mock_with_negative_cases():
assert not is_mock(None)
assert not is_mock(1234)
assert not is_mock(is_mock)
assert not is_mock(BittySnowman())
assert not is_mock('foobar')
assert not is_mock(Mock(spec=BittySnowman))
assert not is_mock(MagicMock(spec=BittySnowman))
def process_arguments_to_given(
wrapped_test,
arguments,
kwargs,
generator_arguments,
generator_kwargs,
argspec,
test,
settings,
):
selfy = None
arguments, kwargs = convert_positional_arguments(wrapped_test, arguments, kwargs)
# If the test function is a method of some kind, the bound object
# will be the first named argument if there are any, otherwise the
# first vararg (if any).
if argspec.args:
selfy = kwargs.get(argspec.args[0])
elif arguments:
selfy = arguments[0]
# Ensure that we don't mistake mocks for self here.
# This can cause the mock to be used as the test runner.
if is_mock(selfy):
selfy = None
test_runner = new_style_executor(selfy)
arguments = tuple(arguments)
# We use TupleStrategy over tuples() here to avoid polluting
# st.STRATEGY_CACHE with references (see #493), and because this is
# trivial anyway if the fixed_dictionaries strategy is cacheable.
search_strategy = TupleStrategy(
(
st.just(arguments),
st.fixed_dictionaries(generator_kwargs).map(
lambda args: dict(args, **kwargs)
),
)
)
if selfy is not None:
search_strategy = WithRunner(search_strategy, selfy)
search_strategy.validate()
return arguments, kwargs, test_runner, search_strategy
def process_arguments_to_given(
wrapped_test,
arguments,
kwargs,
generator_arguments,
generator_kwargs,
argspec,
test,
settings,
):
selfy = None
arguments, kwargs = convert_positional_arguments(wrapped_test, arguments, kwargs)
# If the test function is a method of some kind, the bound object
# will be the first named argument if there are any, otherwise the
# first vararg (if any).
if argspec.args:
selfy = kwargs.get(argspec.args[0])
elif arguments:
selfy = arguments[0]
# Ensure that we don't mistake mocks for self here.
# This can cause the mock to be used as the test runner.
if is_mock(selfy):
selfy = None
test_runner = new_style_executor(selfy)
arguments = tuple(arguments)
# We use TupleStrategy over tuples() here to avoid polluting
# st.STRATEGY_CACHE with references (see #493), and because this is
# trivial anyway if the fixed_dictionaries strategy is cacheable.
search_strategy = TupleStrategy(
(
st.just(arguments),
st.fixed_dictionaries(generator_kwargs).map(
lambda args: dict(args, **kwargs)
),
)
)
if selfy is not None:
search_strategy = WithRunner(search_strategy, selfy)
search_strategy.validate()
return arguments, kwargs, test_runner, search_strategy
def process_arguments_to_given(
wrapped_test, arguments, kwargs, generator_arguments, generator_kwargs,
argspec, test, settings
):
selfy = None
arguments, kwargs = convert_positional_arguments(
wrapped_test, arguments, kwargs)
# If the test function is a method of some kind, the bound object
# will be the first named argument if there are any, otherwise the
# first vararg (if any).
if argspec.args:
selfy = kwargs.get(argspec.args[0])
elif arguments:
selfy = arguments[0]
# Ensure that we don't mistake mocks for self here.
# This can cause the mock to be used as the test runner.
if is_mock(selfy):
selfy = None
test_runner = new_style_executor(selfy)
arguments = tuple(arguments)
search_strategy = st.tuples(
st.just(arguments),
st.fixed_dictionaries(generator_kwargs).map(
lambda args: dict(args, **kwargs)
)
)
if selfy is not None:
search_strategy = WithRunner(search_strategy, selfy)
search_strategy.validate()
return arguments, kwargs, test_runner, search_strategy
def magic(
*modules_or_functions: Union[Callable, types.ModuleType],
except_: Except = (),
style: str = "pytest",
) -> str:
"""Guess which ghostwriters to use, for a module or collection of functions.
As for all ghostwriters, the ``except_`` argument should be an
:class:`python:Exception` or tuple of exceptions, and ``style`` may be either
``"pytest"`` to write test functions or ``"unittest"`` to write test methods
and :class:`~python:unittest.TestCase`.
After finding the public functions attached to any modules, the ``magic``
ghostwriter looks for pairs of functions to pass to :func:`~roundtrip`,
then checks for :func:`~binary_operation` and :func:`~ufunc` functions,
and any others are passed to :func:`~fuzz`.
For example, try :command:`hypothesis write gzip` on the command line!
"""
except_ = _check_except(except_)
_check_style(style)
if not modules_or_functions:
raise InvalidArgument(
"Must pass at least one function or module to test.")
functions = set()
for thing in modules_or_functions:
if callable(thing):
functions.add(thing)
elif isinstance(thing, types.ModuleType):
if hasattr(thing, "__all__"):
funcs = [getattr(thing, name, None)
for name in thing.__all__] # type: ignore
else:
funcs = [
v for k, v in vars(thing).items()
if callable(v) and not k.startswith("_")
]
for f in funcs:
try:
if (not is_mock(f)) and callable(f) and _get_params(f):
functions.add(f)
except (TypeError, ValueError):
pass
else:
raise InvalidArgument(
f"Can't test non-module non-callable {thing!r}")
imports = set()
parts = []
by_name = {}
for f in functions:
try:
by_name[_get_qualname(f, include_module=True)] = f
except Exception:
pass # e.g. Pandas 'CallableDynamicDoc' object has no attribute '__name__'
if not by_name:
return (f"# Found no testable functions in\n"
f"# {functions!r} from {modules_or_functions}\n")
# Look for pairs of functions that roundtrip, based on known naming patterns.
for writename, readname in ROUNDTRIP_PAIRS:
for name in sorted(by_name):
match = re.fullmatch(writename, name.split(".")[-1])
if match:
inverse_name = readname.format(*match.groups())
for other in sorted(n for n in by_name
if n.split(".")[-1] == inverse_name)[:1]:
imp, body = _make_roundtrip_body(
(by_name.pop(name), by_name.pop(other)),
except_=except_,
style=style,
)
imports |= imp
parts.append(body)
# Look for equivalent functions: same name, all required arguments of any can
# be found in all signatures, and if all have return-type annotations they match.
names = defaultdict(list)
for _, f in sorted(by_name.items()):
names[_get_qualname(f)].append(f)
for group in names.values():
if len(group) >= 2 and len({frozenset(_get_params(f))
for f in group}) == 1:
sentinel = object()
returns = {
get_type_hints(f).get("return", sentinel)
for f in group
}
if len(returns - {sentinel}) <= 1:
imp, body = _make_equiv_body(group,
except_=except_,
style=style)
imports |= imp
parts.append(body)
for f in group:
by_name.pop(_get_qualname(f, include_module=True))
# Look for binary operators - functions with two identically-typed arguments,
# and the same return type. The latter restriction might be lifted later.
for name, func in sorted(by_name.items()):
hints = get_type_hints(func)
hints.pop("return", None)
if len(hints) == len(_get_params(func)) == 2:
a, b = hints.values()
if a == b:
imp, body = _make_binop_body(func,
except_=except_,
style=style)
imports |= imp
parts.append(body)
del by_name[name]
# Look for Numpy ufuncs or gufuncs, and write array-oriented tests for them.
if "numpy" in sys.modules:
for name, func in sorted(by_name.items()):
if _is_probably_ufunc(func):
imp, body = _make_ufunc_body(func,
except_=except_,
style=style)
imports |= imp
parts.append(body)
del by_name[name]
# For all remaining callables, just write a fuzz-test. In principle we could
# guess at equivalence or idempotence; but it doesn't seem accurate enough to
# be worth the trouble when it's so easy for the user to specify themselves.
for _, f in sorted(by_name.items()):
imp, body = _make_test_body(f,
test_body=_write_call(f),
except_=except_,
ghost="fuzz",
style=style)
imports |= imp
parts.append(body)
return _make_test(imports, "\n".join(parts))
def test_is_mock_with_positive_cases():
assert is_mock(Mock())
assert is_mock(MagicMock())
assert is_mock(NonCallableMock())
assert is_mock(NonCallableMagicMock())
def test_is_mock_with_positive_cases():
assert is_mock(Mock())
assert is_mock(MagicMock())
assert is_mock(NonCallableMock())
assert is_mock(NonCallableMagicMock())
