simcord 2.0.0__tar.gz → 2.0.2__tar.gz

{simcord-2.0.0 → simcord-2.0.2}/CHANGELOG.md

@@ -4,6 +4,22 @@ This changelog is generated with [towncrier](https://towncrier.readthedocs.io/).
 
 <!-- towncrier release notes start -->
 
+## 2.0.2 (2026-09-18)
+
+### Bug fixes
+
+- Fixed ``create_role`` leaving stale ``Role.position`` values in the bot's cache: inserting a role bumps every existing role's position, and the backend now announces each shift with ``GUILD_ROLE_UPDATE`` after ``GUILD_ROLE_CREATE``, as real Discord does. ``Member.top_role``, ``Role`` comparisons, and hierarchy checks now see the true ordering after role creation.
+- Fixed ``role.colour`` always reading ``0`` in the bot's cache: role payloads now carry the ``colors`` object (``primary_color``/``secondary_color``/``tertiary_color``) that discord.py reads, alongside the deprecated flat ``color`` field.
+- Fixed guild role listings to match real Discord's ordering: ``GET``/``PATCH /guilds/{id}/roles`` responses and the ``roles`` array inside guild payloads (``GUILD_CREATE``/``GUILD_UPDATE`` events and guild REST responses) are now sorted by role id ascending instead of insertion order (observable when a guild is created with an explicit id, which can make ``@everyone``'s snowflake the largest).
+
+
+## 2.0.1 (2026-09-10)
+
+### Bug fixes
+
+- Fixed a 2.0.0 crash where ``Env.start()`` raised ``ValueError: ... was created in a different Context`` whenever ``setup_hook`` suspended on a timer or socket — for example opening a database pool with ``asyncpg.create_pool``, the documented discord.py startup pattern. Task resumption callbacks are now scheduled in the task's own ``Context`` instead of a copy, so ``ContextVar`` tokens created before a suspension remain valid after it. ([#24](https://github.com/SilentHacks/simcord/issues/24))
+
+
 ## 2.0.0 (2026-09-08)
 
 ### Features

