star

venv/lib/python3.9/site-packages/graphene/utils/tests/test_crunch.py

@@ -0,0 +1,51 @@
+from pytest import mark
+
+from ..crunch import crunch
+
+
+@mark.parametrize(
+    "description,uncrunched,crunched",
+    [
+        ["number primitive", 0, [0]],
+        ["boolean primitive", True, [True]],
+        ["string primitive", "string", ["string"]],
+        ["empty array", [], [[]]],
+        ["single-item array", [None], [None, [0]]],
+        [
+            "multi-primitive all distinct array",
+            [None, 0, True, "string"],
+            [None, 0, True, "string", [0, 1, 2, 3]],
+        ],
+        [
+            "multi-primitive repeated array",
+            [True, True, True, True],
+            [True, [0, 0, 0, 0]],
+        ],
+        ["one-level nested array", [[1, 2, 3]], [1, 2, 3, [0, 1, 2], [3]]],
+        ["two-level nested array", [[[1, 2, 3]]], [1, 2, 3, [0, 1, 2], [3], [4]]],
+        ["empty object", {}, [{}]],
+        ["single-item object", {"a": None}, [None, {"a": 0}]],
+        [
+            "multi-item all distinct object",
+            {"a": None, "b": 0, "c": True, "d": "string"},
+            [None, 0, True, "string", {"a": 0, "b": 1, "c": 2, "d": 3}],
+        ],
+        [
+            "multi-item repeated object",
+            {"a": True, "b": True, "c": True, "d": True},
+            [True, {"a": 0, "b": 0, "c": 0, "d": 0}],
+        ],
+        [
+            "complex array",
+            [{"a": True, "b": [1, 2, 3]}, [1, 2, 3]],
+            [True, 1, 2, 3, [1, 2, 3], {"a": 0, "b": 4}, [5, 4]],
+        ],
+        [
+            "complex object",
+            {"a": True, "b": [1, 2, 3], "c": {"a": True, "b": [1, 2, 3]}},
+            [True, 1, 2, 3, [1, 2, 3], {"a": 0, "b": 4}, {"a": 0, "b": 4, "c": 5}],
+        ],
+    ],
+)
+def test_crunch(description, uncrunched, crunched):
+    assert crunch(uncrunched) == crunched

venv/lib/python3.9/site-packages/graphene/utils/tests/test_dataloader.py

