Teach the Ghostwriter about @staticmethod and @classmethod methods

hypothesis-python/RELEASE.rst

@@ -0,0 +1,6 @@
+RELEASE_TYPE: minor
+
+The :doc:`Ghostwritter <ghostwriter>` can now write tests for
+:obj:`@classmethod <classmethod>` or :obj:`@staticmethod <staticmethod>`
+methods, in addition to the existing support for functions and other callables
+(:issue:`3318`).  Thanks to Cheuk Ting Ho for the patch.

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

@@ -37,7 +37,9 @@
 
 import builtins
 import importlib
+import inspect
 import sys
+import types
 from difflib import get_close_matches
 from functools import partial
 from multiprocessing import Pool
@@ -84,27 +86,64 @@ def obj_name(s: str) -> object:
             return importlib.import_module(s)
         except ImportError:
             pass
+        classname = None
         if "." not in s:
             modulename, module, funcname = "builtins", builtins, s
         else:
             modulename, funcname = s.rsplit(".", 1)
             try:
                 module = importlib.import_module(modulename)
             except ImportError as err:
+                try:
+                    modulename, classname = modulename.rsplit(".", 1)
+                    module = importlib.import_module(modulename)
+                except ImportError:
+                    raise click.UsageError(
+                        f"Failed to import the {modulename} module for introspection.  "
+                        "Check spelling and your Python import path, or use the Python API?"
+                    ) from err
+
+        def describe_close_matches(
+            module_or_class: types.ModuleType, objname: str
+        ) -> str:
+            public_names = [
+                name for name in vars(module_or_class) if not name.startswith("_")
+            ]
+            matches = get_close_matches(objname, public_names)
+            if matches:
+                return f"  Closest matches: {matches!r}"
+            else:
+                return ""
+
+        if classname is None:
+            try:
+                return getattr(module, funcname)
+            except AttributeError as err:
                 raise click.UsageError(
-                    f"Failed to import the {modulename} module for introspection.  "
-                    "Check spelling and your Python import path, or use the Python API?"
+                    f"Found the {modulename!r} module, but it doesn't have a "
+                    f"{funcname!r} attribute."
+                    + describe_close_matches(module, funcname)
+                ) from err
+        else:
+            try:
+                func_class = getattr(module, classname)
+            except AttributeError as err:
+                raise click.UsageError(
+                    f"Found the {modulename!r} module, but it doesn't have a "
+                    f"{classname!r} class." + describe_close_matches(module, classname)
+                ) from err
+            try:
+                return getattr(func_class, funcname)
+            except AttributeError as err:
+                if inspect.isclass(func_class):
+                    func_class_is = "class"
+                else:
+                    func_class_is = "attribute"
+                raise click.UsageError(
+                    f"Found the {modulename!r} module and {classname!r} {func_class_is}, "
+                    f"but it doesn't have a {funcname!r} attribute."
+                    + describe_close_matches(func_class, funcname)
                 ) from err
-        try:
-            return getattr(module, funcname)
-        except AttributeError as err:
-            public_names = [name for name in vars(module) if not name.startswith("_")]
-            matches = get_close_matches(funcname, public_names)
-            raise click.UsageError(
-                f"Found the {modulename!r} module, but it doesn't have a "
-                f"{funcname!r} attribute."
-                + (f"  Closest matches: {matches!r}" if matches else "")
-            ) from err
 
     def _refactor(func, fname):
         try:

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

