Merge pull request #2995 from Zalathar/url-fragments-coverage

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,6 @@
+RELEASE_TYPE: patch
+
+This release adjusts some internal code to help make our test suite more
+reliable.
+
+There is no user-visible change.

hypothesis-python/src/hypothesis/extra/django/_fields.py

@@ -233,7 +233,7 @@ def _for_text(field):
         # Not maximally efficient, but it makes pathological cases rarer.
         # If you want a challenge: extend https://qntm.org/greenery to
         # compute intersections of the full Python regex language.
-        return st.one_of(*[st.from_regex(r) for r in regexes])
+        return st.one_of(*(st.from_regex(r) for r in regexes))
     # If there are no (usable) regexes, we use a standard text strategy.
     min_size, max_size = length_bounds_from_validators(field)
     strategy = st.text(

hypothesis-python/src/hypothesis/extra/numpy.py

@@ -1489,5 +1489,5 @@ def array_for(index_shape, size):
         )
 
     return result_shape.flatmap(
-        lambda index_shape: st.tuples(*[array_for(index_shape, size) for size in shape])
+        lambda index_shape: st.tuples(*(array_for(index_shape, size) for size in shape))
     )

hypothesis-python/src/hypothesis/internal/filtering.py

@@ -180,7 +180,7 @@ def numeric_bounds_from_ast(
 
     if isinstance(tree, ast.BoolOp) and isinstance(tree.op, ast.And):
         return merge_preds(
-            *[numeric_bounds_from_ast(node, argname, fallback) for node in tree.values]
+            *(numeric_bounds_from_ast(node, argname, fallback) for node in tree.values)
         )
 
     return fallback

hypothesis-python/src/hypothesis/provisional.py

@@ -112,7 +112,7 @@ def do_draw(self, data):
             .filter(lambda tld: len(tld) + 2 <= self.max_length)
             .flatmap(
                 lambda tld: st.tuples(
-                    *[st.sampled_from([c.lower(), c.upper()]) for c in tld]
+                    *(st.sampled_from([c.lower(), c.upper()]) for c in tld)
                 ).map("".join)
             )
         )
@@ -142,6 +142,25 @@ def domains(
     )
 
 
+# The `urls()` strategy uses this to generate URL fragments (e.g. "#foo").
+# It has been extracted to top-level so that we can test it independently
+# of `urls()`, which helps with getting non-flaky coverage of the lambda.
+_url_fragments_strategy = (
+    st.lists(
+        st.builds(
+            lambda char, encode: f"%{ord(char):02X}"
+            if (encode or char not in FRAGMENT_SAFE_CHARACTERS)
+            else char,
+            st.characters(min_codepoint=0, max_codepoint=255),
+            st.booleans(),
+        ),
+        min_size=1,
+    )
+    .map("".join)
+    .map("#{}".format)
+)
+
+
 @defines_strategy(force_reusable_values=True)
 def urls() -> st.SearchStrategy[str]:
     """A strategy for :rfc:`3986`, generating http/https URLs."""
@@ -152,26 +171,12 @@ def url_encode(s):
     schemes = st.sampled_from(["http", "https"])
     ports = st.integers(min_value=0, max_value=2 ** 16 - 1).map(":{}".format)
     paths = st.lists(st.text(string.printable).map(url_encode)).map("/".join)
-    fragments = (
-        st.lists(
-            st.builds(
-                lambda char, encode: f"%{ord(char):02X}"
-                if (encode or char not in FRAGMENT_SAFE_CHARACTERS)
-                else char,
-                st.characters(min_codepoint=0, max_codepoint=255),
-                st.booleans(),
-            ),
-            min_size=1,
-        )
-        .map("".join)
-        .map("#{}".format)
-    )
 
     return st.builds(
         "{}://{}{}/{}{}".format,
         schemes,
         domains(),
         st.just("") | ports,
         paths,
-        st.just("") | fragments,
+        st.just("") | _url_fragments_strategy,
     )

hypothesis-python/src/hypothesis/strategies/_internal/collections.py

@@ -40,7 +40,7 @@ def do_validate(self):
 
     def calc_label(self):
         return combine_labels(
-            self.class_label, *[s.label for s in self.element_strategies]
+            self.class_label, *(s.label for s in self.element_strategies)
         )
 
     def __repr__(self):

hypothesis-python/src/hypothesis/strategies/_internal/core.py

@@ -762,7 +762,7 @@ def __init__(self, target, args, kwargs):
     def do_draw(self, data):
         try:
             return self.target(
-                *[data.draw(a) for a in self.args],
+                *(data.draw(a) for a in self.args),
                 **{k: data.draw(v) for k, v in self.kwargs.items()},
             )
         except TypeError as err:

hypothesis-python/src/hypothesis/strategies/_internal/strategies.py

@@ -638,7 +638,7 @@ def element_strategies(self):
 
     def calc_label(self):
         return combine_labels(
-            self.class_label, *[p.label for p in self.original_strategies]
+            self.class_label, *(p.label for p in self.original_strategies)
         )
 
     def do_draw(self, data: ConjectureData) -> Ex:

hypothesis-python/tests/common/utils.py

@@ -19,6 +19,7 @@
 
 from hypothesis._settings import Phase
 from hypothesis.errors import HypothesisDeprecationWarning
+from hypothesis.internal.entropy import deterministic_PRNG
 from hypothesis.internal.reflection import proxies
 from hypothesis.reporting import default, with_reporter
 from hypothesis.strategies._internal.core import from_type, register_type_strategy
@@ -94,8 +95,13 @@ def fails_with(e):
     def accepts(f):
         @proxies(f)
         def inverted_test(*arguments, **kwargs):
-            with raises(e):
-                f(*arguments, **kwargs)
+            # Most of these expected-failure tests are non-deterministic, so
+            # we rig the PRNG to avoid occasional flakiness. We do this outside
+            # the `raises` context manager so that any problems in rigging the
+            # PRNG don't accidentally count as the expected failure.
+            with deterministic_PRNG():
+                with raises(e):
+                    f(*arguments, **kwargs)
 
         return inverted_test
 

hypothesis-python/tests/cover/test_provisional_strategies.py

@@ -18,9 +18,14 @@
 
 import pytest
 
-from hypothesis import given
+from hypothesis import given, settings
 from hypothesis.errors import InvalidArgument
-from hypothesis.provisional import domains, urls
+from hypothesis.provisional import (
+    FRAGMENT_SAFE_CHARACTERS,
+    _url_fragments_strategy,
+    domains,
+    urls,
+)
 
 from tests.common.debug import find_any
 
@@ -63,3 +68,18 @@ def test_valid_domains_arguments(max_length, max_element_length):
 @pytest.mark.parametrize("strategy", [domains(), urls()])
 def test_find_any_non_empty(strategy):
     find_any(strategy, lambda s: len(s) > 0)
+
+
+@given(_url_fragments_strategy)
+# There's a lambda in the implementation that only gets run if we generate at
+# least one percent-escape sequence, so we derandomize to ensure that coverage
+# isn't flaky.
+@settings(derandomize=True)
+def test_url_fragments_contain_legal_chars(fragment):
+    assert fragment.startswith("#")
+
+    # Strip all legal escape sequences. Any remaining % characters were not
+    # part of a legal escape sequence.
+    without_escapes = re.sub(r"(?ai)%[0-9a-f][0-9a-f]", "", fragment[1:])
+
+    assert set(without_escapes).issubset(FRAGMENT_SAFE_CHARACTERS)