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_invariant_precondition():
"""If an invariant precodition isn't met, the invariant isn't run.
The precondition decorator can be applied in any order.
"""
class Invariant(RuleBasedStateMachine):
def __init__(self):
super(Invariant, self).__init__()
@invariant()
@precondition(lambda _: False)
def an_invariant(self):
raise ValueError()
@precondition(lambda _: False)
@invariant()
def another_invariant(self):
raise ValueError()
@rule()
def do_stuff(self):
pass
run_state_machine_as_test(Invariant)
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_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_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_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_settings_attribute_is_validated():
real_settings = FailsEventually.TestCase.settings
try:
FailsEventually.TestCase.settings = object()
with pytest.raises(InvalidArgument):
run_state_machine_as_test(FailsEventually)
finally:
FailsEventually.TestCase.settings = real_settings
def test_reproduce_failure_fails_if_no_error():
@reproduce_failure(__version__, base64.b64encode(b"\0\0\0"))
class TrivialMachine(RuleBasedStateMachine):
@rule()
def ok(self):
assert True
with pytest.raises(DidNotReproduce):
run_state_machine_as_test(TrivialMachine)
def test_reproduce_failure_works():
@reproduce_failure(__version__, base64.b64encode(b"\0\0\0"))
class TrivialMachine(RuleBasedStateMachine):
@rule()
def oops(self):
assert False
with pytest.raises(AssertionError):
run_state_machine_as_test(TrivialMachine)
def test_can_explicitly_pass_settings():
try:
FailsEventually.TestCase.settings.stateful_step_count = 15
run_state_machine_as_test(
FailsEventually, settings=Settings(
stateful_step_count=2,
))
finally:
FailsEventually.TestCase.settings.stateful_step_count = 5
def test_func(capsys):
"""Functional test of chirp."""
def init_with_capsys():
return GenFunc(capsys)
# with settings(deadline=None, timeout=unlimited, max_examples=1000,
# max_iterations=10000):
with settings(deadline=None, timeout=unlimited):
run_state_machine_as_test(init_with_capsys)
def test_steps_not_printed_with_pytest_skip(capsys):
class RaisesProblem(RuleBasedStateMachine):
@rule()
def skip_whole_test(self):
pytest.skip()
with pytest.raises(Skipped):
run_state_machine_as_test(RaisesProblem)
out, _ = capsys.readouterr()
assert "state" not in out
def test_can_choose_in_a_machine():
class ChoosingMachine(GenericStateMachine):
def steps(self):
return choices()
def execute_step(self, choices):
choices([1, 2, 3])
run_state_machine_as_test(ChoosingMachine)
def test_uses_seed(capsys):
@seed(0)
class TrivialMachine(RuleBasedStateMachine):
@rule()
def oops(self):
assert False
with pytest.raises(AssertionError):
run_state_machine_as_test(TrivialMachine)
out, _ = capsys.readouterr()
assert "@seed" not in out
def test_steps_printed_despite_pytest_fail(capsys):
# Test for https://github.com/HypothesisWorks/hypothesis/issues/1372
class RaisesProblem(RuleBasedStateMachine):
@rule()
def oops(self):
pytest.fail()
with pytest.raises(Failed):
run_state_machine_as_test(RaisesProblem)
out, _ = capsys.readouterr()
assert 'state = RaisesProblem()\nstate.oops()\nstate.teardown()\n' == out
def test_always_runs_at_least_one_step():
class CountSteps(RuleBasedStateMachine):
def __init__(self):
super(CountSteps, self).__init__()
self.count = 0
@rule()
def do_something(self):
self.count += 1
def teardown(self):
assert self.count > 0
run_state_machine_as_test(CountSteps)
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)
class IncorrectDeletion(RuleBasedStateMachine):
def __init__(self):
super(IncorrectDeletion, self).__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_can_explicitly_call_functions_when_precondition_not_satisfied():
class BadPrecondition(RuleBasedStateMachine):
def __init__(self):
super(BadPrecondition, self).__init__()
@precondition(lambda self: False)
@rule()
def test_blah(self):
raise ValueError()
@rule()
def test_foo(self):
self.test_blah()
with pytest.raises(ValueError):
run_state_machine_as_test(BadPrecondition)
def test_invariant():
"""If an invariant raise an exception, the exception is propagated."""
class Invariant(RuleBasedStateMachine):
def __init__(self):
super(Invariant, self).__init__()
@invariant()
def test_blah(self):
raise ValueError()
@rule()
def do_stuff(self):
pass
with pytest.raises(ValueError):
run_state_machine_as_test(Invariant)
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_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_steps_printed_despite_pytest_fail(capsys):
# Test for https://github.com/HypothesisWorks/hypothesis/issues/1372
class RaisesProblem(RuleBasedStateMachine):
@rule()
def oops(self):
pytest.fail()
with pytest.raises(Failed):
run_state_machine_as_test(RaisesProblem)
out, _ = capsys.readouterr()
assert (
"""\
Falsifying example: run_state_machine(factory=RaisesProblem, data=data(...))
state = RaisesProblem()
state.oops()
state.teardown()
"""
in out
)
def test_minimizes_errors_in_teardown():
counter = [0]
class Foo(GenericStateMachine):
def __init__(self):
counter[0] = 0
def steps(self):
return tuples()
def execute_step(self, value):
counter[0] += 1
def teardown(self):
assert not counter[0]
with raises(AssertionError):
run_state_machine_as_test(Foo)
assert counter[0] == 1
def test_invariant_checks_initial_state():
"""Invariants are checked before any rules run."""
class BadPrecondition(RuleBasedStateMachine):
def __init__(self):
super(BadPrecondition, self).__init__()
self.num = 0
@invariant()
def test_blah(self):
if self.num == 0:
raise ValueError()
@rule()
def test_foo(self):
self.num += 1
with pytest.raises(ValueError):
run_state_machine_as_test(BadPrecondition)
def test_explicit_invariant_call_with_precondition():
"""Invariants can be called explicitly even if their precondition is not
satisfied."""
class BadPrecondition(RuleBasedStateMachine):
def __init__(self):
super(BadPrecondition, self).__init__()
@precondition(lambda self: False)
@invariant()
def test_blah(self):
raise ValueError()
@rule()
def test_foo(self):
self.test_blah()
with pytest.raises(ValueError):
run_state_machine_as_test(BadPrecondition)
def test_multiple_invariants():
"""If multiple invariants are present, they all get run."""
class Invariant(RuleBasedStateMachine):
def __init__(self):
super(Invariant, self).__init__()
self.first_invariant_ran = False
@invariant()
def invariant_1(self):
self.first_invariant_ran = True
@precondition(lambda self: self.first_invariant_ran)
@invariant()
def invariant_2(self):
raise ValueError()
@rule()
def do_stuff(self):
pass
with pytest.raises(ValueError):
run_state_machine_as_test(Invariant)
def test_can_use_factory_for_tests():
with raises(ValueError):
run_state_machine_as_test(lambda: RequiresInit(42))
def test_can_use_factory_for_tests():
with raises(ValueError):
run_state_machine_as_test(lambda: RequiresInit(42))
def test_saves_failing_example_in_database():
db = ExampleDatabase()
with raises(AssertionError):
run_state_machine_as_test(
SetStateMachine, Settings(database=db))
assert len(list(db.data.keys())) == 1
def test_can_run_with_no_db():
with raises(AssertionError):
run_state_machine_as_test(
SetStateMachine, Settings(database=None))
def test_invalid_state_machine():
class NotAStateMachine:
pass
with pytest.raises(hypothesis.errors.InvalidArgument):
run_state_machine_as_test(NotAStateMachine)