{simcord-2.0.0 → simcord-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simcord
-Version: 2.0.0
+Version: 2.0.2
 Summary: Offline discord.py bot testing with pytest. No network, token, or test server.
 Project-URL: Homepage, https://github.com/SilentHacks/simcord
 Project-URL: Documentation, https://simcord.readthedocs.io/

{simcord-2.0.0 → simcord-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simcord"
-version = "2.0.0"
+version = "2.0.2"
 description = "Offline discord.py bot testing with pytest. No network, token, or test server."
 readme = "README.md"
 license = "MIT"

{simcord-2.0.0 → simcord-2.0.2}/src/simcord/backend/ops/guilds.py

@@ -180,9 +180,23 @@ class GuildMixin(BackendBase):
 
     # ----------------------------------------------------------------- roles
 
+    def announce_role_updates(self, guild_id: int, roles: Iterable[Role]) -> None:
+        """Announce each role's current state with GUILD_ROLE_UPDATE.
+
+        Real Discord emits an update for every role whose position changed as a
+        side effect of another operation; without them a client's cache keeps
+        stale positions, so position-driven mutations must announce their shifts.
+        """
+        for role in list(roles):
+            self.emit(
+                "GUILD_ROLE_UPDATE",
+                {"guild_id": str(guild_id), "role": serializers.role_payload(role)},
+            )
+
     def create_role(self, guild_id: int, name: str, *, permissions: int = 0, **fields: Any) -> Role:
         guild = self.get_guild(guild_id)
         position = fields.pop("position", None)
+        shifted: list[Role] = []
         if position is None:
             # New roles insert just above @everyone, pushing existing roles up
             # (so the bot's integration role stays on top), as on real Discord.
@@ -190,6 +204,7 @@ class GuildMixin(BackendBase):
             for existing in guild.roles.values():
                 if existing.position >= 1:
                     existing.position += 1
+                    shifted.append(existing)
         role = Role(
             id=self.snowflake(),
             name=name,
@@ -202,6 +217,7 @@ class GuildMixin(BackendBase):
             "GUILD_ROLE_CREATE",
             {"guild_id": str(guild_id), "role": serializers.role_payload(role)},
         )
+        self.announce_role_updates(guild_id, shifted)
         return role
 
     def edit_role(self, guild_id: int, role_id: int, changes: Mapping[str, Any]) -> Role:
@@ -229,10 +245,7 @@ class GuildMixin(BackendBase):
             if role.position != new_position:
                 role.position = new_position
                 changed.append(role)
-        for role in changed:
-            self.emit(
-                "GUILD_ROLE_UPDATE", {"guild_id": str(guild_id), "role": serializers.role_payload(role)}
-            )
+        self.announce_role_updates(guild_id, changed)
         return guild
 
     def delete_role(self, guild_id: int, role_id: int) -> None:

{simcord-2.0.0 → simcord-2.0.2}/src/simcord/backend/serializers.py

@@ -88,6 +88,11 @@ def role_payload(role: Role) -> role_types.Role:
             "permissions": str(role.permissions),
             "position": role.position,
             "color": role.color,
+            "colors": {
+                "primary_color": role.color,
+                "secondary_color": None,
+                "tertiary_color": None,
+            },
             "hoist": role.hoist,
             "managed": role.managed,
             "mentionable": role.mentionable,
@@ -98,6 +103,12 @@ def role_payload(role: Role) -> role_types.Role:
     )
 
 
+def roles_payload(guild: Guild) -> list[role_types.Role]:
+    # Discord serves a guild's role list sorted by role id ascending (the
+    # @everyone role shares the guild id, so it can sort anywhere).
+    return [role_payload(r) for r in sorted(guild.roles.values(), key=lambda r: r.id)]
+
+
 def member_payload(
     backend: BackendBase, guild: Guild, member: Member, *, with_user: bool = True
 ) -> member_types.MemberWithUser:
@@ -355,7 +366,7 @@ def guild_create_payload(backend: BackendBase, guild: Guild) -> guild_types.Guil
             "features": [],
             "emojis": [guild_emoji_payload(backend, e) for e in guild.emojis.values()],
             "stickers": [sticker_payload(backend, s) for s in guild.stickers.values()],
-            "roles": [role_payload(r) for r in guild.roles.values()],
+            "roles": roles_payload(guild),
             "member_count": len(guild.members),
             "large": False,
             "unavailable": False,

{simcord-2.0.0 → simcord-2.0.2}/src/simcord/env.py

@@ -272,6 +272,11 @@ class Env:
     ) -> asyncio.Handle:
         bound_task = getattr(callback, "__self__", None)
         if isinstance(bound_task, asyncio.Task):
+            # A task resumption callback (__step/__wakeup) must run in the exact
+            # Context the task was scheduled with — scheduling a copy resumes the
+            # coroutine in a different Context object, where ContextVar.reset of
+            # a pre-suspension token raises "created in a different Context".
+            # Ownership is already carried by the task's own context.
             owner_record = self._task_records.get(bound_task)
             scope = (
                 (self, owner_record.generation)
@@ -280,9 +285,10 @@ class Env:
                 if context is not None
                 else None
             )
+            schedule_context = context
         else:
             scope = _BOT_SCOPE.get()
