Ignore messages with other topics in handle_msg

Author: thatbudakguy

mqterm/terminal.py

@@ -64,8 +64,13 @@ async def disconnect(self):
         """Stop processing messages in the input stream."""
         await self.mqtt_client.unsubscribe(self.in_topic)
 
-    async def handle_msg(self, _topic, msg, properties={}):
+    async def handle_msg(self, topic, msg, properties={}):
         """Process a single MQTT message and apply to the appropriate job."""
+        topic = topic.decode("utf-8")
+        if not topic.startswith(self.in_topic):
+            self.logger.debug(f"Terminal received message on {topic}; ignoring")
+            return
+
         client_id = parse_client_id(properties)
         seq = parse_seq(properties)
         try:

tests/test_terminal.py

@@ -31,7 +31,7 @@ def output(self):
 
 class TestMqttTerminal(TestCase):
     def setUp(self):
-        self.in_topic = "/tty/in"
+        self.in_topic = b"/tty/in"
         self.mqtt_client = Mock()
         self.mqtt_client.publish = Mock()
         self.term = MqttTerminal(self.mqtt_client)
@@ -64,6 +64,16 @@ def test_handle_msg_bad_seq(self):
                 self.term.handle_msg(self.in_topic, payload.encode("utf-8"), props)
             )
 
+    def test_handle_msg_wrong_topic(self):
+        """MqttTerminal should ignore messages on wrong topic"""
+        payload = "get_file file.txt"
+        topic = b"/wrong/topic"
+        self.term.update_job = AsyncMock()
+        asyncio.run(
+            self.term.handle_msg(topic, payload.encode("utf-8"), format_properties("localhost", -1))
+        )
+        self.term.update_job.assert_not_awaited()
+
     def test_handle_msg(self):
         """MqttTerminal should parse MQTT messages to update jobs"""
         self.term.update_job = AsyncMock()

tests/utils.py

@@ -14,7 +14,16 @@ def __init__(self):
     def __call__(self, *args, **kwargs):
         self._calls.append(call(*args, **kwargs))
 
+    def assert_called(self):
+        """Assert that the mock was called at least once."""
+        assert len(self._calls) > 0, "Expected mock to be called, but it was not."
+
+    def assert_not_called(self):
+        """Assert that the mock was not called."""
+        assert len(self._calls) == 0, "Expected mock to not be called, but it was."
+
     def assert_called_with(self, *args, **kwargs):
+        """Assert that the mock was last called with the given arguments."""
         # First call should be self, so we prepend it
         expected_args = [self] + list(args)
         expectation = call(*expected_args, **kwargs)
@@ -24,15 +33,31 @@ def assert_called_with(self, *args, **kwargs):
             expectation, self._calls[-1]
         )
 
+    def assert_has_calls(self, calls):
+        """Assert that the mock has the expected calls with arguments."""
+        assert self._calls == calls, "Expected calls {}, got {}".format(
+            calls, self._calls
+        )
+
 
 class AsyncMock(Mock):
     """An async version of Mock that can be awaited."""
 
     async def __call__(self, *args, **kwargs):
         return super().__call__(self, *args, **kwargs)
 
+    def assert_awaited(self):
+        """Assert that the async mock was awaited at least once."""
+        return super().assert_called()
+
+    def assert_not_awaited(self):
+        """Assert that the async mock was not awaited."""
+        return super().assert_not_called()
+
     def assert_awaited_with(self, *args, **kwargs):
+        """Assert that the async mock was last awaited with the given arguments."""
         return super().assert_called_with(*args, **kwargs)
 
     def assert_has_awaits(self, awaits):
-        assert self._calls == awaits
+        """Assert that the async mock has the expected awaits with arguments."""
+        return super().assert_has_calls(awaits)