TST: Add tests covering the inspect.unwrap() problem (#463)

Author: USSX-Hares

pdoc/test/__init__.py

@@ -659,6 +659,47 @@ def test__pdoc__dict(self):
             self.assertEqual(cm, [])
             self.assertNotIn('downloaded_modules', mod.doc)
 
+    # flake8: noqa: E501 line too long
+    def test_class_wrappers(self):
+        """
+        Check that decorated classes are unwrapped properly.
+        Details: https://github.com/pdoc3/pdoc/issues/463
+        """
+
+        module_name = f'{EXAMPLE_MODULE}._test_classwrap'
+
+        root_module = pdoc.Module(module_name, context=pdoc.Context())
+        root_wrapped_cls_parent = root_module.doc['DecoratedClassParent']
+        root_wrapped_cls_child = root_module.doc['DecoratedClassChild']
+
+        module_classdef = root_module.doc['class_definition']
+        module_classdef_cls_parent = module_classdef.doc['DecoratedClassParent']
+        module_classdef_cls_child = module_classdef.doc['DecoratedClassChild']
+
+        module_util = root_module.doc['util']
+        module_util_decorator = module_util.doc['decorate_class']
+
+        self.assertEqual(root_module.qualname, module_name)
+        self.assertEqual(root_wrapped_cls_parent.qualname, 'DecoratedClassParent')
+        self.assertEqual(root_wrapped_cls_parent.docstring,
+                         """This is `DecoratedClassParent` class.""")
+        self.assertEqual(root_wrapped_cls_child.qualname, 'DecoratedClassChild')
+        self.assertEqual(root_wrapped_cls_child.docstring,
+                         """This is an `DecoratedClassParent`'s implementation that always returns 1.""")
+
+        self.assertEqual(module_classdef.qualname, f'{module_name}.class_definition')
+        self.assertEqual(module_classdef_cls_parent.qualname, 'DecoratedClassParent')
+        self.assertEqual(module_classdef_cls_parent.docstring,
+                         """This is `DecoratedClassParent` class.""")
+        self.assertEqual(module_classdef_cls_child.qualname, 'DecoratedClassChild')
+        self.assertEqual(module_classdef_cls_child.docstring,
+                         """This is an `DecoratedClassParent`'s implementation that always returns 1.""")
+
+        self.assertEqual(module_util.qualname, f'{module_name}.util')
+        self.assertEqual(module_util_decorator.qualname, 'decorate_class')
+
+        pdoc.link_inheritance(root_module._context)
+
     @ignore_warnings
     def test_dont_touch__pdoc__blacklisted(self):
         class Bomb:

pdoc/test/example_pkg/_test_classwrap/__init__.py

@@ -0,0 +1,16 @@
+"""
+This is the root module.
+
+This re-exports `DecoratedClassParent` and `DecoratedClassChild`.
+See `pdoc.test.example_pkg._test_classwrap.class_definition.DecoratedClassParent`
+and `pdoc.test.example_pkg._test_classwrap.class_definition.DecoratedClassChild` for more details.
+"""
+
+
+from .class_definition import DecoratedClassParent, DecoratedClassChild
+
+
+__all__ = [
+    'DecoratedClassParent',
+    'DecoratedClassChild',
+]

pdoc/test/example_pkg/_test_classwrap/class_definition.py

@@ -0,0 +1,38 @@
+"""
+This module exports the following classes:
+
+* `DecoratedClassParent`
+* `DecoratedClassChild`
+"""
+
+from .util import decorate_class
+from abc import ABC, abstractmethod
+
+
+@decorate_class
+class DecoratedClassParent(ABC):
+    """ This is `DecoratedClassParent` class. """
+
+    @abstractmethod
+    def __value__(self) -> int:
+        """ An `DecoratedClassParent`'s value implementation, abstract method. """
+        raise NotImplementedError
+
+    @property
+    def value(self) -> int:
+        """ This is `DecoratedClassParent`'s property. """
+        return self.__value__()
+
+
+@decorate_class
+class DecoratedClassChild(DecoratedClassParent):
+    """ This is an `DecoratedClassParent`'s implementation that always returns 1. """
+
+    def __value__(self) -> int:
+        return 1
+
+
+__all__ = [
+    'DecoratedClassParent',
+    'DecoratedClassChild',
+]

pdoc/test/example_pkg/_test_classwrap/util.py

@@ -0,0 +1,37 @@
+import functools
+import types
+from typing import Type, TypeVar, cast
+
+
+C = TypeVar('C')
+
+
+def wrap_first(cls: Type[C]) -> Type[C]:
+    wrapped = types.new_class(cls.__name__, (cls, ), {})
+    wrapped = functools.update_wrapper(wrapped, cls, updated=())
+    wrapped = cast(Type[C], wrapped)
+
+    return wrapped
+
+
+def wrap_second(cls: Type[C]) -> Type[C]:
+    wrapped = type(cls.__name__, cls.__mro__, dict(cls.__dict__))
+    wrapped = functools.update_wrapper(wrapped, cls, updated=())
+    wrapped = cast(Type[C], wrapped)
+
+    return wrapped
+
+
+def decorate_class(cls: Type[C]) -> Type[C]:
+    """ Creates a two-step class decoration. """
+
+    wrapped = wrap_first(cls)
+    wrapped_again = wrap_second(wrapped)
+    wrapped_again.__decorated__ = True
+
+    return wrapped_again
+
+
+__all__ = [
+    'decorate_class',
+]