77 multiple commands from a single message

tests/adapters/interpreters/wrappers/test_splitting_interpreter.py

@@ -0,0 +1,142 @@
+from typing import AnyStr, AsyncIterable, List, Tuple
+
+import pytest
+from mock import ANY, AsyncMock, call, patch
+
+from tickit.adapters.interpreters.utils import wrap_as_async_iterable
+from tickit.adapters.interpreters.wrappers import SplittingInterpreter
+from tickit.core.adapter import Adapter
+
+
+async def dummy_response(msg: AnyStr) -> Tuple[AsyncIterable[AnyStr], bool]:
+    return wrap_as_async_iterable(msg), True
+
+
+class DummySplittingInterpreter(SplittingInterpreter):
+    """SplittingInterpreter with dummy implementation of abstract method."""
+
+    async def _handle_individual_messages(
+        self, adapter: Adapter, individual_messages: List[AnyStr]
+    ) -> List[Tuple[AsyncIterable[AnyStr], bool]]:
+        return [await dummy_response(msg) for msg in individual_messages]
+
+
+async def _test_sub_messages(
+    splitting_interpreter: DummySplittingInterpreter,
+    mock_handle_individual_messages: AsyncMock,
+    mock_get_response: AsyncMock,
+    test_message: AnyStr,
+    expected_sub_messages: List[AnyStr],
+):
+    mock_get_response.return_value = await dummy_response(test_message)
+    await splitting_interpreter.handle(AsyncMock(), test_message)
+    mock_handle_individual_messages.assert_called_once_with(ANY, expected_sub_messages)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "test_message, delimiter, expected_sub_messages",
+    [
+        ("test message", " ", ["test", "message"]),
+        (b"foo/bar", b"/", [b"foo", b"bar"]),
+        ("single message", "/", ["single message"]),
+    ],
+)
+@patch.object(
+    DummySplittingInterpreter, "_get_response_and_interrupt_from_individual_results"
+)
+@patch.object(DummySplittingInterpreter, "_handle_individual_messages")
+async def test_handle_passes_on_correct_sub_messages(
+    mock_handle_individual_messages: AsyncMock,
+    mock_get_response: AsyncMock,
+    test_message: AnyStr,
+    delimiter: AnyStr,
+    expected_sub_messages: List[AnyStr],
+):
+    splitting_interpreter = DummySplittingInterpreter(AsyncMock(), delimiter)
+
+    await _test_sub_messages(
+        splitting_interpreter,
+        mock_handle_individual_messages,
+        mock_get_response,
+        test_message,
+        expected_sub_messages,
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "test_message, expected_sub_messages",
+    [
+        (b"test message", [b"test", b"message"]),
+        (b"foo/bar", [b"foo/bar"]),
+    ],
+)
+@patch.object(
+    DummySplittingInterpreter, "_get_response_and_interrupt_from_individual_results"
+)
+@patch.object(DummySplittingInterpreter, "_handle_individual_messages")
+async def test_handle_passes_on_correct_sub_messages_with_default_delimiter(
+    mock_handle_individual_messages: AsyncMock,
+    mock_get_response: AsyncMock,
+    test_message: AnyStr,
+    expected_sub_messages: List[AnyStr],
+):
+    splitting_interpreter = DummySplittingInterpreter(AsyncMock())
+
+    await _test_sub_messages(
+        splitting_interpreter,
+        mock_handle_individual_messages,
+        mock_get_response,
+        test_message,
+        expected_sub_messages,
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("sub_messages", [["one", "two", "three"], ["test", "message"]])
+async def test_handle_individual_messages_makes_correct_handle_calls(sub_messages):
+    mock_interpreter = AsyncMock()
+    splitting_interpreter = SplittingInterpreter(mock_interpreter)
+    await splitting_interpreter._handle_individual_messages(AsyncMock(), sub_messages)
+    mock_handle_calls = mock_interpreter.handle.mock_calls
+    assert mock_handle_calls == [call(ANY, msg) for msg in sub_messages]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    [
+        "individual_messages",
+        "individual_interrupts",
+        "expected_combined_message",
+        "expected_combined_interrupt",
+    ],
+    [
+        (["one", "two"], [False, False], "onetwo", False),
+        (["three", "four"], [False, True], "threefour", True),
+        (["five", "six"], [True, True], "fivesix", True),
+    ],
+)
+@patch(
+    "tickit.adapters.interpreters.wrappers.splitting_interpreter.wrap_as_async_iterable"
+)
+async def test_individual_results_combined_correctly(
+    mock_wrap_message: AsyncMock,
+    individual_messages: List[AnyStr],
+    individual_interrupts: List[bool],
+    expected_combined_message: AnyStr,
+    expected_combined_interrupt: bool,
+):
+    splitting_interpreter = DummySplittingInterpreter(AsyncMock(), " ")
+    individual_results = [
+        (wrap_as_async_iterable(msg), interrupt)
+        for msg, interrupt in zip(individual_messages, individual_interrupts)
+    ]
+    (
+        _,
+        combined_interrupt,
+    ) = await splitting_interpreter._get_response_and_interrupt_from_individual_results(
+        individual_results
+    )
+    mock_wrap_message.assert_called_once_with(expected_combined_message)
+    assert combined_interrupt == expected_combined_interrupt

