- Fixed tests.

issue #283

Author: albamig

packages/plugins/minos-broker-rabbitmq/minos/plugins/rabbitmq/common.py

@@ -21,7 +21,6 @@ def with_config(self, config: Config):
         common_config = broker_config.get("common", dict())
 
         self.kwargs |= {
-            "group_id": config.get_name(),
             "host": common_config.get("host"),
             "port": common_config.get("port"),
         }

packages/plugins/minos-broker-rabbitmq/minos/plugins/rabbitmq/subscriber.py

@@ -29,6 +29,9 @@
     PostgreSqlBrokerSubscriberQueueBuilder,
     QueuedBrokerSubscriberBuilder,
 )
+from minos.plugins.rabbitmq import (
+    RabbitMQBrokerBuilderMixin,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -39,27 +42,22 @@ class RabbitMQBrokerSubscriber(BrokerSubscriber):
     def __init__(
         self,
         topics: Iterable[str],
-        broker_host: str,
-        broker_port: int,
+        host: str,
+        port: int,
         group_id: Optional[str] = None,
         remove_topics_on_destroy: bool = False,
         **kwargs,
     ):
         super().__init__(topics, **kwargs)
-        self.broker_host = broker_host
-        self.broker_port = broker_port
+        self.host = host
+        self.port = port
         self.group_id = group_id
 
         self.remove_topics_on_destroy = remove_topics_on_destroy
 
-    @classmethod
-    def _from_config(cls, config: MinosConfig, **kwargs) -> RabbitMQBrokerSubscriber:
-        # noinspection PyTypeChecker
-        return RabbitMQBrokerSubscriberBuilder.new().with_config(config).with_kwargs(kwargs).build()
-
     async def _setup(self) -> None:
         await super()._setup()
-        self.connection = await connect(f"amqp://guest:guest@{self.broker_host}:{self.broker_port}/")
+        self.connection = await connect(f"amqp://guest:guest@{self.host}:{self.port}/")
 
     async def _destroy(self) -> None:
         await self.connection.close()
@@ -76,52 +74,8 @@ async def _receive(self) -> BrokerMessage:
                     pass
 
 
-class RabbitMQBrokerSubscriberBuilder(BrokerSubscriberBuilder):
+class RabbitMQBrokerSubscriberBuilder(BrokerSubscriberBuilder[RabbitMQBrokerSubscriber], RabbitMQBrokerBuilderMixin):
     """RabbitMQ Broker Subscriber Builder class."""
 
-    def with_config(self, config: Config) -> BrokerSubscriberBuilder:
-        """Set config.
-
-        :param config: The config to be set.
-        :return: This method return the builder instance.
-        """
-        broker_config = config.get_interface_by_name("broker")
-        common_config = broker_config["common"]
-
-        self.kwargs |= {
-            "group_id": config.get_name(),
-            "broker_host": common_config["host"],
-            "broker_port": common_config["port"],
-        }
-        return self
-
-    def build(self) -> BrokerSubscriber:
-        """Build the instance.
-
-        :return: A ``RabbitMQBrokerSubscriber`` instance.
-        """
-        return RabbitMQBrokerSubscriber(**self.kwargs)
-
-
-class PostgreSqlQueuedRabbitMQBrokerSubscriberBuilder(QueuedBrokerSubscriberBuilder):
-    """PostgreSql Queued RabbitMQ Broker Subscriber Builder class."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(
-            *args,
-            impl_builder=RabbitMQBrokerSubscriberBuilder.new(),
-            queue_builder=PostgreSqlBrokerSubscriberQueueBuilder.new(),
-            **kwargs,
-        )
-
-
-class InMemoryQueuedRabbitMQBrokerSubscriberBuilder(QueuedBrokerSubscriberBuilder):
-    """In Memory Queued RabbitMQ Broker Subscriber Builder class."""
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(
-            *args,
-            impl_builder=RabbitMQBrokerSubscriberBuilder.new(),
-            queue_builder=InMemoryBrokerSubscriberQueueBuilder.new(),
-            **kwargs,
-        )
+RabbitMQBrokerSubscriber.set_builder(RabbitMQBrokerSubscriberBuilder)

packages/plugins/minos-broker-rabbitmq/tests/test_rabbitmq/test_common.py

@@ -0,0 +1,31 @@
+import unittest
+
+from minos.common import (
+    Config,
+)
+from minos.plugins.rabbitmq import (
+    RabbitMQBrokerBuilderMixin,
+)
+from tests.utils import (
+    CONFIG_FILE_PATH,
+)
+
+
+class TestRabbitMQBrokerBuilderMixin(unittest.IsolatedAsyncioTestCase):
+    def test_constructor(self):
+        mixin = RabbitMQBrokerBuilderMixin()
+
+        config = Config(CONFIG_FILE_PATH)
+        mixin.with_config(config)
+
+        common_config = config.get_interface_by_name("broker")["common"]
+
+        expected = {
+            "host": common_config["host"],
+            "port": common_config["port"],
+        }
+        self.assertEqual(expected, mixin.kwargs)
+
+
+if __name__ == "__main__":
+    unittest.main()

packages/plugins/minos-broker-rabbitmq/tests/test_rabbitmq/test_publisher.py

@@ -10,12 +10,8 @@
     BrokerMessageV1,
     BrokerMessageV1Payload,
     BrokerPublisher,
-    InMemoryBrokerPublisherQueue,
-    PostgreSqlBrokerPublisherQueue,
 )
 from minos.plugins.rabbitmq import (
-    InMemoryQueuedRabbitMQBrokerPublisher,
-    PostgreSqlQueuedRabbitMQBrokerPublisher,
     RabbitMQBrokerPublisher,
 )
 from tests.utils import (
@@ -34,8 +30,8 @@ def test_from_config(self):
         publisher = RabbitMQBrokerPublisher.from_config(config)
 
         self.assertIsInstance(publisher, RabbitMQBrokerPublisher)
-        self.assertEqual(broker_config["host"], publisher.broker_host)
-        self.assertEqual(broker_config["port"], publisher.broker_port)
+        self.assertEqual(broker_config["host"], publisher.host)
+        self.assertEqual(broker_config["port"], publisher.port)
 
     @patch("minos.plugins.rabbitmq.publisher.connect")
     async def test_send(self, connect_mock):
@@ -54,21 +50,5 @@ async def test_destroy(self, destroy_mock):
             self.assertEqual(1, destroy_mock.call_count)
 
 
-class TestPostgreSqlQueuedRabbitMQBrokerPublisher(unittest.IsolatedAsyncioTestCase):
-    def test_from_config(self):
-        publisher = PostgreSqlQueuedRabbitMQBrokerPublisher.from_config(CONFIG_FILE_PATH)
-        self.assertIsInstance(publisher, PostgreSqlQueuedRabbitMQBrokerPublisher)
-        self.assertIsInstance(publisher.impl, RabbitMQBrokerPublisher)
-        self.assertIsInstance(publisher.queue, PostgreSqlBrokerPublisherQueue)
-
-
-class TestInMemoryQueuedRabbitMQBrokerPublisher(unittest.IsolatedAsyncioTestCase):
-    def test_from_config(self):
-        publisher = InMemoryQueuedRabbitMQBrokerPublisher.from_config(CONFIG_FILE_PATH)
-        self.assertIsInstance(publisher, InMemoryQueuedRabbitMQBrokerPublisher)
-        self.assertIsInstance(publisher.impl, RabbitMQBrokerPublisher)
-        self.assertIsInstance(publisher.queue, InMemoryBrokerPublisherQueue)
-
-
 if __name__ == "__main__":
     unittest.main()

packages/plugins/minos-broker-rabbitmq/tests/test_rabbitmq/test_subscriber.py

@@ -11,13 +11,8 @@
 )
 from minos.networks import (
     BrokerSubscriber,
-    InMemoryBrokerSubscriberQueue,
-    PostgreSqlBrokerSubscriberQueue,
-    QueuedBrokerSubscriber,
 )
 from minos.plugins.rabbitmq import (
-    InMemoryQueuedRabbitMQBrokerSubscriberBuilder,
-    PostgreSqlQueuedRabbitMQBrokerSubscriberBuilder,
     RabbitMQBrokerSubscriber,
     RabbitMQBrokerSubscriberBuilder,
 )
@@ -36,9 +31,8 @@ async def test_from_config(self):
         config = Config(CONFIG_FILE_PATH)
         broker_config = config.get_interface_by_name("broker")["common"]
         async with RabbitMQBrokerSubscriber.from_config(config, topics={"foo", "bar"}) as subscriber:
-            self.assertEqual(broker_config["host"], subscriber.broker_host)
-            self.assertEqual(broker_config["port"], subscriber.broker_port)
-            self.assertEqual(config.get_name(), subscriber.group_id)
+            self.assertEqual(broker_config["host"], subscriber.host)
+            self.assertEqual(broker_config["port"], subscriber.port)
             self.assertEqual(False, subscriber.remove_topics_on_destroy)
             self.assertEqual({"foo", "bar"}, subscriber.topics)
 
@@ -60,9 +54,8 @@ def test_with_config(self):
         common_config = self.config.get_interface_by_name("broker")["common"]
 
         expected = {
-            "group_id": self.config.get_name(),
-            "broker_host": common_config["host"],
-            "broker_port": common_config["port"],
+            "host": common_config["host"],
+            "port": common_config["port"],
         }
         self.assertEqual(expected, builder.kwargs)
 
@@ -73,34 +66,8 @@ def test_build(self):
 
         self.assertIsInstance(subscriber, RabbitMQBrokerSubscriber)
         self.assertEqual({"one", "two"}, subscriber.topics)
-        self.assertEqual(common_config["host"], subscriber.broker_host)
-        self.assertEqual(common_config["port"], subscriber.broker_port)
-
-
-class TestPostgreSqlQueuedRabbitMQBrokerSubscriberBuilder(unittest.TestCase):
-    def setUp(self) -> None:
-        self.config = Config(CONFIG_FILE_PATH)
-
-    def test_build(self):
-        builder = PostgreSqlQueuedRabbitMQBrokerSubscriberBuilder().with_config(self.config).with_topics({"one", "two"})
-        subscriber = builder.build()
-
-        self.assertIsInstance(subscriber, QueuedBrokerSubscriber)
-        self.assertIsInstance(subscriber.impl, RabbitMQBrokerSubscriber)
-        self.assertIsInstance(subscriber.queue, PostgreSqlBrokerSubscriberQueue)
-
-
-class TestInMemoryQueuedRabbitMQBrokerSubscriberBuilder(unittest.TestCase):
-    def setUp(self) -> None:
-        self.config = Config(CONFIG_FILE_PATH)
-
-    def test_build(self):
-        builder = InMemoryQueuedRabbitMQBrokerSubscriberBuilder().with_config(self.config).with_topics({"one", "two"})
-        subscriber = builder.build()
-
-        self.assertIsInstance(subscriber, QueuedBrokerSubscriber)
-        self.assertIsInstance(subscriber.impl, RabbitMQBrokerSubscriber)
-        self.assertIsInstance(subscriber.queue, InMemoryBrokerSubscriberQueue)
+        self.assertEqual(common_config["host"], subscriber.host)
+        self.assertEqual(common_config["port"], subscriber.port)
 
 
 if __name__ == "__main__":