fix: consistent hashing and equality for RabbitMQ schemas

Author: RinZ27

faststream/rabbit/schemas/channel.py

@@ -29,4 +29,10 @@ class Channel:
     when mandatory message will be returned"""
 
     def __hash__(self) -> int:
-        return id(self)
+        return hash((
+            self.prefetch_count,
+            self.global_qos,
+            self.channel_number,
+            self.publisher_confirms,
+            self.on_return_raises,
+        ))

faststream/rabbit/schemas/exchange.py

@@ -34,15 +34,29 @@ def __repr__(self) -> str:
 
         return f"{self.__class__.__name__}({self.name}, type={self.type}, routing_key='{self.routing()}'{body})"
 
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, RabbitExchange):
+            return NotImplemented
+
+        return (
+            self.name == value.name
+            and self.type == value.type
+            and self.routing_key == value.routing_key
+            and self.durable == value.durable
+            and self.auto_delete == value.auto_delete
+            and self.arguments == value.arguments
+        )
+
     def __hash__(self) -> int:
         """Supports hash to store real objects in declarer."""
-        return sum(
+        return hash(
             (
-                hash(self.name),
-                hash(self.type),
-                hash(self.routing_key),
-                int(self.durable),
-                int(self.auto_delete),
+                self.name,
+                self.type,
+                self.routing_key,
+                self.durable,
+                self.auto_delete,
+                frozenset((self.arguments or {}).items()),
             ),
         )
 

faststream/rabbit/schemas/queue.py

@@ -54,14 +54,27 @@ def __repr__(self) -> str:
 
         return f"{self.__class__.__name__}({self.name}{body})"
 
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, RabbitQueue):
+            return NotImplemented
+
+        return (
+            self.name == value.name
+            and self.durable == value.durable
+            and self.exclusive == value.exclusive
+            and self.auto_delete == value.auto_delete
+            and self.arguments == value.arguments
+        )
+
     def __hash__(self) -> int:
         """Supports hash to store real objects in declarer."""
-        return sum(
+        return hash(
             (
-                hash(self.name),
-                int(self.durable),
-                int(self.exclusive),
-                int(self.auto_delete),
+                self.name,
+                self.durable,
+                self.exclusive,
+                self.auto_delete,
+                frozenset((self.arguments or {}).items()),
             ),
         )
 

faststream/rabbit/testing.py

@@ -293,7 +293,9 @@ def _is_handler_matches(
     headers = headers or {}
     exchange = RabbitExchange.validate(exchange)
 
-    if handler.exchange != exchange:
+    if (handler.exchange.name if handler.exchange else None) != (
+        exchange.name if exchange else None
+    ):
         return False
 
     if handler.exchange is None or handler.exchange.type == ExchangeType.DIRECT:

tests/brokers/rabbit/specific/test_channels.py

@@ -12,7 +12,7 @@ async def test_subscriber_use_shared_channel() -> None:
     broker = RabbitBroker(logger=None)
 
     sub1 = broker.subscriber(uuid4().hex)
-    sub2 = broker.subscriber(uuid4().hex, channel=Channel())
+    sub2 = broker.subscriber(uuid4().hex, channel=Channel(prefetch_count=1))
 
     shared_channel = Channel()
     sub3 = broker.subscriber(uuid4().hex, channel=shared_channel)

tests/brokers/rabbit/test_schemas.py

@@ -1,6 +1,6 @@
 import pytest
 
-from faststream.rabbit import RabbitQueue
+from faststream.rabbit import Channel, RabbitExchange, RabbitQueue
 
 
 @pytest.mark.rabbit()
@@ -23,3 +23,50 @@ def test_different_queue_routing_key() -> None:
         })
         == 1
     )
+
+
+@pytest.mark.rabbit()
+def test_different_queue_params() -> None:
+    assert (
+        len({
+            RabbitQueue("test", durable=True): 0,
+            RabbitQueue("test", durable=False): 1,
+        })
+        == 2
+    )
+
+
+@pytest.mark.rabbit()
+def test_exchange_equality() -> None:
+    assert (
+        len({
+            RabbitExchange("test", durable=True): 0,
+            RabbitExchange("test", durable=True): 1,
+        })
+        == 1
+    )
+    assert (
+        len({
+            RabbitExchange("test", durable=True): 0,
+            RabbitExchange("test", durable=False): 1,
+        })
+        == 2
+    )
+
+
+@pytest.mark.rabbit()
+def test_channel_equality() -> None:
+    assert (
+        len({
+            Channel(prefetch_count=10): 0,
+            Channel(prefetch_count=10): 1,
+        })
+        == 1
+    )
+    assert (
+        len({
+            Channel(prefetch_count=10): 0,
+            Channel(prefetch_count=20): 1,
+        })
+        == 2
+    )