def test_does_print_on_reuse_from_database(): passes_healthcheck = False database = InMemoryExampleDatabase() @settings(database=database) @given(st.integers()) def test(i): assume(passes_healthcheck) raise ValueError() with capture_out() as o: with pytest.raises(FailedHealthCheck): test() assert '@seed' in o.getvalue() passes_healthcheck = True with capture_out() as o: with pytest.raises(ValueError): test() assert all_values(database) assert '@seed' not in o.getvalue() passes_healthcheck = False with capture_out() as o: with pytest.raises(FailedHealthCheck): test() assert '@seed' in o.getvalue()
def test_stability(): @given( st.lists(st.text(min_size=1, max_size=1), unique=True, min_size=5), st.choices(), ) @settings( database=ExampleDatabase(), ) def test_choose_and_then_fail(ls, choice): for _ in hrange(100): choice(ls) assert False # Run once first for easier debugging with raises(AssertionError): test_choose_and_then_fail() with capture_out() as o: with raises(AssertionError): test_choose_and_then_fail() out1 = o.getvalue() with capture_out() as o: with raises(AssertionError): test_choose_and_then_fail() out2 = o.getvalue() assert out1 == out2 assert 'Choice #100:' in out1
def test_can_manually_call_initialize_rule(): class StateMachine(RuleBasedStateMachine): initialize_called_counter = 0 @initialize() def initialize(self): self.initialize_called_counter += 1 return self.initialize_called_counter @rule() def fail_eventually(self): assert self.initialize() <= 2 StateMachine.TestCase.settings = NO_BLOB_SETTINGS with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(StateMachine) result = o.getvalue() assert ( result == """\ Falsifying example: run_state_machine(factory=StateMachine, data=data(...)) state = StateMachine() state.initialize() state.fail_eventually() state.fail_eventually() state.teardown() """ )
def test_prints_debug_on_no_simplification(): with Settings(verbosity=Verbosity.debug): with capture_out() as o: find(just(u"hi"), bool) v = o.getvalue() print(v) assert u"No simplifiers" in v
def test_prints_seed_on_exception(monkeypatch, in_pytest, fail_healthcheck): monkeypatch.setattr(core, 'running_under_pytest', in_pytest) strategy = st.integers() if fail_healthcheck: def slow_map(i): time.sleep(10) return i strategy = strategy.map(slow_map) expected_exc = FailedHealthCheck else: expected_exc = AssertionError @given(strategy) def test(i): assert False with capture_out() as o: with pytest.raises(expected_exc): test() output = o.getvalue() seed = test._hypothesis_internal_use_generated_seed assert seed is not None assert '@seed(%d)' % (seed,) in output contains_pytest_instruction = ('--hypothesis-seed=%d' % (seed,)) in output assert contains_pytest_instruction == in_pytest
def test_prints_equal_values_with_correct_variable_name(): class MovesBetweenBundles(RuleBasedStateMachine): b1 = Bundle("b1") b2 = Bundle("b2") @rule(target=b1) def create(self): return [] @rule(target=b2, source=b1) def transfer(self, source): return source @rule(source=b2) def fail(self, source): assert False with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(MovesBetweenBundles) result = o.getvalue() for m in ["create", "transfer", "fail"]: assert result.count("state." + m) == 1 assert "v1 = state.create()" in result assert "v2 = state.transfer(source=v1)" in result assert "state.fail(source=v2)" in result
def test_prints_equal_values_with_correct_variable_name(): class MovesBetweenBundles(RuleBasedStateMachine): b1 = Bundle('b1') b2 = Bundle('b2') @rule(target=b1) def create(self): return [] @rule(target=b2, source=b1) def transfer(self, source): return source @rule(source=b2) def fail(self, source): assert False with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(MovesBetweenBundles) result = o.getvalue() for m in ['create', 'transfer', 'fail']: assert result.count(m) == 1 assert 'v1 = state.create()' in result assert 'v2 = state.transfer(source=v1)' in result assert 'state.fail(source=v2)' in result
def test_initialize_rule_in_state_machine_with_inheritance(): class ParentStateMachine(RuleBasedStateMachine): initialized = [] @initialize() def initialize_a(self): self.initialized.append('a') class ChildStateMachine(ParentStateMachine): @initialize() def initialize_b(self): self.initialized.append('b') @rule() def fail_fast(self): assert False with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(ChildStateMachine) assert set(ChildStateMachine.initialized[-2:]) == {'a', 'b'} result = o.getvalue().splitlines() assert result[0] == 'state = ChildStateMachine()' # Initialize rules call order is shuffled assert {result[1], result[2]} == { 'state.initialize_a()', 'state.initialize_b()'} assert result[3] == 'state.fail_fast()' assert result[4] == 'state.teardown()'
def test_initialize_rule(): class WithInitializeRules(RuleBasedStateMachine): initialized = [] @initialize() def initialize_a(self): self.initialized.append('a') @initialize() def initialize_b(self): self.initialized.append('b') @initialize() def initialize_c(self): self.initialized.append('c') @rule() def fail_fast(self): assert False with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(WithInitializeRules) assert set(WithInitializeRules.initialized[-3:]) == {'a', 'b', 'c'} result = o.getvalue().splitlines() assert result[0] == 'state = WithInitializeRules()' # Initialize rules call order is shuffled assert {result[1], result[2], result[3]} == { 'state.initialize_a()', 'state.initialize_b()', 'state.initialize_c()' } assert result[4] == 'state.fail_fast()' assert result[5] == 'state.teardown()'
def test_shrinks_both_failures(): first_has_failed = [False] duds = set() second_target = [None] @given(st.integers()) def test(i): if i >= 10000: first_has_failed[0] = True assert False assert i < 10000 if first_has_failed[0]: if second_target[0] is None: for j in range(10000): if j not in duds: second_target[0] = j break assert i < second_target[0] else: duds.add(i) with capture_out() as o: with pytest.raises(MultipleFailures): test() assert 'test(i=10000)' in o.getvalue() assert 'test(i=%d)' % (second_target[0],) in o.getvalue()
def test_initialize_rule_populate_bundle(): class WithInitializeBundleRules(RuleBasedStateMachine): a = Bundle("a") @initialize(target=a, dep=just("dep")) def initialize_a(self, dep): return "a v1 with (%s)" % dep @rule(param=a) def fail_fast(self, param): assert False WithInitializeBundleRules.TestCase.settings = NO_BLOB_SETTINGS with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(WithInitializeBundleRules) result = o.getvalue() assert ( result == """\ Falsifying example: run_state_machine(\ factory=WithInitializeBundleRules, data=data(...)) state = WithInitializeBundleRules() v1 = state.initialize_a(dep='dep') state.fail_fast(param=v1) state.teardown() """ )
def test_multiple_rules_same_func(): test_class = MultipleRulesSameFuncMachine.TestCase with capture_out() as o: test_class().runTest() output = o.getvalue() assert 'rule1data' in output assert 'rule2data' in output
def test_does_not_print_notes_if_all_succeed(): @given(integers()) def test(i): note('Hi there') with capture_out() as out: with reporting.with_reporter(reporting.default): test() assert not out.getvalue()
def test_does_print_debug_in_debug(): @given(integers()) @settings(verbosity=Verbosity.debug) def f(x): debug_report("Hi") with capture_out() as o: f() assert u"Hi" in o.getvalue()
def test_does_not_print_reproduction_for_simple_examples_by_default(): @given(st.integers()) def test(i): assert False with capture_out() as o: with pytest.raises(AssertionError): test() assert '@reproduce_failure' not in o.getvalue()
def test_does_not_print_debug_in_verbose(): @given(integers()) @settings(verbosity=Verbosity.verbose) def f(x): debug_report('Hi') with capture_out() as o: f() assert u'Hi' not in o.getvalue()
def test_can_seed_random(): with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): @given(st.random_module()) def test(r): assert False test() assert 'random.seed(0)' in out.getvalue()
def test_does_print_verbose_in_debug(): @given(integers()) @settings(verbosity=Verbosity.debug) def f(x): verbose_report('Hi') with capture_out() as o: f() assert u'Hi' in o.getvalue()
def test_can_suppress_output(): @given(integers()) def test_int(x): assert False with capture_out() as o: with reporting.with_reporter(reporting.silent): with pytest.raises(AssertionError): test_int() assert u'Falsifying example' not in o.getvalue()
def test_suppresses_exceptions_in_teardown(): with capture_out() as o: with pytest.raises(AssertionError): with BuildContext(): def foo(): raise ValueError() cleanup(foo) assert False assert u'ValueError' in o.getvalue()
def test_does_print_reproduction_given_an_invalid_repr(): @given(st.integers().map(lambda x: Foo())) def test(i): raise ValueError() with capture_out() as o: with pytest.raises(ValueError): test() assert '@reproduce_failure' in o.getvalue()
def test_does_print_reproduction_for_simple_data_examples_by_default(): @given(st.data()) def test(data): data.draw(st.integers()) assert False with capture_out() as o: with pytest.raises(AssertionError): test() assert '@reproduce_failure' in o.getvalue()
def test_prints_output_by_default(): @given(integers()) def test_int(x): assert False with capture_out() as o: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): test_int() assert u'Falsifying example' in o.getvalue()
def test_does_not_print_on_success(): @given(int) def test_is_an_int(x): return True with capture_out() as out: test_is_an_int() out = out.getvalue() lines = [l.strip() for l in out.split('\n')] assert all(not l for l in lines)
def test_deadlines_participate_in_shrinking(): @settings(deadline=500) @given(st.integers()) def slow_if_large(i): if i >= 10000: time.sleep(1) with capture_out() as o: with pytest.raises(DeadlineExceeded): slow_if_large() assert 'slow_if_large(i=10000)' in o.getvalue()
def test_does_not_print_reproduction_if_told_not_to(): @settings(print_blob=PrintSettings.NEVER) @given(st.integers().map(lambda x: Foo())) def test(i): raise ValueError() with capture_out() as o: with pytest.raises(ValueError): test() assert '@reproduce_failure' not in o.getvalue()
def test_does_not_print_on_success(): with Settings(verbosity=Verbosity.normal): @given(integers()) def test_is_an_int(x): return True with capture_out() as out: test_is_an_int() out = out.getvalue() lines = [l.strip() for l in out.split(u'\n')] assert all(not l for l in lines), lines
def test_does_not_print_reproduction_if_verbosity_set_to_quiet(): @given(st.data()) @settings(verbosity=Verbosity.quiet) def test_always_fails(data): assert data.draw(st.just(False)) with capture_out() as out: with pytest.raises(AssertionError): test_always_fails() assert '@reproduce_failure' not in out.getvalue()
def test_prints_output_for_explicit_examples(): @example(-1) @given(integers()) def test_positive(x): assert x > 0 with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): with capture_out() as out: test_positive() out = out.getvalue() assert u'Falsifying example: test_positive(x=-1)' in out
def test_does_not_print_on_explicit_examples_if_no_failure(): @example(1) @given(integers()) def test_positive(x): assert x > 0 with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): with capture_out() as out: test_positive() out = out.getvalue() assert u'Falsifying example: test_positive(1)' not in out
def test_prints_on_failure_by_default(): @given(integers(), integers()) @settings(max_examples=100) def test_ints_are_sorted(balthazar, evans): assume(evans >= 0) assert balthazar <= evans with raises(AssertionError): with capture_out() as out: with reporting.with_reporter(reporting.default): test_ints_are_sorted() out = out.getvalue() lines = [l.strip() for l in out.split("\n")] assert "Falsifying example: test_ints_are_sorted(balthazar=1, evans=0)" in lines
def test_invariant_present_in_falsifying_example(): @Settings(print_blob=False) class BadRuleWithGoodInvariants(RuleBasedStateMachine): def __init__(self): super().__init__() self.num = 0 @initialize() def initialize_1(self): pass @invariant(check_during_init=True) def invariant_1(self): pass @invariant(check_during_init=False) def invariant_2(self): pass @precondition(lambda self: self.num > 0) @invariant() def invariant_3(self): pass @rule() def rule_1(self): self.num += 1 if self.num == 2: raise ValueError() with capture_out() as o: with pytest.raises(ValueError): run_state_machine_as_test(BadRuleWithGoodInvariants) result = o.getvalue() assert (result == """\ Falsifying example: state = BadRuleWithGoodInvariants() state.invariant_1() state.initialize_1() state.invariant_1() state.invariant_2() state.rule_1() state.invariant_1() state.invariant_2() state.invariant_3() state.rule_1() state.teardown() """)
def test_removes_needless_steps(): """Regression test from an example based on tests/nocover/test_database_agreement.py, but without the expensive bits. Comparing two database implementations in which deletion is broken, so as soon as a key/value pair is successfully deleted the test will now fail if you ever check that key. The main interesting feature of this is that it has a lot of opportunities to generate keys and values before it actually fails, but will still fail with very high probability. """ @Settings(derandomize=True, max_examples=1000, deadline=None) class IncorrectDeletion(RuleBasedStateMachine): def __init__(self): super().__init__() self.__saved = defaultdict(set) self.__deleted = defaultdict(set) keys = Bundle("keys") values = Bundle("values") @rule(target=keys, k=binary()) def k(self, k): return k @rule(target=values, v=binary()) def v(self, v): return v @rule(k=keys, v=values) def save(self, k, v): self.__saved[k].add(v) @rule(k=keys, v=values) def delete(self, k, v): if v in self.__saved[k]: self.__deleted[k].add(v) @rule(k=keys) def values_agree(self, k): assert not self.__deleted[k] with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(IncorrectDeletion) assert o.getvalue().count(" = state.k(") == 1 assert o.getvalue().count(" = state.v(") == 1
def test_error_in_strategy_produces_only_one_traceback(): def boom(x): raise ValueError() with Settings(strict=False): @given(st.integers().map(boom)) def test(x): pass with raises(ValueError): with reporting.with_reporter(reporting.default): with capture_out() as out: test() assert out.getvalue().count('ValueError') == 2
def test_prints_notes_once_on_failure(): @given(lists(integers())) @settings(database=None, verbosity=Verbosity.normal) def test(xs): note('Hi there') if sum(xs) <= 100: raise ValueError() with capture_out() as out: with reporting.with_reporter(reporting.default): with raises(ValueError): test() lines = out.getvalue().strip().splitlines() assert len(lines) == 2 assert 'Hi there' in lines
def test_when_set_to_no_simplifies_only_runs_failing_example_once(): failing = [0] @given(integers(), settings=hs.Settings(max_shrinks=0)) def foo(x): if x > 11: failing[0] += 1 assert False with hs.Settings(verbosity=hs.Verbosity.normal): with pytest.raises(AssertionError): with capture_out() as out: foo() assert failing == [1] assert 'Trying example' in out.getvalue()
def test_gives_a_deadline_specific_flaky_error_message(): once = [True] @settings(deadline=100) @given(st.integers()) def slow_once(i): if once[0]: once[0] = False time.sleep(0.2) with capture_out() as o: with pytest.raises(Flaky): slow_once() assert "Unreliable test timing" in o.getvalue() assert "took 2" in o.getvalue()
def test_prints_note_in_failing_example(): @example(x=42) @example(x=43) @given(integers()) def test(x): note(f"x -> {x}") assert x == 42 with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): test() v = out.getvalue() print(v) assert "x -> 43" in v assert "x -> 42" not in v
def test_runs_multiple_cleanup_with_teardown(): with capture_out() as o: with pytest.raises(AssertionError): with BuildContext(): def foo(): raise ValueError() cleanup(foo) def bar(): raise TypeError() cleanup(foo) cleanup(bar) assert False assert u'ValueError' in o.getvalue() assert u'TypeError' in o.getvalue()
def test_prints_note_in_failing_example(): @example(x=42) @example(x=43) @given(integers()) def test(x): note('x -> %d' % (x, )) assert x == 42 with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): test() v = out.getvalue() print_unicode(v) assert 'x -> 43' in v assert 'x -> 42' not in v
def test_prints_on_failure(): @given(st.data()) def test(data): x = data.draw(st.lists(st.integers(0, 10), min_size=2)) y = data.draw(st.sampled_from(x)) x.remove(y) if y in x: raise ValueError() with raises(ValueError): with capture_out() as out: with reporting.with_reporter(reporting.default): test() result = out.getvalue() assert 'Draw 1: [0, 0]' in result assert 'Draw 2: 0' in result
def test_prints_labels_if_given_on_failure(): @given(st.data()) def test(data): x = data.draw(st.lists(st.integers(0, 10), min_size=2), label="Some numbers") y = data.draw(st.sampled_from(x), label="A number") assert y in x x.remove(y) assert y not in x with raises(AssertionError): with capture_out() as out: with reporting.with_reporter(reporting.default): test() result = out.getvalue() assert "Draw 1 (Some numbers): [0, 0]" in result assert "Draw 2 (A number): 0" in result
def test_inserts_line_breaks_only_at_appropriate_lengths(line_break, input): @example(input, input) @given(st.text(), st.text()) def test(x, y): assert x < y with capture_out() as cap: with pytest.raises(AssertionError): test() template = OUTPUT_WITH_LINE_BREAK if line_break else OUTPUT_NO_LINE_BREAK desired_output = template % {"input": repr(input)} actual_output = cap.getvalue() assert desired_output.strip() == actual_output.strip()
def test_when_set_to_no_simplifies_runs_failing_example_twice(): failing = [0] @given(integers()) @settings(phases=no_shrink, max_examples=100, verbosity=Verbosity.normal) def foo(x): if x > 11: note('Lo') failing[0] += 1 assert False with raises(AssertionError): with capture_out() as out: foo() assert failing == [2] assert 'Falsifying example' in out.getvalue() assert 'Lo' in out.getvalue()
def test_uses_global_force(monkeypatch): monkeypatch.setattr(core, "global_force_seed", 42) @given(st.integers()) def test(i): raise ValueError() output = [] for _ in range(2): with capture_out() as o: with pytest.raises(ValueError): test() output.append(o.getvalue()) assert output[0] == output[1] assert "@seed" not in output[0]
def test_no_falsifying_example_if_unittest_skip(skip_exception): """If a ``SkipTest`` exception is raised during a test, Hypothesis should not continue running the test and shrink process, nor should it print anything about falsifying examples.""" class DemoTest(unittest.TestCase): @given(xs=integers()) def test_to_be_skipped(self, xs): if xs == 0: raise skip_exception else: assert xs == 0 with capture_out() as o: suite = unittest.defaultTestLoader.loadTestsFromTestCase(DemoTest) unittest.TextTestRunner().run(suite) assert "Falsifying example" not in o.getvalue()
def test_raises_multiple_failures_with_varying_type(): target = [None] @given(st.integers()) def test(i): if abs(i) < 1000: return if target[0] is None: target[0] = i exc_class = TypeError if target[0] == i else ValueError raise exc_class() with capture_out() as o: with pytest.raises(MultipleFailures): test() assert 'TypeError' in o.getvalue() assert 'ValueError' in o.getvalue()
def test_initialize_rule_populate_bundle(): class WithInitializeBundleRules(RuleBasedStateMachine): a = Bundle('a') @initialize(target=a, dep=just('dep')) def initialize_a(self, dep): return 'a v1 with (%s)' % dep @rule(param=a) def fail_fast(self, param): assert False with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(WithInitializeBundleRules) result = o.getvalue() assert result == """state = WithInitializeBundleRules()
def test_raises_multiple_failures_when_position_varies(): target = [None] @given(st.integers()) def test(i): if abs(i) < 1000: return if target[0] is None: target[0] = i if target[0] == i: raise ValueError('loc 1') else: raise ValueError('loc 2') with capture_out() as o: with pytest.raises(MultipleFailures): test() assert 'loc 1' in o.getvalue() assert 'loc 2' in o.getvalue()
def test_prints_all_notes_in_verbose_mode(): # slightly roundabout because @example messes with verbosity - see #1521 messages = set() @settings(verbosity=Verbosity.debug, database=None) @given(integers(1, 10)) def test(x): msg = 'x -> %d' % (x, ) note(msg) messages.add(msg) assert x < 5 with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): test() v = out.getvalue() for x in sorted(messages): assert x in v
def test_can_manually_call_initialize_rule(): class StateMachine(RuleBasedStateMachine): initialize_called_counter = 0 @initialize() def initialize(self): self.initialize_called_counter += 1 return self.initialize_called_counter @rule() def fail_eventually(self): assert self.initialize() == 2 with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(StateMachine) result = o.getvalue() assert result == """state = StateMachine()
def test_arguments_do_not_use_names_of_return_values(): # See https://github.com/HypothesisWorks/hypothesis/issues/2341 class TrickyPrintingMachine(RuleBasedStateMachine): data = Bundle("data") @initialize(target=data, value=integers()) def init_data(self, value): return value @rule(d=data) def mostly_fails(self, d): assert d == 42 with capture_out() as o: with pytest.raises(AssertionError): run_state_machine_as_test(TrickyPrintingMachine) output = o.getvalue() assert "v1 = state.init_data(value=0)" in output assert "v1 = state.init_data(value=v1)" not in output
def test_raises_multiple_failures_when_position_varies(): target = [None] @settings(max_examples=100) @given(st.integers()) def test(i): if abs(i) < 1000: return if target[0] is None: target[0] = i if target[0] == i: raise ValueError("loc 1") else: raise ValueError("loc 2") with capture_out() as o: with pytest.raises(MultipleFailures): test() assert "loc 1" in o.getvalue() assert "loc 2" in o.getvalue()
def test_runs_multiple_cleanup_with_teardown(): with capture_out() as o: with pytest.raises(AssertionError): with bc(): def foo(): raise ValueError() cleanup(foo) def bar(): raise TypeError() cleanup(foo) cleanup(bar) raise AssertionError assert "ValueError" in o.getvalue() assert "TypeError" in o.getvalue() assert _current_build_context.value is None
def test_prints_all_notes_in_verbose_mode(): # slightly roundabout because @example messes with verbosity - see #1521 generated_integers = [] def notefmt(x): return 'x -> %d' % (x,) @settings(verbosity=Verbosity.debug) @given(integers(1, 10)) def test(x): generated_integers.append(x) note(notefmt(x)) assert x < 5 with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): test() v = out.getvalue() for x in generated_integers: assert notefmt(x) in v
def test_shrinks_both_failures(): first_has_failed = [False] duds = set() second_target = [None] @settings(database=None, max_examples=1000) @given(st.integers(min_value=0).map(int)) def test(i): if i >= 10000: first_has_failed[0] = True assert False assert i < 10000 if first_has_failed[0]: if second_target[0] is None: for j in range(10000): if j not in duds: second_target[0] = j break assert i < second_target[0] else: duds.add(i) with capture_out() as o: with pytest.raises(MultipleFailures): test() output = o.getvalue() assert_output_contains_failure( output, test, i=10000, ) assert_output_contains_failure( output, test, i=second_target[0], )
def test_raises_multiple_failures_with_varying_type(): target = [None] @settings(database=None, max_examples=100) @given(st.integers()) def test(i): if abs(i) < 1000: return if target[0] is None: # Ensure that we have some space to shrink into, so we can't # trigger an minimal example and mask the other exception type. assume(1003 < abs(i)) target[0] = i exc_class = TypeError if target[0] == i else ValueError raise exc_class() with capture_out() as o: with pytest.raises(MultipleFailures): test() assert "TypeError" in o.getvalue() assert "ValueError" in o.getvalue()
def test_prints_reproduction_if_requested(): failing_example = [None] @settings(print_blob=True, database=None, max_examples=100) @given(st.integers()) def test(i): if failing_example[0] is None and i != 0: failing_example[0] = i assert i not in failing_example with capture_out() as o: with pytest.raises(AssertionError): test() assert "@reproduce_failure" in o.getvalue() exp = re.compile(r"reproduce_failure\(([^)]+)\)", re.MULTILINE) extract = exp.search(o.getvalue()) reproduction = eval(extract.group(0)) test = reproduction(test) with pytest.raises(AssertionError): test()
def test_when_set_to_no_simplifies_runs_failing_example_twice(): failing = [] @given(integers()) @settings( phases=no_shrink, max_examples=100, verbosity=Verbosity.normal, report_multiple_bugs=False, ) def foo(x): if x > 11: note("Lo") failing.append(x) assert False with raises(AssertionError): with capture_out() as out: foo() assert len(failing) == 2 assert len(set(failing)) == 1 assert "Falsifying example" in out.getvalue() assert "Lo" in out.getvalue()
def test_prints_seed_only_on_healthcheck( monkeypatch, in_pytest, fail_healthcheck, verbosity ): monkeypatch.setattr(core, "running_under_pytest", in_pytest) strategy = st.integers() if fail_healthcheck: def slow_map(i): time.sleep(10) return i strategy = strategy.map(slow_map) expected_exc = FailedHealthCheck else: expected_exc = AssertionError @settings(database=None, verbosity=verbosity) @given(strategy) def test(i): assert fail_healthcheck with capture_out() as o: with pytest.raises(expected_exc): test() output = o.getvalue() seed = test._hypothesis_internal_use_generated_seed assert seed is not None if fail_healthcheck and verbosity != Verbosity.quiet: assert f"@seed({seed})" in output contains_pytest_instruction = f"--hypothesis-seed={seed}" in output assert contains_pytest_instruction == in_pytest else: assert "@seed" not in output assert f"--hypothesis-seed={seed}" not in output