Type tests

.github/workflows/ci.yml

@@ -144,6 +144,11 @@ jobs:
         run: |
           nox -s verify-types
 
+      - name: Verify test types
+        if: always()
+        run: |
+          nox -s verify-test-types
+
       - name: Flake8
         if: always()
         run: |

pipelines/nox.py

@@ -43,7 +43,16 @@
 
 
 # Default sessions should be defined here
-_options.sessions = ["reformat-code", "codespell", "pytest", "flake8", "slotscheck", "mypy", "verify-types"]
+_options.sessions = [
+    "reformat-code",
+    "codespell",
+    "pytest",
+    "flake8",
+    "slotscheck",
+    "mypy",
+    "verify-types",
+    "verify-test-types",
+]
 _options.default_venv_backend = venv_backend
 
 _NoxCallbackSig = _typing.Callable[[Session], None]

pipelines/pyright.nox.py

@@ -52,3 +52,10 @@ def verify_types(session: nox.Session) -> None:
     """Verify the "type completeness" of types exported by the library using Pyright."""
     session.install(".", *nox.dev_requirements("pyright"))
     session.run("pyright", "--verifytypes", config.MAIN_PACKAGE, "--ignoreexternal")
+
+
+@nox.session()
+def verify_test_types(session: nox.Session) -> None:
+    """Verify the "type completeness" of the test types using Pyright."""
+    session.install(".", *nox.dev_requirements("pyright"))
+    session.run("pyright", config.TEST_PACKAGE)

tests/hikari/conftest.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import datetime
+
+import mock
+import pytest
+
+from hikari import channels
+from hikari import emojis
+from hikari import guilds
+from hikari import messages
+from hikari import snowflakes
+from hikari import stickers
+from hikari import users
+
+
+@pytest.fixture
+def hikari_partial_guild() -> guilds.PartialGuild:
+    return guilds.PartialGuild(
+        app=mock.Mock(), id=snowflakes.Snowflake(123), icon_hash="partial_guild_icon_hash", name="partial_guild"
+    )
+
+
+@pytest.fixture
+def hikari_guild_text_channel() -> channels.GuildTextChannel:
+    return channels.GuildTextChannel(
+        app=mock.Mock(),
+        id=snowflakes.Snowflake(4560),
+        name="guild_text_channel_name",
+        type=channels.ChannelType.GUILD_TEXT,
+        guild_id=mock.Mock(),  # FIXME: Can this be pulled from the actual fixture?
+        parent_id=mock.Mock(),  # FIXME: Can this be pulled from the actual fixture?
+        position=0,
+        is_nsfw=False,
+        permission_overwrites={},
+        topic=None,
+        last_message_id=None,
+        rate_limit_per_user=datetime.timedelta(seconds=10),
+        last_pin_timestamp=None,
+        default_auto_archive_duration=datetime.timedelta(seconds=10),
+    )
+
+
+@pytest.fixture
+def hikari_user() -> users.User:
+    return users.UserImpl(
+        id=snowflakes.Snowflake(789),
+        app=mock.Mock(),
+        discriminator="0",
+        username="user_username",
+        global_name="user_global_name",
+        avatar_hash="user_avatar_hash",
+        banner_hash="user_banner_hash",
+        accent_color=None,
+        is_bot=False,
+        is_system=False,
+        flags=users.UserFlag.NONE,
+    )
+
+
+@pytest.fixture
+def hikari_message() -> messages.Message:
+    return messages.Message(
+        id=snowflakes.Snowflake(101),
+        app=mock.Mock(),
+        channel_id=snowflakes.Snowflake(456),
+        guild_id=None,
+        author=mock.Mock(),
+        member=mock.Mock(),
+        content=None,
+        timestamp=datetime.datetime.fromtimestamp(6000),
+        edited_timestamp=None,
+        is_tts=False,
+        user_mentions={},
+        role_mention_ids=[],
+        channel_mentions={},
+        mentions_everyone=False,
+        attachments=[],
+        embeds=[],
+        reactions=[],
+        is_pinned=False,
+        webhook_id=snowflakes.Snowflake(432),
+        type=messages.MessageType.DEFAULT,
+        activity=None,
+        application=None,
+        message_reference=None,
+        flags=messages.MessageFlag.NONE,
+        stickers=[],
+        nonce=None,
+        referenced_message=None,
+        interaction=None,
+        application_id=None,
+        components=[],
+        thread=None,
+    )
+
+
+@pytest.fixture
+def hikari_partial_sticker() -> stickers.PartialSticker:
+    return stickers.PartialSticker(
+        id=snowflakes.Snowflake(222), name="sticker_name", format_type=stickers.StickerFormatType.PNG
+    )
+
+
+@pytest.fixture
+def hikari_guild_sticker() -> stickers.GuildSticker:
+    return stickers.GuildSticker(
+        id=snowflakes.Snowflake(2220),
+        name="guild_sticker_name",
+        format_type=stickers.StickerFormatType.PNG,
+        description="guild_sticker_description",
+        guild_id=snowflakes.Snowflake(123),
+        is_available=True,
+        tag="guild_sticker_tag",
+        user=None,
+    )
+
+
+@pytest.fixture
+def hikari_custom_emoji() -> emojis.CustomEmoji:
+    return emojis.CustomEmoji(id=snowflakes.Snowflake(444), name="custom_emoji_name", is_animated=False)
+
+
+@pytest.fixture
+def hikari_unicode_emoji() -> emojis.UnicodeEmoji:
+    return emojis.UnicodeEmoji("🙂")

tests/hikari/events/test_base_events.py

@@ -91,29 +91,30 @@ def error(self):
             return ex
 
     @pytest.fixture
-    def event(self, error):
+    def event(self, error: RuntimeError) -> base_events.ExceptionEvent[mock.Mock]:
         return base_events.ExceptionEvent(
             exception=error, failed_event=mock.Mock(base_events.Event), failed_callback=mock.AsyncMock()
         )
 
-    def test_app_property(self, event):
+    def test_app_property(self, event: base_events.ExceptionEvent[mock.Mock]):
         app = mock.Mock()
         event.failed_event.app = app
         assert event.app is app
 
     @pytest.mark.parametrize("has_shard", [True, False])
-    def test_shard_property(self, has_shard, event):
+    def test_shard_property(self, has_shard: bool, event: base_events.ExceptionEvent[mock.Mock]):
         shard = mock.Mock(spec_set=gateway_shard.GatewayShard)
         if has_shard:
             event.failed_event.shard = shard
             assert event.shard is shard
         else:
             assert event.shard is None
 
-    def test_exc_info_property(self, event, error):
+    def test_exc_info_property(self, event: base_events.ExceptionEvent[mock.Mock], error: RuntimeError):
         assert event.exc_info == (type(error), error, error.__traceback__)
 
     @pytest.mark.asyncio
-    async def test_retry(self, event):
-        await event.retry()
-        event.failed_callback.assert_awaited_once_with(event.failed_event)
+    async def test_retry(self, event: base_events.ExceptionEvent[mock.Mock]):
+        with mock.patch.object(event, "failed_callback") as patched_failed_callback:
+            await event.retry()
+            patched_failed_callback.assert_awaited_once_with(event.failed_event)