Hypothesis tries to have good defaults for its behaviour, but sometimes that’s not enough and you need to tweak it.
@given invocation is as follows:
from hypothesis import given, settings @given(integers()) @settings(max_examples=500) def test_this_thoroughly(x): pass
This uses a
settings object which causes the test to receive a much larger
set of examples than normal.
This may be applied either before or after the given and the results are the same. The following is exactly equivalent:
from hypothesis import given, settings @settings(max_examples=500) @given(integers()) def test_this_thoroughly(x): pass
A settings object controls a variety of parameters that are used in falsification. These may control both the falsification strategy and the details of the data that is generated.
Default values are picked up from the settings.default object and changes made there will be picked up in newly created settings.
An instance of hypothesis.database.ExampleDatabase that will be used to save examples to and load previous examples from. May be None in which case no storage will be used.
default value: (dynamically calculated)
An ExampleDatabase instance to use for storage of examples. May be None.
If this was explicitly set at settings instantiation then that value will be used (even if it was None). If not and the database_file setting is not None this will be lazily loaded as an ExampleDatabase, using that file the first time that this property is accessed on a particular thread.
The size of the underlying data used to generate examples. If you need to generate really large examples you may want to increase this, but it will make your tests slower.
default value: 8192
If set, a time in milliseconds (which may be a float to express smaller units of time) that each individual example (i.e. each time your test function is called, not the whole decorated test) within a test is not allowed to exceed. Tests which take longer than that may be converted into errors (but will not necessarily be if close to the deadline, to allow some variability in test run time).
Set this to None to disable this behaviour entirely.
In future this will default to 200. For now, a HypothesisDeprecationWarning will be emitted if you exceed that default deadline and have not explicitly set a deadline yourself.
default value: not_set
If this is True then hypothesis will run in deterministic mode where each falsification uses a random number generator that is seeded based on the hypothesis to falsify, which will be consistent across multiple runs. This has the advantage that it will eliminate any randomness from your tests, which may be preferable for some situations. It does have the disadvantage of making your tests less likely to find novel breakages.
default value: False
Once this many satisfying examples have been considered without finding any counter-example, falsification will terminate.
default value: 100
Once this many iterations of the example loop have run, including ones which failed to satisfy assumptions and ones which produced duplicates, falsification will terminate.
default value: 1000
Once this many successful shrinks have been performed, Hypothesis will assume something has gone a bit wrong and give up rather than continuing to try to shrink the example.
default value: 500
Raise Unsatisfiable for any tests which do not produce at least this many values that pass all assume() calls and which have not exhaustively covered the search space.
default value: 5
If set to True, Hypothesis will run a preliminary health check before attempting to actually execute your test.
default value: True
Control which phases should be run. See the full documentation for more details
default value: (<Phase.explicit: 0>, <Phase.reuse: 1>, <Phase.generate: 2>, <Phase.shrink: 3>)
Number of steps to run a stateful program for before giving up on it breaking.
default value: 50
If set to True, anything that would cause Hypothesis to issue a warning will instead raise an error. Note that new warnings may be added at any time, so running with strict set to True means that new Hypothesis releases may validly break your code. Note also that, as strict mode is itself deprecated, enabling it is now an error!
You can enable this setting temporarily by setting the HYPOTHESIS_STRICT_MODE environment variable to the string ‘true’.
default value: False
Strict mode is deprecated and will go away in a future version of Hypothesis. To get the same behaviour, use warnings.simplefilter(‘error’, HypothesisDeprecationWarning).
A list of health checks to disable.
default value: ()
Once this many seconds have passed, falsify will terminate even if it has not found many examples. This is a soft rather than a hard limit - Hypothesis won’t e.g. interrupt execution of the called function to stop it. If this value is <= 0 then no timeout will be applied.
default value: 60
The timeout setting is deprecated and will be removed in a future version of Hypothesis. To get the future behaviour set
timeout=hypothesis.unlimitedinstead (which will remain valid for a further deprecation period after this setting has gone away).
Whether to use coverage information to improve Hypothesis’s ability to find bugs.
You should generally leave this turned on unless your code performs poorly when run under coverage. If you turn it off, please file a bug report or add a comment to an existing one about the problem that prompted you to do so.
default value: True
Controlling What Runs¶
Hypothesis divides tests into four logically distinct phases:
- Running explicit examples provided with the @example decorator.
- Rerunning a selection of previously failing examples to reproduce a previously seen error
- Generating new examples.
- Attempting to shrink an example found in phases 2 or 3 to a more manageable one (explicit examples cannot be shrunk).
The phases setting provides you with fine grained control over which of these run,
with each phase corresponding to a value on the
Phase.explicitcontrols whether explicit examples are run.
Phase.reusecontrols whether previous examples will be reused.
Phase.generatecontrols whether new examples will be generated.
Phase.shrinkcontrols whether examples will be shrunk.
The phases argument accepts a collection with any subset of these. e.g.
settings(phases=[Phase.generate, Phase.shrink]) will generate new examples
and shrink them, but will not run explicit examples or reuse previous failures,
settings(phases=[Phase.explicit]) will only run the explicit
Seeing intermediate result¶
To see what’s going on while Hypothesis runs your tests, you can turn
up the verbosity setting. This works with both
>>> from hypothesis import find, settings, Verbosity >>> from hypothesis.strategies import lists, booleans >>> find(lists(integers()), any, settings=settings(verbosity=Verbosity.verbose)) Trying example  Found satisfying example [-1198601713, -67, 116, -29578] Shrunk example to [113, -29578] Shrunk example to [-18163] Shrunk example to [-18163] Shrunk example to [-18163] Shrunk example to [-18163] Shrunk example to [-18163] Shrunk example to [-70] Shrunk example to  Shrunk example to  
The four levels are quiet, normal, verbose and debug. normal is the default, while in quiet Hypothesis will not print anything out, even the final falsifying example. debug is basically verbose but a bit more so. You probably don’t want it.
You can also override the default by setting the environment variable
HYPOTHESIS_VERBOSITY_LEVEL to the name of the level you want. So e.g.
HYPOTHESIS_VERBOSITY_LEVEL=verbose will run all your tests printing
intermediate results and errors.
If you are using
pytest, you may also need to
disable output capturing for passing tests.
Building settings objects¶
Settings can be created by calling
settings with any of the available settings
values. Any absent ones will be set to defaults:
>>> from hypothesis import settings >>> settings().max_examples 100 >>> settings(max_examples=10).max_examples 10
You can also copy settings from other settings:
>>> s = settings(max_examples=10) >>> t = settings(s, max_iterations=20) >>> s.max_examples 10 >>> t.max_iterations 20 >>> s.max_iterations 1000 >>> s.max_shrinks 500 >>> t.max_shrinks 500
At any given point in your program there is a current default settings,
settings.default. As well as being a settings object in its own
right, all newly created settings objects which are not explicitly based off
another settings are based off the default, so will inherit any values that are
not explicitly set from it.
You can change the defaults by using profiles (see next section), but you can also override them locally by using a settings object as a context manager
>>> with settings(max_examples=150): ... print(settings.default.max_examples) ... print(settings().max_examples) 150 150 >>> settings().max_examples 100
Note that after the block exits the default is returned to normal.
You can use this by nesting test definitions inside the context:
from hypothesis import given, settings with settings(max_examples=500): @given(integers()) def test_this_thoroughly(x): pass
All settings objects created or tests defined inside the block will inherit their defaults from the settings object used as the context. You can still override them with custom defined settings of course.
Warning: If you use define test functions which don’t use
inside a context block, these will not use the enclosing settings. This is because the context
manager only affects the definition, not the execution of the function.
Depending on your environment you may want different default settings. For example: during development you may want to lower the number of examples to speed up the tests. However, in a CI environment you may want more examples so you are more likely to find bugs.
Hypothesis allows you to define different settings profiles. These profiles can be loaded at any time.
Loading a profile changes the default settings but will not change the behavior of tests that explicitly change the settings.
>>> from hypothesis import settings >>> settings.register_profile("ci", settings(max_examples=1000)) >>> settings().max_examples 100 >>> settings.load_profile("ci") >>> settings().max_examples 1000
Instead of loading the profile and overriding the defaults you can retrieve profiles for specific tests.
>>> with settings.get_profile("ci"): ... print(settings().max_examples) ... 1000
Optionally, you may define the environment variable to load a profile for you. This is the suggested pattern for running your tests on CI. The code below should run in a conftest.py or any setup/initialization section of your test suite. If this variable is not defined the Hypothesis defined defaults will be loaded.
>>> import os >>> from hypothesis import settings, Verbosity >>> settings.register_profile("ci", settings(max_examples=1000)) >>> settings.register_profile("dev", settings(max_examples=10)) >>> settings.register_profile("debug", settings(max_examples=10, verbosity=Verbosity.verbose)) >>> settings.load_profile(os.getenv(u'HYPOTHESIS_PROFILE', 'default'))
If you are using the hypothesis pytest plugin and your profiles are registered
by your conftest you can load one with the command line option
$ py.test tests --hypothesis-profile <profile-name>
The timeout functionality of Hypothesis is being deprecated, and will eventually be removed. For the moment, the timeout setting can still be set and the old default timeout of one minute remains.
If you want to future proof your code you can get the future behaviour by setting it to the value unlimited, which you can import from the main Hypothesis package:
from hypothesis import given, settings, unlimited from hypothesis import strategies as st @settings(timeout=unlimited) @given(st.integers()) def test_something_slow(i): ...
This will cause your code to run until it hits the normal Hypothesis example limits, regardless of how long it takes. timeout=unlimited will remain a valid setting after the timeout functionality has been deprecated (but will then have its own deprecation cycle).
There is however now a timing related health check which is designed to catch tests that run for ages by accident. If you really want your test to run forever, the following code will enable that:
from hypothesis import given, settings, unlimited, HealthCheck from hypothesis import strategies as st @settings(timeout=unlimited, suppress_health_check=[ HealthCheck.hung_test ]) @given(st.integers()) def test_something_slow(i): ...