@@ -0,0 +1,452 @@
+from asyncio import gather
+from collections import namedtuple
+from functools import partial
+from unittest.mock import Mock
+
+from graphene.utils.dataloader import DataLoader
+from pytest import mark, raises
+
+from graphene import ObjectType, String, Schema, Field, List
+
+CHARACTERS = {
+    "1": {"name": "Luke Skywalker", "sibling": "3"},
+    "2": {"name": "Darth Vader", "sibling": None},
+    "3": {"name": "Leia Organa", "sibling": "1"},
+}
+
+get_character = Mock(side_effect=lambda character_id: CHARACTERS[character_id])
+
+
+class CharacterType(ObjectType):
+    name = String()
+    sibling = Field(lambda: CharacterType)
+
+    async def resolve_sibling(character, info):
+        if character["sibling"]:
+            return await info.context.character_loader.load(character["sibling"])
+        return None
+
+
+class Query(ObjectType):
+    skywalker_family = List(CharacterType)
+
+    async def resolve_skywalker_family(_, info):
+        return await info.context.character_loader.load_many(["1", "2", "3"])
+
+
+mock_batch_load_fn = Mock(
+    side_effect=lambda character_ids: [get_character(id) for id in character_ids]
+)
+
+
+class CharacterLoader(DataLoader):
+    async def batch_load_fn(self, character_ids):
+        return mock_batch_load_fn(character_ids)
+
+
+Context = namedtuple("Context", "character_loader")
+
+
+@mark.asyncio
+async def test_basic_dataloader():
+    schema = Schema(query=Query)
+
+    character_loader = CharacterLoader()
+    context = Context(character_loader=character_loader)
+
+    query = """
+        {
+            skywalkerFamily {
+                name
+                sibling {
+                    name
+                }
+            }
+        }
+    """
+
+    result = await schema.execute_async(query, context=context)
+
+    assert not result.errors
+    assert result.data == {
+        "skywalkerFamily": [
+            {"name": "Luke Skywalker", "sibling": {"name": "Leia Organa"}},
+            {"name": "Darth Vader", "sibling": None},
+            {"name": "Leia Organa", "sibling": {"name": "Luke Skywalker"}},
+        ]
+    }
+
+    assert mock_batch_load_fn.call_count == 1
+    assert get_character.call_count == 3
+
+
+def id_loader(**options):
+    load_calls = []
+
+    async def default_resolve(x):
+        return x
+
+    resolve = options.pop("resolve", default_resolve)
+
+    async def fn(keys):
+        load_calls.append(keys)
+        return await resolve(keys)
+        # return keys
+
+    identity_loader = DataLoader(fn, **options)
+    return identity_loader, load_calls
+
+
+@mark.asyncio
+async def test_build_a_simple_data_loader():
+    async def call_fn(keys):
+        return keys
+
+    identity_loader = DataLoader(call_fn)
+
+    promise1 = identity_loader.load(1)
+
+    value1 = await promise1
+    assert value1 == 1
+
+
+@mark.asyncio
+async def test_can_build_a_data_loader_from_a_partial():
+    value_map = {1: "one"}
+
+    async def call_fn(context, keys):
+        return [context.get(key) for key in keys]
+
+    partial_fn = partial(call_fn, value_map)
+    identity_loader = DataLoader(partial_fn)
+
+    promise1 = identity_loader.load(1)
+
+    value1 = await promise1
+    assert value1 == "one"
+
+
+@mark.asyncio
+async def test_supports_loading_multiple_keys_in_one_call():
+    async def call_fn(keys):
+        return keys
+
+    identity_loader = DataLoader(call_fn)
+
+    promise_all = identity_loader.load_many([1, 2])
+
+    values = await promise_all
+    assert values == [1, 2]
+
+    promise_all = identity_loader.load_many([])
+
+    values = await promise_all
+    assert values == []
+
+
+@mark.asyncio
+async def test_batches_multiple_requests():
+    identity_loader, load_calls = id_loader()
+
+    promise1 = identity_loader.load(1)
+    promise2 = identity_loader.load(2)
+
+    p = gather(promise1, promise2)
+
+    value1, value2 = await p
+
+    assert value1 == 1
+    assert value2 == 2
+
+    assert load_calls == [[1, 2]]
+
+
+@mark.asyncio
+async def test_batches_multiple_requests_with_max_batch_sizes():
+    identity_loader, load_calls = id_loader(max_batch_size=2)
+
+    promise1 = identity_loader.load(1)
+    promise2 = identity_loader.load(2)
+    promise3 = identity_loader.load(3)
+
+    p = gather(promise1, promise2, promise3)
+
+    value1, value2, value3 = await p
+
+    assert value1 == 1
+    assert value2 == 2
+    assert value3 == 3
+
+    assert load_calls == [[1, 2], [3]]
+
+
+@mark.asyncio
+async def test_coalesces_identical_requests():
+    identity_loader, load_calls = id_loader()
+
+    promise1 = identity_loader.load(1)
+    promise2 = identity_loader.load(1)
+
+    assert promise1 == promise2
+    p = gather(promise1, promise2)
+
+    value1, value2 = await p
+
+    assert value1 == 1
+    assert value2 == 1
+
+    assert load_calls == [[1]]
+
+
+@mark.asyncio
+async def test_caches_repeated_requests():
+    identity_loader, load_calls = id_loader()
+
+    a, b = await gather(identity_loader.load("A"), identity_loader.load("B"))
+
+    assert a == "A"
+    assert b == "B"
+
+    assert load_calls == [["A", "B"]]
+
+    a2, c = await gather(identity_loader.load("A"), identity_loader.load("C"))
+
+    assert a2 == "A"
+    assert c == "C"
+
+    assert load_calls == [["A", "B"], ["C"]]
+
+    a3, b2, c2 = await gather(
+        identity_loader.load("A"), identity_loader.load("B"), identity_loader.load("C")
+    )
+
+    assert a3 == "A"
+    assert b2 == "B"
+    assert c2 == "C"
+
+    assert load_calls == [["A", "B"], ["C"]]
+
+
+@mark.asyncio
+async def test_clears_single_value_in_loader():
+    identity_loader, load_calls = id_loader()
+
+    a, b = await gather(identity_loader.load("A"), identity_loader.load("B"))
+
+    assert a == "A"
+    assert b == "B"
+
+    assert load_calls == [["A", "B"]]
+
+    identity_loader.clear("A")
+
+    a2, b2 = await gather(identity_loader.load("A"), identity_loader.load("B"))
+
+    assert a2 == "A"
+    assert b2 == "B"
+
+    assert load_calls == [["A", "B"], ["A"]]
+
+
+@mark.asyncio
+async def test_clears_all_values_in_loader():
+    identity_loader, load_calls = id_loader()
+
+    a, b = await gather(identity_loader.load("A"), identity_loader.load("B"))
+
+    assert a == "A"
+    assert b == "B"
+
+    assert load_calls == [["A", "B"]]
+
+    identity_loader.clear_all()
+
+    a2, b2 = await gather(identity_loader.load("A"), identity_loader.load("B"))
+
+    assert a2 == "A"
+    assert b2 == "B"
+
+    assert load_calls == [["A", "B"], ["A", "B"]]
+
+
+@mark.asyncio
+async def test_allows_priming_the_cache():
+    identity_loader, load_calls = id_loader()
+
+    identity_loader.prime("A", "A")
+
+    a, b = await gather(identity_loader.load("A"), identity_loader.load("B"))
+
+    assert a == "A"
+    assert b == "B"
+
+    assert load_calls == [["B"]]
+
+
+@mark.asyncio
+async def test_does_not_prime_keys_that_already_exist():
+    identity_loader, load_calls = id_loader()
+
+    identity_loader.prime("A", "X")
+
+    a1 = await identity_loader.load("A")
+    b1 = await identity_loader.load("B")
+
+    assert a1 == "X"
+    assert b1 == "B"
+
+    identity_loader.prime("A", "Y")
+    identity_loader.prime("B", "Y")
+
+    a2 = await identity_loader.load("A")
+    b2 = await identity_loader.load("B")
+
+    assert a2 == "X"
+    assert b2 == "B"
+
+    assert load_calls == [["B"]]
+
+
+# # Represents Errors
+@mark.asyncio
+async def test_resolves_to_error_to_indicate_failure():
+    async def resolve(keys):
+        mapped_keys = [
+            key if key % 2 == 0 else Exception("Odd: {}".format(key)) for key in keys
+        ]
+        return mapped_keys
+
+    even_loader, load_calls = id_loader(resolve=resolve)
+
+    with raises(Exception) as exc_info:
+        await even_loader.load(1)
+
+    assert str(exc_info.value) == "Odd: 1"
+
+    value2 = await even_loader.load(2)
+    assert value2 == 2
+    assert load_calls == [[1], [2]]
+
+
+@mark.asyncio
+async def test_can_represent_failures_and_successes_simultaneously():
+    async def resolve(keys):
+        mapped_keys = [
+            key if key % 2 == 0 else Exception("Odd: {}".format(key)) for key in keys
+        ]
+        return mapped_keys
+
+    even_loader, load_calls = id_loader(resolve=resolve)
+
+    promise1 = even_loader.load(1)
+    promise2 = even_loader.load(2)
+
+    with raises(Exception) as exc_info:
+        await promise1
+
+    assert str(exc_info.value) == "Odd: 1"
+    value2 = await promise2
+    assert value2 == 2
+    assert load_calls == [[1, 2]]
+
+
+@mark.asyncio
+async def test_caches_failed_fetches():
+    async def resolve(keys):
+        mapped_keys = [Exception("Error: {}".format(key)) for key in keys]
+        return mapped_keys
+
+    error_loader, load_calls = id_loader(resolve=resolve)
+
+    with raises(Exception) as exc_info:
+        await error_loader.load(1)
+
+    assert str(exc_info.value) == "Error: 1"
+
+    with raises(Exception) as exc_info:
+        await error_loader.load(1)
+
+    assert str(exc_info.value) == "Error: 1"
+
+    assert load_calls == [[1]]
+
+
+@mark.asyncio
+async def test_caches_failed_fetches_2():
+    identity_loader, load_calls = id_loader()
+
+    identity_loader.prime(1, Exception("Error: 1"))
+
+    with raises(Exception) as _:
+        await identity_loader.load(1)
+
+    assert load_calls == []
+
+
+# It is resilient to job queue ordering
+@mark.asyncio
+async def test_batches_loads_occuring_within_promises():
+    identity_loader, load_calls = id_loader()
+
+    async def load_b_1():
+        return await load_b_2()
+
+    async def load_b_2():
+        return await identity_loader.load("B")
+
+    values = await gather(identity_loader.load("A"), load_b_1())
+
+    assert values == ["A", "B"]
+
+    assert load_calls == [["A", "B"]]
+
+
+@mark.asyncio
+async def test_catches_error_if_loader_resolver_fails():
+    exc = Exception("AOH!")
+
+    def do_resolve(x):
+        raise exc
+
+    a_loader, a_load_calls = id_loader(resolve=do_resolve)
+
+    with raises(Exception) as exc_info:
+        await a_loader.load("A1")
+
+    assert exc_info.value == exc
+
+
+@mark.asyncio
+async def test_can_call_a_loader_from_a_loader():
+    deep_loader, deep_load_calls = id_loader()
+    a_loader, a_load_calls = id_loader(
+        resolve=lambda keys: deep_loader.load(tuple(keys))
+    )
+    b_loader, b_load_calls = id_loader(
+        resolve=lambda keys: deep_loader.load(tuple(keys))
+    )
+
+    a1, b1, a2, b2 = await gather(
+        a_loader.load("A1"),
+        b_loader.load("B1"),
+        a_loader.load("A2"),
+        b_loader.load("B2"),
+    )
+
+    assert a1 == "A1"
+    assert b1 == "B1"
+    assert a2 == "A2"
+    assert b2 == "B2"
+
+    assert a_load_calls == [["A1", "A2"]]
+    assert b_load_calls == [["B1", "B2"]]
+    assert deep_load_calls == [[("A1", "A2"), ("B1", "B2")]]
+
+
+@mark.asyncio
+async def test_dataloader_clear_with_missing_key_works():
+    async def do_resolve(x):
+        return x
+
+    a_loader, a_load_calls = id_loader(resolve=do_resolve)
+    assert a_loader.clear("A1") == a_loader

