refactor(test): Reduce usage of assume()

According to recommendation of hypothesis, .filter() is more efficient

Author: abelcheung

tests/runtime/elem/test_attrib.py

@@ -27,7 +27,11 @@
     signature_tester,
     strategy as _st,
 )
-from .._testutils.common import attr_name_types, attr_value_types
+from .._testutils.common import (
+    attr_name_types,
+    attr_value_types,
+    hashable_elem_if_is_set,
+)
 from .._testutils.errors import raise_invalid_utf8_type
 
 if sys.version_info >= (3, 11):
@@ -65,11 +69,7 @@ def test_key_type_bad_1(self, disposable_attrib: _Attrib, thing: Any) -> None:
     def test_key_type_bad_2(
         self, disposable_attrib: _Attrib, iterable_of: Any, k: _AttrName
     ) -> None:
-        # unhashable types not addable to set
-        assume(not (
-            getattr(iterable_of, "type") in {set, frozenset}
-            and isinstance(k, bytearray)
-        ))  # fmt: skip
+        assume(hashable_elem_if_is_set(iterable_of, k))
         with raise_invalid_utf8_type:
             _ = disposable_attrib[iterable_of(k)]
 
@@ -94,11 +94,7 @@ def test_value_type_bad_1(self, disposable_attrib: _Attrib, thing: Any) -> None:
     def test_value_type_bad_2(
         self, disposable_attrib: _Attrib, iterable_of: Any, v: _AttrVal
     ) -> None:
-        # unhashable types not addable to set
-        assume(not (
-            getattr(iterable_of, "type") in {set, frozenset}
-            and isinstance(v, bytearray)
-        ))  # fmt: skip
+        assume(hashable_elem_if_is_set(iterable_of, v))
         with raise_invalid_utf8_type:
             disposable_attrib["foo"] = iterable_of(v)
 
@@ -391,10 +387,7 @@ def test_input_iterable_ok(
         iterable_of: Any,
     ) -> None:
         # unhashable types not addable to set
