Merge branch 'master' into crosshair-event

Author: Liam-DeVoe

hypothesis-python/docs/changelog.rst

@@ -18,6 +18,15 @@ Hypothesis 6.x
 
     .. include:: ../RELEASE.rst
 
+.. _v6.148.5:
+
+--------------------
+6.148.5 - 2025-12-01
+--------------------
+
+This patch improves the error message for :class:`~hypothesis.errors.FlakyStrategyDefinition`
+when the precondition for a rule is flaky (:issue:`4206`).
+
 .. _v6.148.4:
 
 --------------------

hypothesis-python/src/hypothesis/stateful.py

@@ -15,6 +15,7 @@
 Notably, the set of steps available at any point may depend on the
 execution to date.
 """
+
 import collections
 import dataclasses
 import inspect
@@ -35,7 +36,11 @@
 )
 from hypothesis.control import _current_build_context, current_build_context
 from hypothesis.core import TestFunc, given
-from hypothesis.errors import InvalidArgument, InvalidDefinition
+from hypothesis.errors import (
+    FlakyStrategyDefinition,
+    InvalidArgument,
+    InvalidDefinition,
+)
 from hypothesis.internal.compat import add_note, batched
 from hypothesis.internal.conjecture.engine import BUFFER_SIZE
 from hypothesis.internal.conjecture.junkdrawer import gc_cumulative_time
@@ -95,7 +100,11 @@ def __delete__(self, obj):
         raise AttributeError("Cannot delete TestCase")
 
 
-def get_state_machine_test(state_machine_factory, *, settings=None, _min_steps=0):
+def get_state_machine_test(
+    state_machine_factory, *, settings=None, _min_steps=0, _flaky_state=None
+):
+    # This function is split out from run_state_machine_as_test so that
+    # HypoFuzz can get and call the test function directly.
     if settings is None:
         try:
             settings = state_machine_factory.TestCase.settings
@@ -108,6 +117,7 @@ def get_state_machine_test(state_machine_factory, *, settings=None, _min_steps=0
         # Because settings can vary via e.g. profiles, settings.stateful_step_count
         # overrides this argument and we don't bother cross-validating.
         raise InvalidArgument(f"_min_steps={_min_steps} must be non-negative.")
+    _flaky_state = _flaky_state or {}
 
     @settings
     @given(st.data())
@@ -161,6 +171,7 @@ def output(s):
 
                 # Choose a rule to run, preferring an initialize rule if there are
                 # any which have not been run yet.
+                _flaky_state["selecting_rule"] = True
                 if machine._initialize_rules_to_run:
                     init_rules = [
                         st.tuples(st.just(rule), st.fixed_dictionaries(rule.arguments))
@@ -170,6 +181,7 @@ def output(s):
                     machine._initialize_rules_to_run.remove(rule)
                 else:
                     rule, data = cd.draw(machine._rules_strategy)
+                _flaky_state["selecting_rule"] = False
                 draw_label = f"generate:rule:{rule.function.__name__}"
                 cd.draw_times.setdefault(draw_label, 0.0)
                 in_gctime = gc_cumulative_time() - start_gc
@@ -250,10 +262,23 @@ def run_state_machine_as_test(state_machine_factory, *, settings=None, _min_step
     RuleBasedStateMachine when called with no arguments - it can be a class or a
     function. settings will be used to control the execution of the test.
     """
+    flaky_state = {"selecting_rule": False}
     state_machine_test = get_state_machine_test(
-        state_machine_factory, settings=settings, _min_steps=_min_steps
+        state_machine_factory,
+        settings=settings,
+        _min_steps=_min_steps,
+        _flaky_state=flaky_state,
     )
-    state_machine_test()
+    try:
+        state_machine_test()
+    except FlakyStrategyDefinition as err:
+        if flaky_state["selecting_rule"]:
+            add_note(
+                err,
+                "while selecting a rule to run. This is usually caused by "
+                "a flaky precondition, or a bundle that was unexpectedly empty.",
+            )
+        raise
 
 
 class StateMachineMeta(type):

hypothesis-python/src/hypothesis/version.py

@@ -8,5 +8,5 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.
 