venv/lib/python3.9/site-packages/graphene/utils/tests/test_deduplicator.py

@@ -0,0 +1,179 @@
+import datetime
+import graphene
+from graphene import relay
+from graphene.types.resolver import dict_resolver
+
+from ..deduplicator import deflate
+
+
+def test_does_not_modify_object_without_typename_and_id():
+    response = {"foo": "bar"}
+
+    deflated_response = deflate(response)
+    assert deflated_response == {"foo": "bar"}
+
+
+def test_does_not_modify_first_instance_of_an_object():
+    response = {
+        "data": [
+            {"__typename": "foo", "id": 1, "name": "foo"},
+            {"__typename": "foo", "id": 1, "name": "foo"},
+        ]
+    }
+
+    deflated_response = deflate(response)
+
+    assert deflated_response == {
+        "data": [
+            {"__typename": "foo", "id": 1, "name": "foo"},
+            {"__typename": "foo", "id": 1},
+        ]
+    }
+
+
+def test_does_not_modify_first_instance_of_an_object_nested():
+    response = {
+        "data": [
+            {
+                "__typename": "foo",
+                "bar1": {"__typename": "bar", "id": 1, "name": "bar"},
+                "bar2": {"__typename": "bar", "id": 1, "name": "bar"},
+                "id": 1,
+            },
+            {
+                "__typename": "foo",
+                "bar1": {"__typename": "bar", "id": 1, "name": "bar"},
+                "bar2": {"__typename": "bar", "id": 1, "name": "bar"},
+                "id": 2,
+            },
+        ]
+    }
+
+    deflated_response = deflate(response)
+
+    assert deflated_response == {
+        "data": [
+            {
+                "__typename": "foo",
+                "bar1": {"__typename": "bar", "id": 1, "name": "bar"},
+                "bar2": {"__typename": "bar", "id": 1, "name": "bar"},
+                "id": 1,
+            },
+            {
+                "__typename": "foo",
+                "bar1": {"__typename": "bar", "id": 1},
+                "bar2": {"__typename": "bar", "id": 1},
+                "id": 2,
+            },
+        ]
+    }
+
+
+def test_does_not_modify_input():
+    response = {
+        "data": [
+            {"__typename": "foo", "id": 1, "name": "foo"},
+            {"__typename": "foo", "id": 1, "name": "foo"},
+        ]
+    }
+
+    deflate(response)
+
+    assert response == {
+        "data": [
+            {"__typename": "foo", "id": 1, "name": "foo"},
+            {"__typename": "foo", "id": 1, "name": "foo"},
+        ]
+    }
+
+
+TEST_DATA = {
+    "events": [
+        {"id": "568", "date": datetime.date(2017, 5, 19), "movie": "1198359"},
+        {"id": "234", "date": datetime.date(2017, 5, 20), "movie": "1198359"},
+    ],
+    "movies": {
+        "1198359": {
+            "id": "1198359",
+            "name": "King Arthur: Legend of the Sword",
+            "synopsis": (
+                "When the child Arthur's father is murdered, Vortigern, "
+                "Arthur's uncle, seizes the crown. Robbed of his birthright and "
+                "with no idea who he truly is..."
+            ),
+        }
+    },
+}
+
+
+def test_example_end_to_end():
+    class Movie(graphene.ObjectType):
+        class Meta:
+            interfaces = (relay.Node,)
+            default_resolver = dict_resolver
+
+        name = graphene.String(required=True)
+        synopsis = graphene.String(required=True)
+
+    class Event(graphene.ObjectType):
+        class Meta:
+            interfaces = (relay.Node,)
+            default_resolver = dict_resolver
+
+        movie = graphene.Field(Movie, required=True)
+        date = graphene.types.datetime.Date(required=True)
+
+        def resolve_movie(event, info):
+            return TEST_DATA["movies"][event["movie"]]
+
+    class Query(graphene.ObjectType):
+        events = graphene.List(graphene.NonNull(Event), required=True)
+
+        def resolve_events(_, info):
+            return TEST_DATA["events"]
+
+    schema = graphene.Schema(query=Query)
+    query = """\
+        {
+            events {
+                __typename
+                id
+                date
+                movie {
+                    __typename
+                    id
+                    name
+                    synopsis
+                }
+            }
+        }
+    """
+    result = schema.execute(query)
+    assert not result.errors
+
+    data = deflate(result.data)
+    assert data == {
+        "events": [
+            {
+                "__typename": "Event",
+                "id": "RXZlbnQ6NTY4",
+                "date": "2017-05-19",
+                "movie": {
+                    "__typename": "Movie",
+                    "id": "TW92aWU6MTE5ODM1OQ==",
+                    "name": "King Arthur: Legend of the Sword",
+                    "synopsis": (
+                        "When the child Arthur's father is murdered, Vortigern, "
+                        "Arthur's uncle, seizes the crown. Robbed of his birthright and "
+                        "with no idea who he truly is..."
+                    ),
+                },
+            },
+            {
+                "__typename": "Event",
+                "id": "RXZlbnQ6MjM0",
+                "date": "2017-05-20",
+                "movie": {"__typename": "Movie", "id": "TW92aWU6MTE5ODM1OQ=="},
+            },
+        ]
+    }

