dissect.target 3.20.2.dev55__tar.gz → 3.20.2.dev57__tar.gz

{dissect_target-3.20.2.dev55/dissect.target.egg-info → dissect_target-3.20.2.dev57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dissect.target
-Version: 3.20.2.dev55
+Version: 3.20.2.dev57
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/dissect/target/plugin.py

@@ -82,6 +82,10 @@ class PluginDescriptor:
     functions: list[str]
     exports: list[str]
 
+    @property
+    def cls(self) -> type[Plugin]:
+        return load(self)
+
 
 @dataclass(frozen=True, eq=True)
 class FunctionDescriptor:
@@ -112,6 +116,22 @@ class FunctionDescriptor:
     module: str
     qualname: str
 
+    @property
+    def cls(self) -> type[Plugin]:
+        return load(self)
+
+    @property
+    def func(self) -> Callable[..., Any]:
+        return getattr(self.cls, self.method_name)
+
+    @property
+    def record(self) -> RecordDescriptor | list[RecordDescriptor] | None:
+        return getattr(self.func, "__record__", None)
+
+    @property
+    def args(self) -> list[tuple[list[str], dict[str, Any]]]:
+        return getattr(self.func, "__args__", [])
+
 
 @dataclass(frozen=True, eq=True)
 class FailureDescriptor:
@@ -191,7 +211,7 @@ def export(*args, **kwargs) -> Callable[..., Any]:
         cache (bool): Whether the result of this function should be cached.
 
         record (RecordDescriptor): The :class:`flow.record.RecordDescriptor` for the records that this function yields.
-            If multiple record types are yielded, specificy each descriptor in a list.
+            If multiple record types are yielded, specificy each descriptor in a list or tuple.
             If the records are dynamically made, use :func:`dissect.target.helpers.record.DynamicDescriptor` instead.
 
         output (str): The output type of this function. Must be one of:
@@ -227,8 +247,13 @@ def export(*args, **kwargs) -> Callable[..., Any]:
         if record is not None:
             output = "record"
 
+            if not isinstance(record, (list, RecordDescriptor)) and not (
+                isinstance(record, (list, tuple)) and all(isinstance(r, RecordDescriptor) for r in record)
+            ):
+                raise TypeError("record must be an instance of RecordDescriptor or a list of RecordDescriptor")
+
         obj.__output__ = output
-        obj.__record__ = record
+        obj.__record__ = list(record) if isinstance(record, tuple) else record
         obj.__exported__ = True
 
         if kwargs.get("property", False):
@@ -841,6 +866,43 @@ def find_functions(
     return result, invalid_functions
 
 
+def find_functions_by_record_field_type(
+    field_types: str | list[str],
+    target: Target | None = None,
+    compatibility: bool = False,
+    ignore_load_errors: bool = False,
+) -> Iterator[FunctionDescriptor]:
+    """Find functions that yield records with a specific field type.
+
+    Args:
+        field_types: The field type to search for.
+        target: The target to check compatibility with.
+        compatibility: Whether to check compatibility with the target.
+        ignore_load_errors: Whether to ignore load errors.
+    """
+
+    def _search(search_types: list[str]) -> Iterator[FunctionDescriptor]:
+        for descriptor in functions():
+            try:
+                if descriptor.output != "record" or (record_descriptors := descriptor.record) is None:
+                    continue
+            except Exception:
+                if ignore_load_errors:
+                    continue
+                raise
+
+            for rd in record_descriptors if isinstance(record_descriptors, list) else [record_descriptors]:
+                if any(type_name in search_types for type_name, _ in rd._field_tuples):
+                    yield descriptor
+                    break
+
+    search_types = field_types if isinstance(field_types, list) else [field_types]
+    if compatibility and target is not None:
+        yield from _filter_compatible(_search(search_types), target, ignore_load_errors)
+    else:
+        yield from _search(search_types)
+
+
 def _filter_exact_match(
     pattern: str, os_filter: str, exact_match: bool, exact_os_match: bool
 ) -> Iterator[FunctionDescriptor]:
@@ -899,6 +961,7 @@ def _filter_compatible(
             raise
 
         if plugincls not in seen:
+            seen.add(plugincls)
             try:
                 if not plugincls(target).is_compatible():
                     continue

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/dissect/target/plugins/apps/productivity/sevenzip.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterator, Union
+from typing import Iterator, Union, get_args
 
 from dissect.target.exceptions import RegistryError, UnsupportedPluginError
 from dissect.target.helpers.record import TargetRecordDescriptor
@@ -77,7 +77,7 @@ class SevenZipPlugin(Plugin):
         except RegistryError:
             pass
 
-    @export(record=SevenZipRecord)
+    @export(record=get_args(SevenZipRecord))
     @alias("7zip")
     def sevenzip(self) -> Iterator[SevenZipRecord]:
         """Return 7-Zip GUI history information from the registry.

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/dissect/target/plugins/general/plugins.py

@@ -58,9 +58,7 @@ def generate_functions_json(functions: list[plugin.FunctionDescriptor] | None =
     failed = []
 
     for desc in functions or _get_default_functions():
-        plugincls = plugin.load(desc)
-        func = getattr(plugincls, desc.method_name)
-        docstring = func.__doc__.split("\n\n", 1)[0].strip() if func.__doc__ else None
+        docstring = desc.func.__doc__.split("\n\n", 1)[0].strip() if desc.func.__doc__ else None
         arguments = [
             {
                 "name": name[0],
@@ -69,7 +67,7 @@ def generate_functions_json(functions: list[plugin.FunctionDescriptor] | None =
                 "default": arg.get("default"),
                 "required": arg.get("required", False),
             }
-            for name, arg in getattr(func, "__args__", [])
+            for name, arg in desc.args
         ]
 
         loaded.append(
@@ -112,7 +110,7 @@ def _categorize_functions(functions: list[plugin.FunctionDescriptor] | None = No
             obj = obj.setdefault(part, {})
 
         if parts[-1] not in obj:
-            obj[parts[-1]] = plugin.load(desc)
+            obj[parts[-1]] = desc.cls
 
     return dict(sorted(result.items()))
 

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/dissect/target/plugins/os/default/network.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterator, Union
+from typing import Any, Iterator, Union, get_args
 
 from flow.record.fieldtypes.net import IPAddress, IPNetwork
 from flow.record.fieldtypes.net.ipv4 import Address, addr_long, addr_str, mask_to_bits
@@ -41,7 +41,7 @@ class NetworkPlugin(Plugin):
             else:
                 yield output
 
-    @export(record=InterfaceRecord)
+    @export(record=get_args(InterfaceRecord))
     def interfaces(self) -> Iterator[InterfaceRecord]:
         """Yield interfaces."""
         # Only search for the interfaces once

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/dissect/target/tools/query.py

@@ -27,7 +27,7 @@ from dissect.target.plugins.general.plugins import (
     generate_functions_json,
     generate_functions_overview,
 )
-from dissect.target.report import ExecutionReport
+from dissect.target.tools.report import ExecutionReport
 from dissect.target.tools.utils import (
     catch_sigpipe,
     configure_generic_arguments,

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dissect.target
-Version: 3.20.2.dev55
+Version: 3.20.2.dev57
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/dissect.target.egg-info/SOURCES.txt

@@ -16,7 +16,6 @@ dissect/target/exceptions.py
 dissect/target/filesystem.py
 dissect/target/loader.py
 dissect/target/plugin.py
-dissect/target/report.py
 dissect/target/target.py
 dissect/target/volume.py
 dissect/target/containers/__init__.py
@@ -395,6 +394,7 @@ dissect/target/tools/logging.py
 dissect/target/tools/mount.py
 dissect/target/tools/query.py
 dissect/target/tools/reg.py
+dissect/target/tools/report.py
 dissect/target/tools/shell.py
 dissect/target/tools/utils.py
 dissect/target/tools/yara.py
@@ -416,9 +416,8 @@ tests/conftest.py
 tests/test_container.py
 tests/test_exceptions.py
 tests/test_filesystem.py
+tests/test_loader.py
 tests/test_plugin.py
-tests/test_registration.py
-tests/test_report.py
 tests/test_target.py
 tests/test_tests.py
 tests/test_volume.py
@@ -689,6 +688,7 @@ tests/tools/test_info.py
 tests/tools/test_mount.py
 tests/tools/test_query.py
 tests/tools/test_reg.py
+tests/tools/test_report.py
 tests/tools/test_shell.py
 tests/tools/test_utils.py
 tests/tools/test_yara.py

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/tests/test_container.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import struct
+import textwrap
 from io import BytesIO
 from pathlib import Path
 from typing import Iterator
@@ -11,6 +12,7 @@ import pytest
 from dissect.target import container
 from dissect.target.containers import raw, vhd
 from dissect.target.exceptions import ContainerError
+from dissect.target.plugin import load_modules_from_paths
 
 
 @pytest.fixture
@@ -98,3 +100,57 @@ def test_reset_file_position() -> None:
         assert isinstance(opened_container, mock_container.MockContainer)
         assert opened_container.success
         assert fh.tell() == 512
+
+
+def test_registration(tmp_path: Path) -> None:
+    code = """
+        from __future__ import annotations
+
+        import io
+        from pathlib import Path
+        from typing import BinaryIO
+
+        from dissect.target.container import Container, register
+
+
+        class TestContainer(Container):
+            def __init__(self, fh: BinaryIO | Path, *args, **kwargs):
+                super().__init__(fh, 20, *args, **kwargs)
+
+            def __repr__(self) -> str:
+                return f"<{self.__class__.__name__} size={self.size} vs={self.vs}>"
+
+            @staticmethod
+            def _detect_fh(fh: BinaryIO, original: list[BinaryIO] | BinaryIO) -> bool:
+                return False
+
+            @staticmethod
+            def detect_path(path: Path, original: list[Path] | Path) -> bool:
+                return False
+
+            def read(self, length: int) -> bytes:
+                return self.fh.read(length)
+
+            def seek(self, offset: int, whence: int = io.SEEK_SET) -> int:
+                return self.fh.seek(offset, whence)
+
+            def seekable(self) -> bool:
+                return True
+
+            def tell(self) -> int:
+                return self.fh.tell()
+
+            def close(self) -> None:
+                pass
+
+
+        register(__name__, TestContainer.__name__, internal=False)
+    """
+
+    (tmp_path / "container.py").write_text(textwrap.dedent(code))
+
+    with patch("dissect.target.container.CONTAINERS", []) as mocked_containers:
+        load_modules_from_paths([tmp_path])
+
+        assert len(mocked_containers) == 1
+        assert mocked_containers[0].__name__ == "TestContainer"

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/tests/test_filesystem.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import stat
+import textwrap
 from datetime import datetime, timezone
 from io import BytesIO
 from pathlib import Path
@@ -34,6 +35,7 @@ from dissect.target.filesystems.extfs import ExtFilesystem, ExtFilesystemEntry
 from dissect.target.filesystems.ffs import FfsFilesystemEntry
 from dissect.target.filesystems.tar import TarFilesystemEntry
 from dissect.target.filesystems.xfs import XfsFilesystemEntry
+from dissect.target.plugin import load_modules_from_paths
 
 try:
     from dissect.target.filesystems.vmfs import VmfsFilesystemEntry
@@ -59,6 +61,42 @@ def vfs() -> VirtualFilesystem:
     return vfs
 
 
+def test_registration(tmp_path: Path) -> None:
+    code = """
+        from __future__ import annotations
+
+        from typing import BinaryIO
+
+        from dissect.target.filesystem import Filesystem, FilesystemEntry, register
+        from dissect.target.volume import Volume
+
+
+        class TestFilesystem(Filesystem):
+            __type__ = "test"
+
+            def __init__(self, case_sensitive: bool = True, alt_separator: str = None, volume: Volume = None):
+                super().__init__(case_sensitive, alt_separator, volume)
+                print("Helloworld from TestFilesystem")
+
+            def get(self, path: str) -> FilesystemEntry:
+                pass
+
+            def detect(fh: BinaryIO) -> bool:
+                return False
+
+
+        register(__name__, TestFilesystem.__name__, internal=False)
+    """
+
+    (tmp_path / "filesystem.py").write_text(textwrap.dedent(code))
+
+    with patch("dissect.target.filesystem.FILESYSTEMS", []) as mocked_filesystems:
+        load_modules_from_paths([tmp_path])
+
+        assert len(mocked_filesystems) == 1
+        assert mocked_filesystems[0].__name__ == "TestFilesystem"
+
+
 def test_get(vfs: VirtualFilesystem) -> None:
     assert vfs.get("dirlink1").name == "dirlink1"
     assert vfs.get("dirlink1").is_symlink()

dissect_target-3.20.2.dev57/tests/test_loader.py

@@ -0,0 +1,37 @@
+import textwrap
+from pathlib import Path
+from unittest.mock import patch
+
+from dissect.target.plugin import load_modules_from_paths
+
+
+def test_registration(tmp_path: Path) -> None:
+    code = """
+        from pathlib import Path
+
+        from dissect.target import container
+        from dissect.target.loader import Loader, register
+        from dissect.target.target import Target
+
+
+        class TestLoader(Loader):
+            @staticmethod
+            def detect(path: Path) -> bool:
+                return False
+
+            def map(self, target: Target) -> None:
+                target.disks.add(container.open(self.path))
+
+
+        register(__name__, TestLoader.__name__, internal=False)
+    """
+    (tmp_path / "loader.py").write_text(textwrap.dedent(code))
+
+    with (
+        patch("dissect.target.loader.LOADERS", []) as mocked_loaders,
+        patch("dissect.target.loader.LOADERS_BY_SCHEME", {}),
+    ):
+        load_modules_from_paths([tmp_path])
+
+        assert len(mocked_loaders) == 1
+        assert mocked_loaders[0].__name__ == "TestLoader"

{dissect_target-3.20.2.dev55 → dissect_target-3.20.2.dev57}/tests/test_plugin.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import textwrap
 from functools import reduce
 from pathlib import Path
@@ -24,18 +25,22 @@ from dissect.target.plugin import (
     PluginDescriptor,
     PluginDescriptorLookup,
     PluginRegistry,
+    _find_py_files,
     _generate_long_paths,
     _save_plugin_import_failure,
     alias,
     environment_variable_paths,
     export,
     find_functions,
+    find_functions_by_record_field_type,
+    functions,
     get_external_module_paths,
-    load,
     load_modules_from_paths,
     lookup,
     plugins,
 )
+from dissect.target.plugins.apps.other.env import EnvironmentFilePlugin
+from dissect.target.plugins.general.users import UsersPlugin
 from dissect.target.plugins.os.default._os import DefaultPlugin
 from dissect.target.target import Target
 
@@ -80,6 +85,100 @@ def test_load_paths_with_env() -> None:
         assert get_external_module_paths([Path(""), Path("")]) == [Path("")]
 
 
+def test_load_environment_variable_empty_string() -> None:
+    with patch("dissect.target.plugin._find_py_files") as mocked_find_py_files:
+        load_modules_from_paths([])
+        mocked_find_py_files.assert_not_called()
+
+
+def test_load_environment_variable_comma_seperated_string() -> None:
+    with patch("dissect.target.plugin._find_py_files") as mocked_find_py_files:
+        load_modules_from_paths([Path(""), Path("")])
+        mocked_find_py_files.assert_called_with(Path(""))
+
+
+def test_filter_file(tmp_path: Path) -> None:
+    file = tmp_path / "hello.py"
+    file.touch()
+
+    assert list(_find_py_files(file)) == [file]
+
+    test_file = tmp_path / "non_existent_file"
+    assert list(_find_py_files(test_file)) == []
+
+    test_file = tmp_path / "__init__.py"
+    test_file.touch()
+    assert list(_find_py_files(test_file)) == []
+
+
+@pytest.mark.parametrize(
+    ("filename", "empty_list"),
+    [
+        ("__init__.py", True),
+        ("__pycache__/help.pyc", True),
+        ("hello/test.py", False),
+    ],
+)
+def test_filter_directory(tmp_path: Path, filename: str, empty_list: bool) -> None:
+    file = tmp_path / filename
+    file.parent.mkdir(parents=True, exist_ok=True)
+    file.touch()
+
+    if empty_list:
+        assert list(_find_py_files(tmp_path)) == []
+    else:
+        assert file in list(_find_py_files(tmp_path))
+
+
+@pytest.mark.parametrize(
+    ("filename", "expected_module"),
+    [
+        ("test.py", "test"),
+        ("hello_world/help.py", "hello_world.help"),
+        ("path/to/file.py", "path.to.file"),
+    ],
+)
+def test_filesystem_module_registration(tmp_path: Path, filename: str, expected_module: str) -> None:
+    path = tmp_path / filename
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.touch()
+
+    load_modules_from_paths([tmp_path])
+
+    assert expected_module in sys.modules.keys()
+
+
+def test_plugin_registration(tmp_path: Path) -> None:
+    code = """
+        from dissect.target.plugin import Plugin, export
+
+
+        class TestPlugin(Plugin):
+            __register__ = False
+
+            def check_compatible(self) -> None:
+                return None
+
+            @export(output="default")
+            def hello_world(self):
+                for x in self.target.fs.iterdir(""):
+                    print(f"hello {x}")
+    """
+    (tmp_path / "plugin.py").write_text(textwrap.dedent(code))
+
+    with patch("dissect.target.plugin.register") as mock_register:
+        load_modules_from_paths([tmp_path])
+
+        mock_register.assert_called_once()
+        assert mock_register.call_args[0][0].__name__ == "TestPlugin"
+
+    with patch("dissect.target.plugin.register") as mock_register:
+        load_modules_from_paths([tmp_path / "plugin.py"])
+
+        mock_register.assert_called_once()
+        assert mock_register.call_args[0][0].__name__ == "TestPlugin"
+
+
 @patch("dissect.target.plugin.PLUGINS", new_callable=PluginRegistry)
 def test_plugin_directory(mock_plugins: PluginRegistry, tmp_path: Path) -> None:
     code = """
@@ -850,20 +949,12 @@ def test_function_required_arguments(target_default: Target) -> None:
     # function without any arguments should have an args property with an empty list
     syslog_fd = find_functions("syslog", target_default)[0][0]
     assert syslog_fd
-
-    # args property does not exist until https://github.com/fox-it/dissect.target/pull/1007 is merged
-    func = getattr(load(syslog_fd), syslog_fd.method_name)
-    assert not hasattr(func, "__args__")
+    assert not syslog_fd.args
 
     # function with an argument should have an args property filled
     envfile_fd = find_functions("envfile", target_default)[0][0]
     assert envfile_fd
-
-    # args property does not exist until https://github.com/fox-it/dissect.target/pull/1007 is merged
-    func = getattr(load(envfile_fd), envfile_fd.method_name)
-    assert hasattr(func, "__args__")
-
-    assert func.__args__ == [
+    assert envfile_fd.args == [
         (
             ("--env-path",),
             {
@@ -881,6 +972,47 @@ def test_function_required_arguments(target_default: Target) -> None:
     ]
 
 
+def test_plugin_runtime_info() -> None:
+    plugin_desc = next(p for p in plugins() if p.path == "general.users")
+    assert plugin_desc.cls is UsersPlugin
+
+    func_desc = next(p for p in functions() if p.path == "apps.other.env.envfile")
+    assert func_desc.cls is EnvironmentFilePlugin
+    assert func_desc.func is EnvironmentFilePlugin.envfile
+    assert func_desc.record is EnvironmentFilePlugin.envfile.__record__
+    assert func_desc.args == EnvironmentFilePlugin.envfile.__args__
+
+
+def test_find_by_record_field_type(target_default: Target) -> None:
+    assert "filesystem.walkfs.walkfs" in [desc.path for desc in find_functions_by_record_field_type("path")]
+    assert "apps.other.env.envfile" in [
+        desc.path for desc in find_functions_by_record_field_type("path", target_default, compatibility=True)
+    ]
+
+    with patch(
+        "dissect.target.plugin.functions",
+        return_value=[
+            FunctionDescriptor(
+                name="test",
+                namespace=None,
+                path="test",
+                exported=True,
+                internal=False,
+                findable=True,
+                alias=False,
+                output="record",
+                method_name="test",
+                module="test",
+                qualname="Test",
+            )
+        ],
+    ):
+        with pytest.raises(PluginError, match="An exception occurred while trying to load a plugin: test"):
+            list(find_functions_by_record_field_type("path"))
+
+        assert list(find_functions_by_record_field_type("path", ignore_load_errors=True)) == []
+
+
 @pytest.mark.parametrize(
     "method_name",
     [
@@ -1044,6 +1176,7 @@ def test_plugin_alias(target_bare: Target) -> None:
 @pytest.mark.parametrize(
     "descriptor",
     find_functions("*", Target(), compatibility=False, show_hidden=True)[0],
+    ids=lambda d: d.path,
 )
 def test_exported_plugin_format(descriptor: FunctionDescriptor) -> None:
     """This test checks plugin style guide conformity for all exported plugins.
@@ -1051,23 +1184,20 @@ def test_exported_plugin_format(descriptor: FunctionDescriptor) -> None:
     Resources:
         - https://docs.dissect.tools/en/latest/contributing/style-guide.html
     """
-    plugincls = load(descriptor)
-
     # Ignore DefaultPlugin and NamespacePlugin instances
-    if plugincls.__base__ is NamespacePlugin or plugincls is DefaultPlugin:
+    if descriptor.cls.__base__ is NamespacePlugin or descriptor.cls is DefaultPlugin:
         return
 
     # Plugin method should specify what it returns
     assert descriptor.output in ["record", "yield", "default", "none"], f"Invalid output_type for function {descriptor}"
 
-    py_func = getattr(plugincls, descriptor.method_name)
     annotations = None
 
-    if hasattr(py_func, "__annotations__"):
-        annotations = py_func.__annotations__
+    if hasattr(descriptor.func, "__annotations__"):
+        annotations = descriptor.func.__annotations__
 
-    elif isinstance(py_func, property):
-        annotations = py_func.fget.__annotations__
+    elif isinstance(descriptor.func, property):
+        annotations = descriptor.func.fget.__annotations__
 
     # Plugin method should have a return annotation
     assert annotations and "return" in annotations.keys(), f"No return type annotation for function {descriptor}"
@@ -1075,7 +1205,7 @@ def test_exported_plugin_format(descriptor: FunctionDescriptor) -> None:
     # TODO: Check if the annotations make sense with the provided output_type
 
     # Plugin method should have a docstring
-    method_doc_str = py_func.__doc__
+    method_doc_str = descriptor.func.__doc__
     assert isinstance(method_doc_str, str), f"No docstring for function {descriptor}"
     assert method_doc_str != "", f"Empty docstring for function {descriptor}"
 
@@ -1083,9 +1213,9 @@ def test_exported_plugin_format(descriptor: FunctionDescriptor) -> None:
     assert_valid_rst(method_doc_str)
 
     # Plugin class should have a docstring
-    class_doc_str = plugincls.__doc__
-    assert isinstance(class_doc_str, str), f"No docstring for class {plugincls.__name__}"
-    assert class_doc_str != "", f"Empty docstring for class {plugincls.__name__}"
+    class_doc_str = descriptor.cls.__doc__
+    assert isinstance(class_doc_str, str), f"No docstring for class {descriptor.cls.__name__}"
+    assert class_doc_str != "", f"Empty docstring for class {descriptor.cls.__name__}"
 
     # The class docstring should compile to rst without warnings
     assert_valid_rst(class_doc_str)