-        schedule_context = self._context_for_scope(context, scope) if context is not None else context
+            schedule_context = self._context_for_scope(context, scope) if context is not None else context
         if scope is None or scope[0] is not self:
             return original(*schedule_args, callback, *args, context=schedule_context)
         label = getattr(callback, "__qualname__", None) or getattr(

{simcord-2.0.0 → simcord-2.0.2}/src/simcord/http/routes/guilds.py

@@ -640,7 +640,7 @@ def delete_role(ctx: RequestContext) -> Any:
 @route("GET", "/guilds/{guild_id}/roles")
 def get_roles(ctx: RequestContext) -> Any:
     guild = ctx.backend.get_guild(ctx.int_arg("guild_id"))
-    return [dict(serializers.role_payload(r)) for r in guild.roles.values()]
+    return [dict(r) for r in serializers.roles_payload(guild)]
 
 
 @route("GET", "/guilds/{guild_id}/roles/{role_id}")
@@ -668,4 +668,4 @@ def move_role_positions(ctx: RequestContext) -> Any:
         backend.require_role_assignable(guild_id, bot_id, int(item["id"]))
         backend.require_position_assignable(guild_id, bot_id, int(item["position"]))
     guild = backend.reorder_roles(guild_id, positions)
-    return [dict(serializers.role_payload(r)) for r in guild.roles.values()]
+    return [dict(r) for r in serializers.roles_payload(guild)]

{simcord-2.0.0 → simcord-2.0.2}/tests/integration/test_edge_cases.py

@@ -69,7 +69,12 @@ async def test_role_reorder_changes_positions(env):
     await env.settle()
 
     assert env.backend.get_role(env.guild.id, low.id).position == high_pos
-    assert "GUILD_ROLE_UPDATE" in env.transcript()
+    # The reorder itself announced the moved role (create_role updates alone
+    # would leave this assertion passing otherwise).
+    assert any(
+        name == "GUILD_ROLE_UPDATE" and payload["role"]["id"] == str(low.id)
+        for _, name, payload in env.backend.transcript
+    )
 
 
 async def test_second_stage_instance_rejected(env):

{simcord-2.0.0 → simcord-2.0.2}/tests/integration/test_roles_and_ordering.py

@@ -54,6 +54,81 @@ async def test_edit_role_positions(env):
     assert guild.get_role(low.id).position == high_pos
 
 
+async def test_create_role_announces_position_shifts(env):
+    guild = env.bot.get_guild(env.guild.id)
+    await guild.create_role(name="admin")
+    await guild.create_role(name="mod")
+    await env.settle()
+
+    # Each create inserts at position 1 and bumps every existing role up; the
+    # backend announces each shift with GUILD_ROLE_UPDATE (after the create, as
+    # real Discord does), so every cached position matches the backend's.
+    backend_guild = env.backend.get_guild(env.guild.id)
+    for backend_role in backend_guild.roles.values():
+        cached = guild.get_role(backend_role.id)
+        assert cached is not None
+        assert cached.position == backend_role.position
+    assert backend_guild.roles[guild.id].position == 0
+
+    # Each create lands first, then the shift updates it caused.
+    role_events = [
+        (name, payload["role"]["name"])
+        for _, name, payload in env.backend.transcript
+        if name in ("GUILD_ROLE_CREATE", "GUILD_ROLE_UPDATE")
+    ]
+    assert role_events[:2] == [("GUILD_ROLE_CREATE", "admin"), ("GUILD_ROLE_UPDATE", "TestBot")]
+    assert role_events[2] == ("GUILD_ROLE_CREATE", "mod")
+    assert all(name == "GUILD_ROLE_UPDATE" for name, _ in role_events[3:])
+
+    # The bot's managed role rides on top of the hierarchy, so hierarchy checks
+    # like "bot must outrank target" see a true ordering.
+    assert guild.me.top_role.position == max(r.position for r in backend_guild.roles.values())
+
+
+async def test_delete_role_leaves_position_gap(env):
+    guild = env.bot.get_guild(env.guild.id)
+    low = await guild.create_role(name="low")
+    mid = await guild.create_role(name="mid")
+    await env.settle()
+
+    await mid.delete()
+    await env.settle()
+
+    # Discord does not renumber positions on delete: the hole at 1 stays a hole.
+    assert env.backend.get_role(guild.id, low.id).position == 2
+    assert guild.get_role(low.id).position == 2
+
+
+async def test_role_colour_reaches_the_cache(env):
+    guild = env.bot.get_guild(env.guild.id)
+    role = await guild.create_role(name="Tinted", colour=discord.Colour(0x112233))
+    await env.settle()
+
+    # discord.py reads the role "colors" object (primary/secondary/tertiary);
+    # the deprecated flat "color" field alone leaves every cached colour at 0.
+    assert role.colour == discord.Colour(0x112233)
+    cached = guild.get_role(role.id)
+    assert cached.colour == discord.Colour(0x112233)
+    assert cached.secondary_colour is None
+
+
+async def test_guild_roles_list_sorted_by_id(env):
+    odd = env.create_guild("Odd", id=8_000_000_000_000_000_000)
+    await env.settle()
+    guild = env.bot.get_guild(odd.id)
+    await guild.create_role(name="one")
+    await guild.create_role(name="two")
+    await env.settle()
+
+    # Real Discord returns a guild's roles sorted by id ascending — with an
+    # explicit guild id the @everyone role's snowflake is the largest, so
+    # insertion order alone would wrongly put it first.
+    fetched = await guild.fetch_roles()
+    ids = [r.id for r in fetched]
+    assert ids == sorted(ids)
+    assert ids[-1] == odd.id
+
+
 async def test_reorder_cannot_lift_role_above_bot(env):
     guild = env.bot.get_guild(env.guild.id)
     role = await guild.create_role(name="Climber")

simcord-2.0.2/tests/integration/test_setup_hook_suspension.py

@@ -0,0 +1,107 @@
+"""setup_hook may suspend on timers and sockets — e.g. opening a DB pool.
+
+Regression tests for the 2.0.0 crash where ``Env.start()`` raised
+``ValueError: ... was created in a different Context``: task resumption
+callbacks were scheduled under a copied ``Context``, so a suspended
+``setup_hook`` resumed in a different ``Context`` object and the
+``_bot_scope`` ``ContextVar.reset`` became invalid.
+"""
+
+import asyncio
+import contextvars
+
+import pytest
+from discord.ext import commands
+
+import simcord
+from fixtures.sample_bot import create_bot
+
+
+def _suspending_bot(suspend) -> commands.Bot:
+    """A sample bot whose setup_hook suspends via ``suspend`` first."""
+    bot = create_bot()
+    original_setup = bot.setup_hook
+
+    async def setup_hook() -> None:
+        await suspend()
+        await original_setup()
+
+    bot.setup_hook = setup_hook
+    return bot
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("delay", [0, 0.01])
+async def test_setup_hook_may_suspend_on_timers(delay: float):
+    bot = _suspending_bot(lambda: asyncio.sleep(delay))
+    async with simcord.run(bot) as env:
+        guild = env.create_guild()
+        alice = guild.add_member(env.create_user("alice"))
+        channel = guild.create_text_channel("general")
+        await alice.send(channel, "!ping")
+        assert channel.last_message is not None
+        assert channel.last_message.content == "Pong!"
+
+
+@pytest.mark.asyncio
+async def test_setup_hook_may_suspend_on_a_socket():
+    received: list[bytes] = []
+
+    async def echo(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        received.append(await reader.read(4))
+        writer.write(b"pong")
+        await writer.drain()
+        writer.close()
+
+    server = await asyncio.start_server(echo, "127.0.0.1", 0)
+    try:
+        port = server.sockets[0].getsockname()[1]
+
+        async def open_pool_like() -> None:
+            reader, writer = await asyncio.open_connection("127.0.0.1", port)
+            writer.write(b"ping")
+            await writer.drain()
+            assert await reader.read(4) == b"pong"
+            writer.close()
+            await writer.wait_closed()
+
+        bot = _suspending_bot(open_pool_like)
+        async with simcord.run(bot) as env:
+            env.create_guild()
+    finally:
+        server.close()
+        await server.wait_closed()
+    assert received == [b"ping"]
+
+
+@pytest.mark.asyncio
+async def test_user_contextvar_survives_setup_hook_suspension():
+    """A user ContextVar behaves as if setup_hook never left its own Context:
+    a value set before an await is visible after it, and a value set after an
+    await survives the next suspension (a copied resumption context would lose it)."""
+    var: contextvars.ContextVar[str] = contextvars.ContextVar("simcord_test_var")
+    observations: list[str] = []
+    bot = create_bot()
+    original_setup = bot.setup_hook
+
+    async def setup_hook() -> None:
+        var.set("before-await")
+        await asyncio.sleep(0.01)
+        observations.append(var.get())
+        var.set("after-await")
+        await asyncio.sleep(0.01)
+        observations.append(var.get())
+        await original_setup()
+
+    bot.setup_hook = setup_hook
+    async with simcord.run(bot):
+        pass
+    assert observations == ["before-await", "after-await"]
+
+
+@pytest.mark.asyncio
+async def test_restart_bot_with_suspending_setup_hook(env, channel, alice):
+    await env.restart_bot(_suspending_bot(lambda: asyncio.sleep(0.01)))
+    await alice.send(channel, "!ping")
+    assert channel.last_message is not None
+    assert channel.last_message.content == "Pong!"

{simcord-2.0.0 → simcord-2.0.2}/uv.lock

@@ -1402,7 +1402,7 @@ wheels = [
 
 [[package]]
 name = "simcord"
-version = "2.0.0"
+version = "2.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "discord-py" },