venv/lib/python3.9/site-packages/graphene/utils/tests/test_deprecated.py

@@ -0,0 +1,9 @@
+from .. import deprecated
+from ..deprecated import warn_deprecation
+
+
+def test_warn_deprecation(mocker):
+    mocker.patch.object(deprecated, "warn")
+
+    warn_deprecation("OH!")
+    deprecated.warn.assert_called_with("OH!", stacklevel=2, category=DeprecationWarning)

venv/lib/python3.9/site-packages/graphene/utils/tests/test_module_loading.py

@@ -0,0 +1,69 @@
+from pytest import raises
+
+from graphene import ObjectType, String
+
+from ..module_loading import import_string, lazy_import
+
+
+def test_import_string():
+    MyString = import_string("graphene.String")
+    assert MyString == String
+
+    MyObjectTypeMeta = import_string("graphene.ObjectType", "__doc__")
+    assert MyObjectTypeMeta == ObjectType.__doc__
+
+
+def test_import_string_module():
+    with raises(Exception) as exc_info:
+        import_string("graphenea")
+
+    assert str(exc_info.value) == "graphenea doesn't look like a module path"
+
+
+def test_import_string_class():
+    with raises(Exception) as exc_info:
+        import_string("graphene.Stringa")
+
+    assert (
+        str(exc_info.value)
+        == 'Module "graphene" does not define a "Stringa" attribute/class'
+    )
+
+
+def test_import_string_attributes():
+    with raises(Exception) as exc_info:
+        import_string("graphene.String", "length")
+
+    assert (
+        str(exc_info.value)
+        == 'Module "graphene" does not define a "length" attribute inside attribute/class '
+        '"String"'
+    )
+
+    with raises(Exception) as exc_info:
+        import_string("graphene.ObjectType", "__class__.length")
+
+    assert (
+        str(exc_info.value)
+        == 'Module "graphene" does not define a "__class__.length" attribute inside '
+        'attribute/class "ObjectType"'
+    )
+
+    with raises(Exception) as exc_info:
+        import_string("graphene.ObjectType", "__classa__.__base__")
+
+    assert (
+        str(exc_info.value)
+        == 'Module "graphene" does not define a "__classa__" attribute inside attribute/class '
+        '"ObjectType"'
+    )
+
+
+def test_lazy_import():
+    f = lazy_import("graphene.String")
+    MyString = f()
+    assert MyString == String
+
+    f = lazy_import("graphene.ObjectType", "__doc__")
+    MyObjectTypeMeta = f()
+    assert MyObjectTypeMeta == ObjectType.__doc__

