polish: add tests for assert_equal_awaitables_or_values

Replicates graphql/graphql-js@a842678

Author: Cito

tests/execution/test_subscribe.py

@@ -1,16 +1,5 @@
 import asyncio
-from typing import (
-    Any,
-    AsyncIterable,
-    Awaitable,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-)
+from typing import Any, AsyncIterable, Callable, Dict, List, Optional, TypeVar, Union
 
 from pytest import mark, raises
 
@@ -33,6 +22,8 @@
     GraphQLString,
 )
 
+from ..utils.assert_equal_awaitables_or_values import assert_equal_awaitables_or_values
+
 
 try:
     from typing import TypedDict
@@ -150,27 +141,6 @@ def transform(new_email):
 DummyQueryType = GraphQLObjectType("Query", {"dummy": GraphQLField(GraphQLString)})
 
 
-def assert_equal_awaitables_or_values(
-    value1: AwaitableOrValue[T], value2: AwaitableOrValue[T]
-) -> AwaitableOrValue[T]:
-    if is_awaitable(value1):
-        awaitable1 = cast(Awaitable[T], value1)
-        assert is_awaitable(value2)
-        awaitable2 = cast(Awaitable[T], value2)
-
-        # noinspection PyShadowingNames
-        async def awaited_equal_value():
-            value1 = await awaitable1
-            value2 = await awaitable2
-            assert value1 == value2
-            return value1
-
-        return awaited_equal_value()
-    assert not is_awaitable(value2)
-    assert value1 == value2
-    return value1
-
-
 def subscribe_with_bad_fn(
     subscribe_fn: Callable,
 ) -> AwaitableOrValue[Union[ExecutionResult, AsyncIterable[Any]]]:

tests/utils/__init__.py

@@ -1,7 +1,14 @@
 """Test utilities"""
 
+from .assert_equal_awaitables_or_values import assert_equal_awaitables_or_values
+from .assert_matching_values import assert_matching_values
 from .dedent import dedent
 from .gen_fuzz_strings import gen_fuzz_strings
 
 
-__all__ = ["dedent", "gen_fuzz_strings"]
+__all__ = [
+    "assert_matching_values",
+    "assert_equal_awaitables_or_values",
+    "dedent",
+    "gen_fuzz_strings",
+]

tests/utils/assert_equal_awaitables_or_values.py

@@ -0,0 +1,27 @@
+import asyncio
+from typing import Awaitable, Tuple, TypeVar, cast
+
+from graphql.pyutils import is_awaitable
+
+from .assert_matching_values import assert_matching_values
+
+
+__all__ = ["assert_equal_awaitables_or_values"]
+
+T = TypeVar("T")
+
+
+def assert_equal_awaitables_or_values(*items: T) -> T:
+    """Check whether the items are the same and either all awaitables or all values."""
+    if all(is_awaitable(item) for item in items):
+        awaitable_items = cast(Tuple[Awaitable], items)
+
+        async def assert_matching_awaitables():
+            return assert_matching_values(*(await asyncio.gather(*awaitable_items)))
+
+        return assert_matching_awaitables()
+
+    if all(not is_awaitable(item) for item in items):
+        return assert_matching_values(*items)
+
+    assert False, "Received an invalid mixture of promises and values."

tests/utils/assert_matching_values.py

@@ -0,0 +1,14 @@
+from typing import TypeVar
+
+
+__all__ = ["assert_matching_values"]
+
+T = TypeVar("T")
+
+
+def assert_matching_values(*values: T) -> T:
+    """Test that all values in the sequence are equal."""
+    first_value, *remaining_values = values
+    for value in remaining_values:
+        assert value == first_value
+    return first_value

tests/utils/test_assert_equal_awaitables_or_values.py

@@ -0,0 +1,49 @@
+from pytest import mark, raises
+
+from . import assert_equal_awaitables_or_values
+
+
+def describe_assert_equal_awaitables_or_values():
+    def throws_when_given_unequal_values():
+        with raises(AssertionError):
+            assert_equal_awaitables_or_values({}, {}, {"test": "test"})
+
+    def does_not_throw_when_given_equal_values():
+        test_value = {"test": "test"}
+        assert (
+            assert_equal_awaitables_or_values(test_value, test_value, test_value)
+            == test_value
+        )
+
+    @mark.asyncio
+    async def does_not_throw_when_given_equal_awaitables():
+        async def test_value():
+            return {"test": "test"}
+
+        assert (
+            await assert_equal_awaitables_or_values(
+                test_value(), test_value(), test_value()
+            )
+            == await test_value()
+        )
+
+    @mark.asyncio
+    async def throws_when_given_unequal_awaitables():
+        async def test_value(value):
+            return value
+
+        with raises(AssertionError):
+            await assert_equal_awaitables_or_values(
+                test_value({}), test_value({}), test_value({"test": "test"})
+            )
+
+    @mark.asyncio
+    async def throws_when_given_mixture_of_equal_values_and_awaitables():
+        async def test_value():
+            return {"test": "test"}
+
+        with raises(
+            AssertionError,
+            match=r"Received an invalid mixture of promises and values\.",
+        ):
+            await assert_equal_awaitables_or_values(await test_value(), test_value())

tests/utils/test_assert_matching_values.py

@@ -0,0 +1,13 @@
+from pytest import raises
+
+from . import assert_matching_values
+
+
+def describe_assert_matching_values():
+    def throws_when_given_unequal_values():
+        with raises(AssertionError):
+            assert_matching_values({}, {}, {"test": "test"})
+
+    def does_not_throw_when_given_equal_values():
+        test_value = {"test": "test"}
+        assert assert_matching_values(test_value, test_value, test_value) == test_value