-        assume(not (
-            getattr(iterable_of, "type") in {set, frozenset}
-            and isinstance(v, bytearray)
-        ))  # fmt: skip
+        assume(hashable_elem_if_is_set(iterable_of, v))
         self._verify_key_val_present(disposable_attrib, iterable_of((k, v)))
 
     @given(atts=st.iterables(

tests/runtime/elem/test_elem_accessor.py

@@ -12,7 +12,6 @@
 import pytest
 from hypothesis import (
     HealthCheck,
-    assume,
     given,
     settings,
     strategies as st,
@@ -76,10 +75,13 @@ def test_child_arg_bad_2(
         suppress_health_check=[HealthCheck.function_scoped_fixture],
         max_examples=300,
     )
-    @given(thing=_st.all_instances_except_of_type(NoneType, int, Decimal))
+    @given(
+        thing=_st.all_instances_except_of_type(NoneType, int, Decimal).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_start_arg_bad_1(self, xml2_root: _Element, thing: Any) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         with raise_lxml_non_integer:
             _ = xml2_root.index(xml2_root[0], start=thing)
 
@@ -96,10 +98,13 @@ def test_start_arg_bad_2(self, xml2_root: _Element, iterable_of: Any) -> None:
         suppress_health_check=[HealthCheck.function_scoped_fixture],
         max_examples=300,
     )
-    @given(thing=_st.all_instances_except_of_type(NoneType, int, Decimal))
+    @given(
+        thing=_st.all_instances_except_of_type(NoneType, int, Decimal).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_stop_arg_bad_1(self, xml2_root: _Element, thing: Any) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         with raise_lxml_non_integer:
             _ = xml2_root.index(xml2_root[0], stop=thing)
 

tests/runtime/elem/test_find_methods.py

@@ -15,7 +15,12 @@
 from typing import Any, cast
 
 import pytest
-from hypothesis import HealthCheck, assume, example, given, settings
+from hypothesis import (
+    HealthCheck,
+    example,
+    given,
+    settings,
+)
 from lxml.etree import (
     QName,
     _Attrib as _Attrib,
@@ -109,12 +114,15 @@ def test_namespaces_arg_ok(self, svg_root: _Element) -> None:
 
     # range objects can cause indefinite hang
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(Mapping, NoneType, range))
+    @given(
+        thing=_st.all_instances_except_of_type(Mapping, NoneType, range).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_namespaces_arg_bad_1(
         self, disposable_element: _Element, thing: Any
     ) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         # pyrefly: ignore[no-matching-overload]
         with pytest.raises((TypeError, AttributeError)):  # too diversified
             _ = disposable_element.iterfind("foo", namespaces=thing)
@@ -175,12 +183,15 @@ def test_namespaces_arg_ok(self, svg_root: _Element) -> None:
 
     # range objects can cause indefinite hang
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(Mapping, NoneType, range))
+    @given(
+        thing=_st.all_instances_except_of_type(Mapping, NoneType, range).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_namespaces_arg_bad_1(
         self, disposable_element: _Element, thing: Any
     ) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         # pyrefly: ignore[no-matching-overload]
         with pytest.raises((TypeError, AttributeError)):  # too diversified
             _ = disposable_element.find("foo", namespaces=thing)
@@ -241,12 +252,15 @@ def test_namespaces_arg_ok(self, svg_root: _Element) -> None:
 
     # range objects can cause indefinite hang
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(Mapping, NoneType, range))
+    @given(
+        thing=_st.all_instances_except_of_type(Mapping, NoneType, range).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_namespaces_arg_bad_1(
         self, disposable_element: _Element, thing: Any
     ) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         # pyrefly: ignore[no-matching-overload]
         with pytest.raises((TypeError, AttributeError)):  # too diversified
             _ = disposable_element.findall("foo", namespaces=thing)
@@ -329,12 +343,15 @@ def test_namespaces_arg_ok(self, svg_root: _Element) -> None:
 
     # range objects can cause indefinite hang
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(Mapping, NoneType, range))
+    @given(
+        thing=_st.all_instances_except_of_type(Mapping, NoneType, range).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_namespaces_arg_bad_1(
         self, disposable_element: _Element, thing: Any
     ) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         # pyrefly: ignore[no-matching-overload]
         with pytest.raises((TypeError, AttributeError)):  # too diversified
             _ = disposable_element.findtext("foo", namespaces=thing)

tests/runtime/elem/test_iter_methods.py

@@ -323,10 +323,13 @@ def test_input_ok(self, svg_root: _Element, arg: Any, kw: Any, empty: bool) -> N
         max_examples=300,
     )
     @given(
-        thing=_st.all_instances_except_of_type(
+        thing=_st
+        .all_instances_except_of_type(
             *tag_selector_types.allow,
             *tag_selector_types.skip,
-        ).filter(lambda x: x is not NotImplemented and bool(x)).filter(lambda x: not can_practically_iter(x)),
+        )
+        .filter(lambda x: x is not NotImplemented and bool(x))
+        .filter(lambda x: not can_practically_iter(x)),
     )
     @pytest.mark.slow
     def test_input_bad_1(self, xml2_root: _Element, thing: Any) -> None:

tests/runtime/html_/test_beautifulsoup.py

@@ -10,7 +10,11 @@
 
 import pytest
 from bs4 import BeautifulSoup
-from hypothesis import HealthCheck, assume, given, settings
+from hypothesis import (
+    HealthCheck,
+    given,
+    settings,
+)
 from lxml.etree import (
     Element,
     _Element as _Element,
@@ -93,10 +97,13 @@ def test_beautifulsoup_arg_ok(self, html2_str: str) -> None:
         del result2
 
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(NoneType))
+    @given(
+        thing=_st.all_instances_except_of_type(NoneType).filter(
+            lambda x: x is not NoneType
+        )
+    )
     @pytest.mark.slow
     def test_beautifulsoup_arg_bad_1(self, html2_str: str, thing: Any) -> None:
-        assume(thing is not NoneType)
         if not callable(thing):
             with raise_non_callable:
                 _ = _soup.fromstring(html2_str, thing)
@@ -293,11 +300,14 @@ def test_makeelement_arg_ok(self, html2_str: str) -> None:
         del result2
 
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(NoneType))
+    @given(
+        thing=_st.all_instances_except_of_type(NoneType).filter(
+            lambda x: x is not NoneType
+        )
+    )
     @pytest.mark.slow
     def test_makeelement_arg_bad_1(self, html2_str: str, thing: Any) -> None:
         soup = BeautifulSoup(html2_str, features="html.parser")
-        assume(thing is not NoneType)
         if not callable(thing):
             with raise_non_callable:
                 _ = _soup.convert_tree(soup, makeelement=thing)

tests/runtime/html_/test_element.py

@@ -273,15 +273,13 @@ def test_sequence_modify_bad_1(
     # items into element tree (e.g. huge ranges)
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
     @given(
-        thing=_st
-        .all_instances_except_of_type(
+        thing=_st.all_instances_except_of_type(
             _Element,
             Iterator,
             range,
             ipaddress.IPv4Network,
             ipaddress.IPv6Network,
-        )
-        .filter(lambda x: x is not NotImplemented and bool(x))
+        ).filter(lambda x: x is not NotImplemented and bool(x))
     )
     @pytest.mark.slow
     def test_sequence_modify_bad_2(

tests/runtime/html_/test_html5lib.py

@@ -12,7 +12,11 @@
 import lxml.etree as _e
 import lxml.html.html5parser as h5
 import pytest
-from hypothesis import HealthCheck, assume, given, settings
+from hypothesis import (
+    HealthCheck,
+    given,
+    settings,
+)
 from lxml.etree import (
     _Element as _Element,
     _ElementTree as _ElementTree,
@@ -220,10 +224,13 @@ def test_parse_src_ok(
     #   empty html document (<html><body/></html>)
     # - buffer-like objects, in which html content is directly taken from
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(str, io.BytesIO, io.StringIO, Buffer))
+    @given(
+        thing=_st.all_instances_except_of_type(
+            str, io.BytesIO, io.StringIO, Buffer
+        ).filter(lambda x: x is not NotImplemented and bool(x))
+    )
     @pytest.mark.slow
     def test_parse_src_bad(self, thing: Any) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         # pyrefly: ignore[no-matching-overload]
         with pytest.raises((
             TypeError,

tests/runtime/html_/test_link_funcs.py

@@ -18,7 +18,6 @@
 import pytest
 from hypothesis import (
     HealthCheck,
-    assume,
     given,
     settings,
 )
@@ -304,12 +303,15 @@ def test_handle_failures_arg_ok(
                     assert old != new
 
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(NoneType))
+    @given(
+        thing=_st.all_instances_except_of_type(NoneType).filter(
+            lambda x: x not in ("ignore", "discard")
+        )
+    )
     @pytest.mark.slow
     def test_handle_failures_arg_bad_1(
         self, disposable_html_with_base_href: HtmlElement, thing: Any
     ) -> None:
-        assume(thing not in ("ignore", "discard"))
         # collection raises TypeError instead
         # because of error in constructing exception
         # pyrefly: ignore[no-matching-overload]
@@ -352,12 +354,15 @@ def test_handle_failures_valid_type(
                     assert old != new
 
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(NoneType))
+    @given(
+        thing=_st.all_instances_except_of_type(NoneType).filter(
+            lambda x: x not in ("ignore", "discard")
+        )
+    )
     @pytest.mark.slow
     def test_handle_failures_wrong_type(
         self, disposable_html_with_base_href: HtmlElement, thing: Any
     ) -> None:
-        assume(thing not in ("ignore", "discard"))
         # pyrefly: ignore[no-matching-overload]
         with pytest.raises((
             ValueError,
@@ -371,13 +376,16 @@ def test_handle_failures_wrong_type(
     # that can be anything
 
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(str, NoneType))
+    # Falsy values short circuited by urljoin() and never raises
+    @given(
+        thing=_st.all_instances_except_of_type(str, NoneType).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_base_href(
         self, disposable_html_with_base_href: HtmlElement, thing: Any
     ) -> None:
-        # Falsy values short circuited by urljoin() and never raises
-        assume(thing is not NotImplemented and bool(thing))
         with pytest.raises(TypeError, match="Cannot mix str and non-str arguments"):
             _ = make_links_absolute(disposable_html_with_base_href, base_url=thing)
 
@@ -434,13 +442,16 @@ def test_link_repl_func_bad_input(
     # that can be anything
 
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(str, NoneType))
+    # Falsy values got short circuited by urljoin() and never raises
+    @given(
+        thing=_st.all_instances_except_of_type(str, NoneType).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_base_href(
         self, disposable_html_with_base_href: HtmlElement, thing: Any
     ) -> None:
-        # Falsy values got short circuited by urljoin() and never raises
-        assume(thing is not NotImplemented and bool(thing))
         with pytest.raises(TypeError, match="Cannot mix str and non-str arguments"):
             _ = rewrite_links(disposable_html_with_base_href, str, base_href=thing)
 

tests/runtime/test_errorlog.py

@@ -10,7 +10,11 @@
 from typing import Any, cast
 
 import pytest
-from hypothesis import HealthCheck, assume, given, settings
+from hypothesis import (
+    HealthCheck,
+    given,
+    settings,
+)
 from lxml.etree import (
     ErrorDomains,
     ErrorLevels,
@@ -317,10 +321,13 @@ def test_init_name_arg_ok(self) -> None:
         use_global_python_log(pylog)
 
     @settings(suppress_health_check=[HealthCheck.too_slow], max_examples=300)
-    @given(thing=_st.all_instances_except_of_type(str))
+    @given(
+        thing=_st.all_instances_except_of_type(str).filter(
+            lambda x: x is not NotImplemented and bool(x)
+        )
+    )
     @pytest.mark.slow
     def test_init_name_arg_bad_1(self, thing: Any) -> None:
-        assume(thing is not NotImplemented and bool(thing))
         with pytest.raises(TypeError, match="logger name must be a string"):
             _ = PyErrorLog(logger_name=thing)