Type tests

.github/workflows/ci.yml

@@ -64,7 +64,7 @@ jobs:
           include-hidden-files: true
 
   upload-coverage:
-    needs: [test]
+    needs: [ test ]
     runs-on: ubuntu-latest
 
     steps:
@@ -151,6 +151,11 @@ jobs:
         run: |
           nox -s verify-types
 
+      - name: Pyright (tests)
+        if: always()
+        run: |
+          nox -s pyright-tests
+
       - name: Ruff
         if: always() && !cancelled()
         run: |
@@ -220,7 +225,7 @@ jobs:
 
   # Allows us to add this as a required check in Github branch rules, as all the other jobs are subject to change
   ci-done:
-    needs: [upload-coverage, linting, twemoji, docs]
+    needs: [ upload-coverage, linting, twemoji, docs ]
     if: always() && !cancelled()
 
     runs-on: ubuntu-latest

hikari/users.py

@@ -622,12 +622,6 @@ class User(PartialUser, abc.ABC):
 
     __slots__: typing.Sequence[str] = ()
 
-    @property
-    @abc.abstractmethod
-    @typing_extensions.override
-    def app(self) -> traits.RESTAware:
-        """Client application that models may use for procedures."""
-
     @property
     @abc.abstractmethod
     @typing_extensions.override

pipelines/nox.py

@@ -28,7 +28,16 @@
 NoxCallbackSigT = typing.Callable[[nox.Session], None]
 
 # Default sessions should be defined here
-nox.options.sessions = ["reformat-code", "codespell", "pytest", "ruff", "slotscheck", "mypy", "verify-types"]
+nox.options.sessions = [
+    "reformat-code",
+    "codespell",
+    "pytest",
+    "pyright-tests",
+    "ruff",
+    "slotscheck",
+    "mypy",
+    "verify-types",
+]
 nox.options.default_venv_backend = "uv"
 
 

pipelines/pyright.nox.py

@@ -35,7 +35,14 @@ def pyright(session: nox.Session) -> None:
     exists to make it easier to test and eventually reach that 100% compatibility.
     """
     nox.sync(session, self=True, extras=["speedups", "server"], groups=["pyright"])
-    session.run("pyright")
+    session.run("pyright", config.MAIN_PACKAGE)
+
+
+@nox.session()
+def pyright_tests(session: nox.Session) -> None:
+    """Perform type analysis on the tests using Pyright."""
+    nox.sync(session, self=True, extras=["speedups", "server"], groups=["pyright", "pytest"])
+    session.run("pyright", config.TEST_PACKAGE)
 
 
 @nox.session()

pyproject.toml

@@ -157,9 +157,7 @@ exclude_lines = [
 ]
 
 [tool.pyright]
-include = ["hikari", "examples"]
-exclude = [
-    "examples/simple_dashboard.py",
+ignore = [
     "**/__init__.py",
     "hikari/internal/enums.py",
     "hikari/internal/fast_protocol.py",
@@ -180,6 +178,11 @@ reportUnknownMemberType = "warning"
 reportUntypedFunctionDecorator = "warning"
 reportOptionalMemberAccess = "warning"
 
+executionEnvironments = [
+  { root = "hikari" },
+  { root = "tests/hikari", reportPrivateUsage = "none" },
+]
+
 [tool.pytest.ini_options]
 xfail_strict = true
 norecursedirs = [
@@ -192,7 +195,7 @@ norecursedirs = [
     ".venv",
     "venv",
     "public",
-    "ci",
+    "pipelines",
 ]
 # Treat warnings as errors
 filterwarnings = [

tests/hikari/conftest.py

@@ -0,0 +1,159 @@
+# Copyright (c) 2020 Nekokatt
+# Copyright (c) 2021-present davfsa
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+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 traits
+from hikari import users
+
+
+@pytest.fixture
+def hikari_app() -> traits.RESTAware:
+    return mock.Mock(spec=traits.RESTAware, rest=mock.AsyncMock())
+
+
+@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_decoration=users.AvatarDecoration(
+            asset_hash="avatar_decoration_asset_hash", sku_id=snowflakes.Snowflake(999), expires_at=None
+        ),
+        avatar_hash="user_avatar_hash",
+        banner_hash="user_banner_hash",
+        accent_color=None,
+        is_bot=False,
+        is_system=False,
+        flags=users.UserFlag.NONE,
+        primary_guild=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=[],
+        poll=None,
+        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,
+        message_snapshots=[],
+        application_id=None,
+        components=[],
+        thread=None,
+        interaction_metadata=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)