venv/lib/python3.9/site-packages/graphene/utils/tests/test_orderedtype.py

@@ -0,0 +1,41 @@
+from ..orderedtype import OrderedType
+
+
+def test_orderedtype():
+    one = OrderedType()
+    two = OrderedType()
+    three = OrderedType()
+
+    assert one < two < three
+
+
+def test_orderedtype_eq():
+    one = OrderedType()
+    two = OrderedType()
+
+    assert one == one
+    assert one != two
+
+
+def test_orderedtype_hash():
+    one = OrderedType()
+    two = OrderedType()
+
+    assert hash(one) == hash(one)
+    assert hash(one) != hash(two)
+
+
+def test_orderedtype_resetcounter():
+    one = OrderedType()
+    two = OrderedType()
+    one.reset_counter()
+
+    assert one > two
+
+
+def test_orderedtype_non_orderabletypes():
+    one = OrderedType()
+
+    assert one.__lt__(1) == NotImplemented
+    assert one.__gt__(1) == NotImplemented
+    assert one != 1

venv/lib/python3.9/site-packages/graphene/utils/tests/test_resolve_only_args.py

@@ -0,0 +1,13 @@
+from .. import deprecated
+from ..resolve_only_args import resolve_only_args
+
+
+def test_resolve_only_args(mocker):
+    mocker.patch.object(deprecated, "warn_deprecation")
+
+    def resolver(root, **args):
+        return root, args
+
+    wrapped_resolver = resolve_only_args(resolver)
+    result = wrapped_resolver(1, 2, a=3)
+    assert result == (1, {"a": 3})