@@ -891,10 +891,15 @@ def magic(
     for thing in modules_or_functions:
         if callable(thing):
             functions.add(thing)
+            # class need to be added for exploration
+            if inspect.isclass(thing):
+                funcs: List[Optional[Any]] = [thing]
+            else:
+                funcs = []
         elif isinstance(thing, types.ModuleType):
             if hasattr(thing, "__all__"):
                 funcs = [getattr(thing, name, None) for name in thing.__all__]
-            else:
+            elif hasattr(thing, "__package__"):
                 pkg = thing.__package__
                 funcs = [
                     v
@@ -906,22 +911,35 @@ def magic(
                 ]
                 if pkg and any(getattr(f, "__module__", pkg) == pkg for f in funcs):
                     funcs = [f for f in funcs if getattr(f, "__module__", pkg) == pkg]
-            for f in funcs:
-                try:
-                    if (
-                        (not is_mock(f))
-                        and callable(f)
-                        and _get_params(f)
-                        and not isinstance(f, enum.EnumMeta)
-                    ):
-                        functions.add(f)
-                        if getattr(thing, "__name__", None):
-                            KNOWN_FUNCTION_LOCATIONS[f] = thing.__name__
-                except (TypeError, ValueError):
-                    pass
         else:
             raise InvalidArgument(f"Can't test non-module non-callable {thing!r}")
 
+        for f in list(funcs):
+            if inspect.isclass(f):
+                funcs += [
+                    v.__get__(f)
+                    for k, v in vars(f).items()
+                    if hasattr(v, "__func__")
+                    and not is_mock(v)
+                    and not k.startswith("_")
+                ]
+        for f in funcs:
+            try:
+                if (
+                    (not is_mock(f))
+                    and callable(f)
+                    and _get_params(f)
+                    and not isinstance(f, enum.EnumMeta)
+                ):
+                    functions.add(f)
+                    if getattr(thing, "__name__", None):
+                        if inspect.isclass(thing):
+                            KNOWN_FUNCTION_LOCATIONS[f] = thing.__module__
+                        else:
+                            KNOWN_FUNCTION_LOCATIONS[f] = thing.__name__
+            except (TypeError, ValueError):
+                pass
+
     imports = set()
     parts = []
 

hypothesis-python/tests/ghostwriter/recorded/fuzz_staticmethod.txt

@@ -0,0 +1,10 @@
+# This test code was written by the `hypothesis.extra.ghostwriter` module
+# and is provided under the Creative Commons Zero public domain dedication.
+
+import test_expected_output
+from hypothesis import given, strategies as st
+
+
+@given(arg=st.integers())
+def test_fuzz_A_Class_a_staticmethod(arg):
+    test_expected_output.A_Class.a_staticmethod(arg=arg)

hypothesis-python/tests/ghostwriter/recorded/hypothesis_module_magic.txt

@@ -96,6 +96,21 @@ def test_fuzz_settings(
     )
 
 
+@given(name=st.text())
+def test_fuzz_settings_get_profile(name):
+    hypothesis.settings.get_profile(name=name)
+
+
+@given(name=st.text())
+def test_fuzz_settings_load_profile(name):
+    hypothesis.settings.load_profile(name=name)
+
+
+@given(name=st.text(), parent=st.one_of(st.none(), st.builds(settings)))
+def test_fuzz_settings_register_profile(name, parent):
+    hypothesis.settings.register_profile(name=name, parent=parent)
+
+
 @given(observation=st.one_of(st.floats(), st.integers()), label=st.text())
 def test_fuzz_target(observation, label):
     hypothesis.target(observation=observation, label=label)

hypothesis-python/tests/ghostwriter/recorded/magic_builtins.txt

@@ -31,6 +31,16 @@ def test_fuzz_bin(number):
     bin(number)
 
 
+@given(frm=st.nothing(), to=st.nothing())
+def test_fuzz_bytearray_maketrans(frm, to):
+    bytearray.maketrans(frm, to)
+
+
+@given(frm=st.nothing(), to=st.nothing())
+def test_fuzz_bytes_maketrans(frm, to):
+    bytes.maketrans(frm, to)
+
+
 @given(obj=st.nothing())
 def test_fuzz_callable(obj):
     callable(obj)

hypothesis-python/tests/ghostwriter/recorded/magic_class.txt

@@ -0,0 +1,20 @@
+# This test code was written by the `hypothesis.extra.ghostwriter` module
+# and is provided under the Creative Commons Zero public domain dedication.
+
+import test_expected_output
+from hypothesis import given, strategies as st
+
+
+@given()
+def test_fuzz_A_Class():
+    test_expected_output.A_Class()
+
+
+@given(arg=st.integers())
+def test_fuzz_A_Class_a_classmethod(arg):
+    test_expected_output.A_Class.a_classmethod(arg=arg)
+
+
+@given(arg=st.integers())
+def test_fuzz_A_Class_a_staticmethod(arg):
+    test_expected_output.A_Class.a_staticmethod(arg=arg)

hypothesis-python/tests/ghostwriter/test_expected_output.py

@@ -65,6 +65,10 @@ class A_Class:
     def a_classmethod(cls, arg: int):
         pass
 
+    @staticmethod
+    def a_staticmethod(arg: int):
+        pass
+
 
 def add(a: float, b: float) -> float:
     return a + b
@@ -86,6 +90,7 @@ def divide(a: int, b: int) -> float:
         ("fuzz_sorted", ghostwriter.fuzz(sorted)),
         ("fuzz_with_docstring", ghostwriter.fuzz(with_docstring)),
         ("fuzz_classmethod", ghostwriter.fuzz(A_Class.a_classmethod)),
+        ("fuzz_staticmethod", ghostwriter.fuzz(A_Class.a_staticmethod)),
         ("fuzz_ufunc", ghostwriter.fuzz(numpy.add)),
         ("magic_gufunc", ghostwriter.magic(numpy.matmul)),
         ("magic_base64_roundtrip", ghostwriter.magic(base64.b64encode)),
@@ -176,6 +181,7 @@ def divide(a: int, b: int) -> float:
                 style="unittest",
             ),
         ),
+        ("magic_class", ghostwriter.magic(A_Class)),
         pytest.param(
             ("magic_builtins", ghostwriter.magic(builtins)),
             marks=[

hypothesis-python/tests/ghostwriter/test_ghostwriter.py

@@ -257,6 +257,34 @@ def test_invalid_func_inputs(gw, args):
         gw(*args)
 
 
+class A:
+    @classmethod
+    def to_json(cls, obj: Union[dict, list]) -> str:
+        return json.dumps(obj)
+
+    @classmethod
+    def from_json(cls, obj: str) -> Union[dict, list]:
+        return json.loads(obj)
+
+    @staticmethod
+    def static_sorter(seq: Sequence[int]) -> List[int]:
+        return sorted(seq)
+
+
+@pytest.mark.parametrize(
+    "gw,args",
+    [
+        (ghostwriter.fuzz, [A.static_sorter]),
+        (ghostwriter.idempotent, [A.static_sorter]),
+        (ghostwriter.roundtrip, [A.to_json, A.from_json]),
+        (ghostwriter.equivalent, [A.to_json, json.dumps]),
+    ],
+)
+def test_class_methods_inputs(gw, args):
+    source_code = gw(*args)
+    get_test_function(source_code)()
+
+
 def test_run_ghostwriter_fuzz():
     # Our strategy-guessing code works for all the arguments to sorted,
     # and we handle positional-only arguments in calls correctly too.