-__version_info__ = (6, 148, 4)
+__version_info__ = (6, 148, 5)
 __version__ = ".".join(map(str, __version_info__))

hypothesis-python/tests/cover/test_composite.py

@@ -8,7 +8,6 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.
 
-import sys
 import typing
 
 import pytest
@@ -196,21 +195,14 @@ def test_drawfn_cannot_be_instantiated():
 
 
 def test_warns_on_strategy_annotation():
-    # TODO: print the stack on Python 3.10 and 3.11 to determine the appropriate
-    #       stack depth to use.  Consider adding a debug-print if IN_COVERAGE_TESTS
-    #       and the relevant depth is_hypothesis_file(), for easier future fixing.
-    #
-    # Meanwhile, the test is not skipped on 3.10/3.11 as it is still required for
-    # coverage of the warning-generating branch.
     with pytest.warns(HypothesisWarning, match="Return-type annotation") as w:
 
         @st.composite
         def my_integers(draw: st.DrawFn) -> st.SearchStrategy[int]:
             return draw(st.integers())
 
-    if sys.version_info[:2] > (3, 11):  # TEMP: see PR #3961
-        assert len(w.list) == 1
-        assert w.list[0].filename == __file__  # check stacklevel points to user code
+    assert len(w.list) == 1
+    assert w.list[0].filename == __file__  # check stacklevel points to user code
 
 
 def test_composite_allows_overload_without_draw():

hypothesis-python/tests/cover/test_stateful.py

@@ -28,11 +28,18 @@
 from hypothesis.control import current_build_context
 from hypothesis.core import encode_failure
 from hypothesis.database import InMemoryExampleDatabase
-from hypothesis.errors import DidNotReproduce, Flaky, InvalidArgument, InvalidDefinition
+from hypothesis.errors import (
+    DidNotReproduce,
+    Flaky,
+    FlakyStrategyDefinition,
+    InvalidArgument,
+    InvalidDefinition,
+)
 from hypothesis.stateful import (
     Bundle,
     RuleBasedStateMachine,
     consumes,
+    get_state_machine_test,
     initialize,
     invariant,
     multiple,
@@ -151,6 +158,44 @@ def test_flaky_raises_flaky():
         FlakyStateMachine.TestCase().runTest()
 
 
+class FlakyPreconditionMachine(RuleBasedStateMachine):
+    @precondition(lambda self: not current_build_context().is_final)
+    @rule()
+    def action(self):
+        raise AssertionError
+
+
+def test_flaky_precondition_error_message():
+    with raises(FlakyStrategyDefinition) as exc_info:
+        FlakyPreconditionMachine.TestCase().runTest()
+    assert any("flaky precondition" in note for note in exc_info.value.__notes__)
+
+
+class FlakyDrawInRuleMachine(RuleBasedStateMachine):
+    # Flakiness inside rule execution (via data().draw()) happens AFTER rule selection,
+    # so the "flaky precondition" note should NOT be added.
+    @rule(d=data())
+    def action(self, d):
+        if current_build_context().is_final:
+            d.draw(st.integers(0, 0))
+        d.draw(st.integers())
+        raise AssertionError
+
+
+def test_flaky_draw_in_rule_no_precondition_note():
+    # When flakiness occurs during rule execution (not rule selection),
+    # the error message should NOT mention flaky preconditions.
+    with raises(FlakyStrategyDefinition) as exc_info:
+        FlakyDrawInRuleMachine.TestCase().runTest()
+    notes = getattr(exc_info.value, "__notes__", [])
+    assert not any("flaky precondition" in note for note in notes)
+
+
+def test_get_state_machine_test_is_importable():
+    # Regression test: get_state_machine_test is used by HypoFuzz
+    assert callable(get_state_machine_test)
+
+
 class FlakyRatchettingMachine(RuleBasedStateMachine):
     ratchet = 0
 
@@ -1310,7 +1355,6 @@ def test_targets_repr(bundle_names, initial, repr_):
     bundles = {name: Bundle(name) for name in bundle_names}
 
     class Machine(RuleBasedStateMachine):
-
         @initialize(targets=[bundles[name] for name in bundle_names])
         def init(self):
             return initial