simcord 2.0.1__tar.gz → 2.0.2__tar.gz

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

@@ -4,6 +4,15 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simcord
-Version: 2.0.1
+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.1 → simcord-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simcord"
-version = "2.0.1"
+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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → simcord-2.0.2}/uv.lock

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