venv/lib/python3.9/site-packages/graphene/utils/tests/test_str_converters.py

@@ -0,0 +1,19 @@
+# coding: utf-8
+from ..str_converters import to_camel_case, to_snake_case
+
+
+def test_snake_case():
+    assert to_snake_case("snakesOnAPlane") == "snakes_on_a_plane"
+    assert to_snake_case("SnakesOnAPlane") == "snakes_on_a_plane"
+    assert to_snake_case("SnakesOnA_Plane") == "snakes_on_a__plane"
+    assert to_snake_case("snakes_on_a_plane") == "snakes_on_a_plane"
+    assert to_snake_case("snakes_on_a__plane") == "snakes_on_a__plane"
+    assert to_snake_case("IPhoneHysteria") == "i_phone_hysteria"
+    assert to_snake_case("iPhoneHysteria") == "i_phone_hysteria"
+
+
+def test_camel_case():
+    assert to_camel_case("snakes_on_a_plane") == "snakesOnAPlane"
+    assert to_camel_case("snakes_on_a__plane") == "snakesOnA_Plane"
+    assert to_camel_case("i_phone_hysteria") == "iPhoneHysteria"
+    assert to_camel_case("field_i18n") == "fieldI18n"

venv/lib/python3.9/site-packages/graphene/utils/tests/test_trim_docstring.py

@@ -0,0 +1,22 @@
+from ..trim_docstring import trim_docstring
+
+
+def test_trim_docstring():
+    class WellDocumentedObject:
+        """
+        This object is very well-documented. It has multiple lines in its
+        description.
+
+        Multiple paragraphs too
+        """
+
+    assert (
+        trim_docstring(WellDocumentedObject.__doc__)
+        == "This object is very well-documented. It has multiple lines in its\n"
+        "description.\n\nMultiple paragraphs too"
+    )
+
+    class UndocumentedObject:
+        pass
+
+    assert trim_docstring(UndocumentedObject.__doc__) is None