tickit/adapters/interpreters/command/command_interpreter.py

@@ -2,6 +2,7 @@
 from inspect import getmembers
 from typing import AnyStr, AsyncIterable, Optional, Sequence, Tuple, get_type_hints
 
+from tickit.adapters.interpreters.utils import wrap_as_async_iterable
 from tickit.core.adapter import Adapter, Interpreter
 from tickit.utils.compat.typing_compat import Protocol, runtime_checkable
 
@@ -39,19 +40,6 @@ class CommandInterpreter(Interpreter[AnyStr]):
     called with the parsed arguments.
     """
 
-    @staticmethod
-    async def _wrap(reply: AnyStr) -> AsyncIterable[AnyStr]:
-        """Wraps the reply in an asynchronous iterable.
-
-        Args:
-            response (AnyStr): A singular reply message.
-
-        Returns:
-            AsyncIterable[AnyStr]: An asynchronous iterable containing the reply
-                message.
-        """
-        yield reply
-
     @staticmethod
     async def unknown_command() -> AsyncIterable[bytes]:
         """An asynchronous iterable of containing a single unknown command reply.
@@ -96,7 +84,7 @@ async def handle(
             )
             resp = await method(*args)
             if not isinstance(resp, AsyncIterable):
-                resp = CommandInterpreter._wrap(resp)
+                resp = wrap_as_async_iterable(resp)
             return resp, command.interrupt
         resp = CommandInterpreter.unknown_command()
         return resp, False

tickit/adapters/interpreters/utils.py

@@ -0,0 +1,13 @@
+from typing import AnyStr, AsyncIterable
+
+
+async def wrap_as_async_iterable(message: AnyStr) -> AsyncIterable[AnyStr]:
+    """Wraps a message in an asynchronous iterable.
+
+    Args:
+        message (AnyStr): A singular message.
+
+    Returns:
+        AsyncIterable[AnyStr]: An asynchronous iterable containing the message.
+    """
+    yield message

tickit/adapters/interpreters/wrappers/__init__.py

@@ -0,0 +1,5 @@
+from tickit.adapters.interpreters.wrappers.splitting_interpreter import (
+    SplittingInterpreter,
+)
+
+__all__ = ["SplittingInterpreter"]

tickit/adapters/interpreters/wrappers/splitting_interpreter.py

@@ -0,0 +1,110 @@
+import functools
+from typing import AnyStr, AsyncIterable, List, Tuple, overload
+
+from tickit.adapters.interpreters.utils import wrap_as_async_iterable
+from tickit.core.adapter import Adapter, Interpreter
+
+
+class SplittingInterpreter(Interpreter[AnyStr]):
+    """An wrapper for an interpreter that splits a single message into multiple.
+
+    An interpreter wrapper class that takes a message, splits it according to a given
+    delimiter, and passes on the resulting sub-messages individually on to the
+    wrapped interpreter. The individual responses to the sub-messages are combined into
+    a single response.
+    """
+
+    @overload
+    def __init__(self, interpreter: Interpreter[AnyStr]) -> None:  # noqa: D107
+        pass
+
+    @overload
+    def __init__(
+        self, interpreter: Interpreter[AnyStr], delimiter: AnyStr
+    ) -> None:  # noqa: D107
+        pass
+
+    def __init__(self, interpreter: Interpreter[AnyStr], delimiter=b" ") -> None:
+        """A decorator for an interpreter that splits a message into multiple sub-messages.
+
+        Args:
+            interpreter (Interpreter): The interpreter messages are passed on to.
+            delimiter (AnyStr): The delimiter by which the message is split up.
+
+        """
+        super().__init__()
+        self.interpreter: Interpreter[AnyStr] = interpreter
+        self.delimiter: AnyStr = delimiter
+
+    async def _handle_individual_messages(
+        self, adapter: Adapter, individual_messages: List[AnyStr]
+    ) -> List[Tuple[AsyncIterable[AnyStr], bool]]:
+        results = [
+            await self.interpreter.handle(adapter, message)
+            for message in individual_messages
+        ]
+        return results
+
+    @staticmethod
+    async def _get_response_and_interrupt_from_individual_results(
+        results: List[Tuple[AsyncIterable[AnyStr], bool]]
+    ) -> Tuple[AsyncIterable[AnyStr], bool]:
+        """Combines results from handling multiple messages.
+
+        Takes the responses from when the wrapped interpreter handles multiple messages
+        and returns an appropriate composite repsonse and interrrupt. The composite
+        response is the concatentation of each of the individual responses, the
+        composite interrupt is a logical inclusive 'or' of all of the individual
+        responses.
+
+        Args:
+            results (List[Tuple[AsyncIterable[AnyStr], bool]]): a list of returned
+                values from the wrapped class' handle() method.
+
+        Returns:
+            Tuple[AsyncIterable[AnyStr], bool]:
+                A tuple of the asynchronous iterable of reply messages and a flag
+                indicating whether an interrupt should be raised by the adapter.
+        """
+        individual_responses, individual_interrupts = zip(*results)
+
+        response_list = [
+            response
+            for response_gen in individual_responses
+            async for response in response_gen
+        ]
+        response = functools.reduce(lambda a, b: a + b, response_list)
+        resp = wrap_as_async_iterable(response)
+
+        interrrupt = any(individual_interrupts)
+
+        return resp, interrrupt
+
+    async def handle(
+        self, adapter: Adapter, message: AnyStr
+    ) -> Tuple[AsyncIterable[AnyStr], bool]:
+        """Splits a message and passes the resulting sub-messages on to an interpreter.
+
+        Splits a given message and passes the resulting sub-messages on to an
+        interpreter. The responses to the individual sub-messages are then combined
+        into a single response and returned.
+
+        Args:
+            adapter (Adapter): The adapter in which the function should be executed
+            message: (AnyStr): The message to be split up and handled.
+
+        Returns:
+            Tuple[AsyncIterable[Union[str, bytes]], bool]:
+                A tuple of the asynchronous iterable of reply messages and a flag
+                indicating whether an interrupt should be raised by the adapter.
+        """
+        individual_messages = message.split(self.delimiter)
+
+        results = await self._handle_individual_messages(adapter, individual_messages)
+
+        (
+            resp,
+            interrupt,
+        ) = await self._get_response_and_interrupt_from_individual_results(results)
+
+        return resp, interrupt