Reference for Hypothesis features with a defined interface, but no code API.
.. automodule:: hypothesis.extra.ghostwriter :members:
Ghostwritten tests are intended as a starting point for human authorship,
to demonstrate best practice, help novices past blank-page paralysis, and save time
for experts. They may be ready-to-run, or include placeholders and # TODO:
comments to fill in strategies for unknown types. In either case, improving tests
for their own code gives users a well-scoped and immediately rewarding context in
which to explore property-based testing.
By contrast, most test-generation tools aim to produce ready-to-run test suites... and implicitly assume that the current behavior is the desired behavior. However, the code might contain bugs, and we want our tests to fail if it does! Worse, tools require that the code to be tested is finished and executable, making it impossible to generate tests as part of the development process.
Fraser 2013 found that evolving a high-coverage test suite (e.g. Randoop, EvoSuite, Pynguin) "leads to clear improvements in commonly applied quality metrics such as code coverage [but] no measurable improvement in the number of bugs actually found by developers" and that "generating a set of test cases, even high coverage test cases, does not necessarily improve our ability to test software". Invariant detection (famously Daikon; in PBT see e.g. Alonso 2022, QuickSpec, Speculate) relies on code execution. Program slicing (e.g. FUDGE, FuzzGen, WINNIE) requires downstream consumers of the code to test.
Ghostwriter inspects the function name, argument names and types, and docstrings. It can be used on buggy or incomplete code, runs in a few seconds, and produces a single semantically-meaningful test per function or group of functions. Rather than detecting regressions, these tests check semantic properties such as encode/decode or save/load round-trips, for commutative, associative, and distributive operations, equivalence between methods, array shapes, and idempotence. Where no property is detected, we simply check for 'no error on valid input' and allow the user to supply their own invariants.
Evaluations such as the SBFT24 competition measure performance on a task which the Ghostwriter is not intended to perform. I'd love to see qualitative user studies, such as PBT in Practice for test generation, which could check whether the Ghostwriter is onto something or tilting at windmills. If you're interested in similar questions, drop me an email!
Tip
The Tyche VSCode extension provides an in-editor UI for observability results generated by Hypothesis. If you want to view observability results, rather than programmatically consume or display them, we recommend using Tyche.
Understanding what your code is doing - for example, why your test failed - is often
a frustrating exercise in adding some more instrumentation or logging (or print() calls)
and running it again. The idea of :wikipedia:`observability <Observability_(software)>`
is to let you answer questions you didn't think of in advance. In slogan form,
Debugging should be a data analysis problem.
By default, Hypothesis only reports the minimal failing example... but sometimes you might want to know something about all the examples. Printing them to the terminal by increasing |Verbosity| might be nice, but isn't always enough. This feature gives you an analysis-ready dataframe with useful columns and one row per test case, with columns from arguments to code coverage to pass/fail status.
This is deliberately a much lighter-weight and task-specific system than e.g. OpenTelemetry. It's also less detailed than time-travel debuggers such as rr or pytrace, because there's no good way to compare multiple traces from these tools and their Python support is relatively immature.
The standard way to configure observability is with |settings.observability|.
Alternatively, observability can be configured by setting the HYPOTHESIS_OBSERVABILITY environment variable. If HYPOTHESIS_OBSERVABILITY is set to one of True, true, or 1, |settings.observability| defaults to True. Note that unlike |settings.observability|, HYPOTHESIS_OBSERVABILITY only configures whether observability is enabled or disabled, not additional options like |ObservabilityConfig|.
When observability is enabled, and callbacks in |ObservabilityConfig| has not been configured to remove the default callback, Hypothesis will log various observations to jsonlines files in the
.hypothesis/observed/ directory. You can load and explore these with e.g.
:func:`pd.read_json(".hypothesis/observed/*_testcases.jsonl", lines=True) <pandas.read_json>`,
or by using the :pypi:`sqlite-utils` and :pypi:`datasette` libraries:
sqlite-utils insert testcases.db testcases .hypothesis/observed/*_testcases.jsonl --nl --flatten datasette serve testcases.db
If you want to record more information about your test cases than the arguments and
outcome - for example, was x a binary tree? what was the difference between the
expected and the actual value? how many queries did it take to find a solution? -
Hypothesis makes this easy.
:func:`~hypothesis.event` accepts a string label, and optionally a string or int or float observation associated with it. All events are collected and summarized in :ref:`statistics`, as well as included on a per-test-case basis in our observations.
:func:`~hypothesis.target` is a special case of numeric-valued events: as well as recording them in observations, Hypothesis will try to maximize the targeted value. Knowing that, you can use this to guide the search for failing inputs.
We dump observations in json lines format, with each line describing either a test case or an information message. The tables below are derived from :download:`this machine-readable JSON schema <schema_observations.json>`, to provide both readable and verifiable specifications.
Note that we use :func:`python:json.dumps` and can therefore emit non-standard JSON
which includes infinities and NaN. This is valid in JSON5,
and supported by some JSON parsers
including Gson in Java, JSON.parse() in Ruby, and of course in Python.
.. jsonschema:: ./schema_observations.json#/oneOf/1 :hide_key: /additionalProperties, /type
.. jsonschema:: ./schema_observations.json#/oneOf/0 :hide_key: /additionalProperties, /type
While the observability format is agnostic to the property-based testing library which generated it, Hypothesis includes specific values in the metadata key for test cases. You may rely on these being present if and only if the observation was generated by Hypothesis.
.. jsonschema:: ./schema_metadata.json :hide_key: /additionalProperties, /type
These additional metadata elements are included in metadata (as e.g. metadata["choice_nodes"] or metadata["choice_spans"]), if and only if observability is configured to include choices (see |ObservabilityConfig|).
.. jsonschema:: ./schema_metadata_choices.json :hide_key: /additionalProperties, /type
Hypothesis includes a tiny plugin to improve integration with :pypi:`pytest`, which is activated by default (but does not affect other test runners). It aims to improve the integration between Hypothesis and Pytest by providing extra information and convenient access to config options.
pytest --hypothesis-show-statisticscan be used to :ref:`display test and data generation statistics <statistics>`.pytest --hypothesis-profile=<profile name>can be used to load a settings profile (as in |settings.load_profile|).pytest --hypothesis-verbosity=<level name>can be used to override the current |Verbosity| setting.pytest --hypothesis-seed=<an int>can be used to reproduce a failure with a particular seed (as in |@seed|).pytest --hypothesis-explaincan be used to temporarily enable |Phase.explain|.
Finally, all tests that are defined with Hypothesis automatically have @pytest.mark.hypothesis applied to them. See :ref:`here for information on working with markers <pytest:mark examples>`.
Note
Pytest will load the plugin automatically if Hypothesis is installed. You don't need to do anything at all to use it.
If this causes problems, you can avoid loading the plugin with the -p no:hypothesispytest option.
Note
While test statistics are only available under pytest, you can use the :ref:`observability <observability>` interface to view similar information about your tests.
You can see a number of statistics about executed tests by passing the command line argument --hypothesis-show-statistics. This will include some general statistics about the test:
For example if you ran the following with --hypothesis-show-statistics:
from hypothesis import given, strategies as st
@given(st.integers())
def test_integers(i):
passYou would see:
- during generate phase (0.06 seconds):
- Typical runtimes: < 1ms, ~ 47% in data generation
- 100 passing examples, 0 failing examples, 0 invalid examples
- Stopped because settings.max_examples=100
The final "Stopped because" line tells you why Hypothesis stopped generating new examples. This is typically because we hit |max_examples|, but occasionally because we exhausted the search space or because shrinking was taking a very long time. This can be useful for understanding the behaviour of your tests.
In some cases (such as filtered and recursive strategies) you will see events mentioned which describe some aspect of the data generation:
from hypothesis import given, strategies as st
@given(st.integers().filter(lambda x: x % 2 == 0))
def test_even_integers(i):
passYou would see something like:
test_even_integers:
- during generate phase (0.08 seconds):
- Typical runtimes: < 1ms, ~ 57% in data generation
- 100 passing examples, 0 failing examples, 12 invalid examples
- Events:
* 51.79%, Retried draw from integers().filter(lambda x: x % 2 == 0) to satisfy filter
* 10.71%, Aborted test because unable to satisfy integers().filter(lambda x: x % 2 == 0)
- Stopped because settings.max_examples=100
Note
This feature requires the hypothesis[cli] :doc:`extra </extras>`, via pip install hypothesis[cli].
.. automodule:: hypothesis.extra.cli
Note
This feature requires the hypothesis[codemods] :doc:`extra </extras>`, via pip install hypothesis[codemods].
.. automodule:: hypothesis.extra.codemods
Note
This feature requires the hypothesis[dpcontracts] :doc:`extra </extras>`, via pip install hypothesis[dpcontracts].
Tip
For new projects, we recommend using either :pypi:`deal` or :pypi:`icontract` and :pypi:`icontract-hypothesis` over :pypi:`dpcontracts`. They're generally more powerful tools for design-by-contract programming, and have substantially nicer Hypothesis integration too!
.. automodule:: hypothesis.extra.dpcontracts :members: