mersal-polling 0.1.0__tar.gz

mersal_polling-0.1.0/.gitignore

@@ -0,0 +1,196 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/python,emacs
+# Edit at https://www.toptal.com/developers/gitignore?templates=python,emacs
+
+*.DS_Store
+### Emacs ###
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# Org-mode
+.org-id-locations
+*_archive
+
+# flymake-mode
+*_flymake.*
+
+# eshell files
+/eshell/history
+/eshell/lastdir
+
+# elpa packages
+/elpa/
+
+# reftex files
+*.rel
+
+# AUCTeX auto folder
+/auto/
+
+# cask packages
+.cask/
+dist/
+
+# Flycheck
+flycheck_*.el
+
+# server auth directory
+/server/
+
+# projectiles files
+.projectile
+
+# directory configuration
+.dir-locals.el
+
+# network security
+/network-security.data
+
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# End of https://www.toptal.com/developers/gitignore/api/python,emacs

mersal_polling-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: mersal-polling
+Version: 0.1.0
+Summary: Add your description here
+Author-email: Abdulhaq Emhemmed <abdulhaq.emhemmed@gmail.com>
+Requires-Python: >=3.10
+Requires-Dist: mersal
+Description-Content-Type: text/markdown
+
+# mersal-polling
+
+Describe your project here.

mersal_polling-0.1.0/README.md

@@ -0,0 +1,3 @@
+# mersal-polling
+
+Describe your project here.

mersal_polling-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "mersal-polling"
+version = "0.1.0"
+description = "Add your description here"
+authors = [
+    { name = "Abdulhaq Emhemmed", email = "abdulhaq.emhemmed@gmail.com" }
+]
+dependencies = [
+"mersal",
+]
+readme = "README.md"
+requires-python = ">= 3.10"
+
+[dependency-groups]
+dev = [
+"pytest",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv]
+managed = true
+
+[tool.uv.sources]
+mersal = { workspace = true }
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mersal_polling"]

mersal_polling-0.1.0/src/mersal_polling/__init__.py

@@ -0,0 +1,21 @@
+from .config import (
+    PollingConfig,
+)
+from .default_poller import DefaultPoller
+from .message_completion_handler import (
+    message_completion_event_publisher,
+    register_message_completion_publishers,
+)
+from .poller import Poller, PollingResult
+from .poller_with_timeout import PollerWithTimeout, PollingTimeoutError
+
+__all__ = [
+    "DefaultPoller",
+    "Poller",
+    "PollerWithTimeout",
+    "PollingConfig",
+    "PollingResult",
+    "PollingTimeoutError",
+    "message_completion_event_publisher",
+    "register_message_completion_publishers",
+]

mersal_polling-0.1.0/src/mersal_polling/config.py

@@ -0,0 +1,65 @@
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any, Generic, TypeVar
+
+from mersal_polling.plugin import PollingPlugin
+from mersal_polling.poller import Poller
+
+__all__ = (
+    "FailedCompletionCorrelation",
+    "PollingConfig",
+    "SuccessfulCompletionCorrelation",
+)
+
+
+EventType = TypeVar("EventType")
+
+
+@dataclass
+class SuccessfulCompletionCorrelation(Generic[EventType]):
+    """Correlates an event with the successful completion of a message (usually a command).
+
+    The correlation is either based on a custom callback that is given the event
+    and should return the message id or by default; the correlation id will be used.
+    """
+
+    message_id_getter: Callable[[EventType], Any] | None = None
+
+
+@dataclass
+class FailedCompletionCorrelation(Generic[EventType]):
+    """Correlates an event with the failed completion of a message (usually a command).
+
+    The correlation is either based on a custom callback that is given the event
+    and should return the message id or by default; the correlation id will be used.
+    """
+
+    message_id_getter: Callable[[EventType], Any] | None = None
+
+    """
+    Callback that builds a custom exception to pass to the poller for the failed case.
+    """
+    exception_builder: Callable[[EventType], Exception] | None = None
+
+
+@dataclass
+class PollingConfig:
+    """Configuration for the polling functionality.
+
+    Args:
+        poller: The poller instance to use
+        successful_completion_events_map: Map of event types to successful completion correlations
+        failed_completion_events_map: Map of event types to failed completion correlations
+        auto_publish_completion_events: Whether to automatically publish message completion events
+        exclude_from_completion_events: Message types to exclude from automatic completion events
+    """
+
+    poller: Poller
+    successful_completion_events_map: dict[type, SuccessfulCompletionCorrelation] = field(default_factory=dict)
+    failed_completion_events_map: dict[type, FailedCompletionCorrelation] = field(default_factory=dict)
+    auto_publish_completion_events: bool = True
+    exclude_from_completion_events: set[type] = field(default_factory=set)
+
+    @property
+    def plugin(self) -> PollingPlugin:
+        return PollingPlugin(self)

mersal_polling-0.1.0/src/mersal_polling/default_poller.py

@@ -0,0 +1,37 @@
+import uuid
+
+from anyio import Event
+
+from .poller import Poller, PollingResult
+
+__all__ = ("DefaultPoller",)
+
+
+class DefaultPoller(Poller):
+    def __init__(self) -> None:
+        self.results: dict[uuid.UUID, PollingResult] = {}
+        self.events: dict[uuid.UUID, Event] = {}
+
+    async def poll(self, message_id: uuid.UUID) -> PollingResult:
+        # Check if result already exists
+        message = self.results.get(message_id)
+        if message:
+            return message
+
+        # Create an event for this message_id if it doesn't exist
+        if message_id not in self.events:
+            self.events[message_id] = Event()
+
+        # Wait for the event to be set
+        await self.events[message_id].wait()
+
+        # Return the result (should be available now)
+        return self.results[message_id]
+
+    async def push(self, message_id: uuid.UUID, exception: Exception | None = None) -> None:
+        # Store the result
+        self.results[message_id] = PollingResult(message_id, exception)
+
+        # If there's a waiting event, trigger it
+        if message_id in self.events:
+            self.events[message_id].set()

mersal_polling-0.1.0/src/mersal_polling/error_handler_poller_wrapper.py

@@ -0,0 +1,21 @@
+from mersal.messages import TransportMessage
+from mersal.retry import ErrorHandler
+from mersal.transport import TransactionContext
+from mersal_polling.poller import Poller
+
+__all__ = ("ErrorHandlerPollerWrapper",)
+
+
+class ErrorHandlerPollerWrapper(ErrorHandler):
+    def __init__(self, poller: Poller, error_handler: ErrorHandler) -> None:
+        self.poller = poller
+        self.error_handler = error_handler
+
+    async def handle_poison_message(
+        self,
+        message: TransportMessage,
+        transaction_context: TransactionContext,
+        exception: Exception,
+    ) -> None:
+        await self.error_handler.handle_poison_message(message, transaction_context, exception)
+        await self.poller.push(message.headers.message_id, exception)

mersal_polling-0.1.0/src/mersal_polling/message_completion_handler.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING, Any
+
+from mersal.messages.message_completed_event import MessageCompletedEvent
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from mersal.activation import HandlerActivator
+    from mersal.app import Mersal
+    from mersal.pipeline import MessageContext
+    from mersal.types import AsyncAnyCallable
+
+__all__ = (
+    "message_completion_event_publisher",
+    "register_message_completion_publishers",
+)
+
+
+def message_completion_event_publisher(
+    message_context: MessageContext,
+    app: Mersal,
+    _: list[AsyncAnyCallable],
+) -> Callable[[Any], Awaitable[None]]:
+    """Create a handler that publishes a MessageCompletedEvent.
+
+    This function creates a message handler that publishes a MessageCompletedEvent
+    when invoked, allowing for tracking message processing completion.
+
+    Args:
+        message_context: The message context for the current message
+        app: The Mersal application instance
+        _: Unused parameter for compatibility with handler factory signature
+
+    Returns:
+        A message handler function that publishes a completion event
+    """
+
+    async def handler(_: Any) -> None:
+        """Handler that publishes a MessageCompletedEvent.
+
+        Args:
+            _: The message (not used in this handler)
+        """
+        completed_message_id = message_context.headers.message_id
+        published_message_id = uuid.uuid4()
+        await app.publish(
+            MessageCompletedEvent(completed_message_id=completed_message_id),
+            headers={"message_id": published_message_id},
+        )
+
+    return handler
+
+
+def register_message_completion_publishers(
+    activator: HandlerActivator,
+    exclude_types: set[type] | None = None,
+) -> None:
+    """Register message completion event publishers for all message types.
+
+    This function registers handlers that publish MessageCompletedEvent for all
+    message types that already have handlers registered in the activator, except
+    for those in the exclude_types set.
+
+    Args:
+        activator: The handler activator to register completion publishers with
+        exclude_types: Message types to exclude from completion event publishing
+    """
+    # Create exclude set (always exclude MessageCompletedEvent itself)
+    exclude: set[type] = set() if exclude_types is None else exclude_types.copy()
+    exclude.add(MessageCompletedEvent)
+
+    # Get all registered message types
+    completion_event_registry: set[type] = set()
+
+    # Register completion event publishers for all message types
+    for message_type in activator.registered_message_types:
+        if message_type not in exclude and message_type not in completion_event_registry:
+            # For each message type, register a handler that publishes completion events
+            def completion_publisher_factory(
+                message_context: MessageContext,
+                app: Mersal,
+            ) -> Callable[[Any], Awaitable[None]]:
+                return message_completion_event_publisher(
+                    message_context=message_context,
+                    app=app,
+                    _=[],
+                )
+
+            activator.register(message_type, completion_publisher_factory)
+            completion_event_registry.add(message_type)

mersal_polling-0.1.0/src/mersal_polling/plugin.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from mersal.activation import HandlerActivator
+from mersal.lifespan import LifespanHandler
+from mersal.messages import MessageCompletedEvent
+from mersal.plugins import Plugin
+from mersal.retry import ErrorHandler
+from mersal_polling.error_handler_poller_wrapper import (
+    ErrorHandlerPollerWrapper,
+)
+from mersal_polling.message_completion_handler import register_message_completion_publishers
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from mersal.app import Mersal
+    from mersal.configuration import StandardConfigurator
+    from mersal.pipeline.message_context import MessageContext
+    from mersal_polling.config import (
+        FailedCompletionCorrelation,
+        PollingConfig,
+        SuccessfulCompletionCorrelation,
+    )
+
+__all__ = ("PollingPlugin",)
+
+
+class PollingPlugin(Plugin):
+    """Plugin that adds polling functionality to a Mersal application.
+
+    This plugin enables waiting for message processing completion through polling.
+    It registers handlers for MessageCompletedEvent and custom completion events,
+    and can automatically add completion event publishers for registered message types.
+    """
+
+    def __init__(self, config: PollingConfig) -> None:
+        """Initialize a new polling plugin.
+
+        Args:
+            config: The configuration for the polling plugin
+        """
+        self._poller = config.poller
+        self._successfull_completion_events_map = config.successful_completion_events_map
+        self._failed_completion_events_map = config.failed_completion_events_map
+        self._auto_publish_completion_events = config.auto_publish_completion_events
+        self._exclude_from_completion_events = config.exclude_from_completion_events
+
+    def __call__(self, configurator: StandardConfigurator) -> None:
+        """Configure the Mersal application with polling functionality.
+
+        Args:
+            configurator: The standard configurator for the application
+        """
+        # Configure event subscriptions for MessageCompletedEvent and other events
+        self._configure_event_subscriptions(configurator)
+
+        # Integrate with error handling
+        self._configure_error_handler(configurator)
+
+        # Register handlers for completion events
+        self._configure_completion_event_handlers(configurator)
+
+        # If auto-publish is enabled, register completion event publishers for all message types
+        if self._auto_publish_completion_events:
+            self._configure_auto_completion_event_publishing(configurator)
+
+    def _configure_event_subscriptions(self, configurator: StandardConfigurator) -> None:
+        """Configure event subscriptions for the polling plugin.
+
+        Args:
+            configurator: The standard configurator for the application
+        """
+
+        def decorate(configurator: StandardConfigurator) -> Any:
+            events_to_subscribe_to: list[type] = [
+                MessageCompletedEvent,
+            ]
+            lifespan_handler: LifespanHandler = configurator.get(LifespanHandler)  # type: ignore[type-abstract]
+            app: Mersal = configurator.mersal
+
+            # Add all custom completion events
+            for event in self._successfull_completion_events_map:
+                events_to_subscribe_to.append(event)
+            for event in self._failed_completion_events_map:
+                events_to_subscribe_to.append(event)
+
+            # Register a startup hook to subscribe to all events
+            lifespan_handler.register_on_startup_hook(self._subscribe(app, events_to_subscribe_to))  # type: ignore[arg-type]
+
+            return lifespan_handler
+
+        configurator.decorate(LifespanHandler, decorate)
+
+    def _configure_error_handler(self, configurator: StandardConfigurator) -> None:
+        """Configure error handling integration with polling.
+
+        Args:
+            configurator: The standard configurator for the application
+        """
+
+        def decorate_error_handler(configurator: StandardConfigurator) -> Any:
+            error_handler: ErrorHandler = configurator.get(ErrorHandler)  # type: ignore[type-abstract]
+            return ErrorHandlerPollerWrapper(self._poller, error_handler)
+
+        configurator.decorate(ErrorHandler, decorate_error_handler)
+
+    def _configure_completion_event_handlers(self, configurator: StandardConfigurator) -> None:
+        """Configure handlers for message completion events.
+
+        Args:
+            configurator: The standard configurator for the application
+        """
+
+        def decorate_activator(configurator: StandardConfigurator) -> Any:
+            activator: HandlerActivator = configurator.get(HandlerActivator)  # type: ignore[type-abstract]
+
+            # Register handler for MessageCompletedEvent
+            activator.register(
+                MessageCompletedEvent,
+                lambda __, _: self._message_completed_event_handler,
+            )
+
+            # Register handlers for custom success completion events
+            for (
+                event_type,
+                success_correlator,
+            ) in self._successfull_completion_events_map.items():
+                activator.register(
+                    event_type,
+                    lambda message_context,  # type: ignore[misc]
+                    _,
+                    sc=success_correlator: self._successfull_custom_completion_event_handler_factory(
+                        sc, message_context
+                    ),
+                )
+
+            # Register handlers for custom failure completion events
+            for (
+                event_type,
+                failure_correlator,
+            ) in self._failed_completion_events_map.items():
+                activator.register(
+                    event_type,
+                    lambda message_context,  # type: ignore[misc]
+                    _,
+                    fc=failure_correlator: self._failed_custom_completion_event_handler_factory(fc, message_context),
+                )
+
+            return activator
+
+        configurator.decorate(HandlerActivator, decorate_activator)
+
+    def _configure_auto_completion_event_publishing(self, configurator: StandardConfigurator) -> None:
+        """Configure automatic completion event publishing.
+
+        Args:
+            configurator: The standard configurator for the application
+        """
+
+        def decorate_activator(configurator: StandardConfigurator) -> Any:
+            activator: HandlerActivator = configurator.get(HandlerActivator)  # type: ignore[type-abstract]
+            register_message_completion_publishers(activator, self._exclude_from_completion_events)
+            return activator
+
+        configurator.decorate(HandlerActivator, decorate_activator)
+
+    async def _message_completed_event_handler(self, event: MessageCompletedEvent) -> None:
+        """Handle MessageCompletedEvent by updating the poller.
+
+        Args:
+            event: The message completed event
+        """
+        await self._poller.push(event.completed_message_id, None)
+
+    def _successfull_custom_completion_event_handler_factory(
+        self,
+        correlator: SuccessfulCompletionCorrelation,
+        message_context: MessageContext,
+    ) -> Callable[[Any], Awaitable[None]]:
+        """Create a handler for custom successful completion events.
+
+        Args:
+            correlator: The correlation configuration
+            message_context: The message context
+
+        Returns:
+            A handler function that processes the event
+        """
+
+        async def _custom_completion_event_handler(event: Any) -> None:
+            if message_id_getter := correlator.message_id_getter:
+                message_id = message_id_getter(event)
+            else:
+                message_id = message_context.headers.correlation_id
+            await self._poller.push(message_id, None)
+
+        return _custom_completion_event_handler
+
+    def _failed_custom_completion_event_handler_factory(
+        self, correlator: FailedCompletionCorrelation, message_context: MessageContext
+    ) -> Callable[[Any], Awaitable[None]]:
+        """Create a handler for custom failure completion events.
+
+        Args:
+            correlator: The correlation configuration
+            message_context: The message context
+
+        Returns:
+            A handler function that processes the event
+        """
+
+        async def _custom_completion_event_handler(event: Any) -> None:
+            if message_id_getter := correlator.message_id_getter:
+                message_id = message_id_getter(event)
+            else:
+                message_id = message_context.headers.correlation_id
+
+            if exception_builder := correlator.exception_builder:
+                exception = exception_builder(event)
+            else:
+                exception = Exception("Event error")
+            await self._poller.push(message_id, exception)
+
+        return _custom_completion_event_handler
+
+    def _subscribe(self, app: Mersal, events: list[type]) -> Callable[[list[type]], Awaitable[None]]:
+        """Create a function that subscribes to the given events.
+
+        Args:
+            app: The Mersal application
+            events: The list of event types to subscribe to
+
+        Returns:
+            A function that performs the subscriptions
+        """
+
+        async def subscribe(
+            events: list[type] = events,
+        ) -> None:
+            for e in events:
+                await app.subscribe(e)
+
+        return subscribe

mersal_polling-0.1.0/src/mersal_polling/poller.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+__all__ = (
+    "Poller",
+    "PollingResult",
+)
+
+
+@dataclass
+class PollingResult:
+    message_id: Any
+    exception: Exception | None
+
+
+class Poller(Protocol):
+    async def poll(self, message_id: Any) -> PollingResult: ...
+
+    async def push(
+        self,
+        message_id: Any,
+        exception: Exception | None = None,
+    ) -> None: ...

mersal_polling-0.1.0/src/mersal_polling/poller_with_timeout.py

@@ -0,0 +1,28 @@
+import uuid
+
+from anyio import fail_after
+
+from mersal.exceptions import MersalExceptionError
+
+from .poller import Poller, PollingResult
+
+__all__ = (
+    "PollerWithTimeout",
+    "PollingTimeoutError",
+)
+
+
+class PollingTimeoutError(MersalExceptionError):
+    pass
+
+
+class PollerWithTimeout:
+    def __init__(self, poller: Poller) -> None:
+        self._poller = poller
+
+    async def poll(self, message_id: uuid.UUID, timeout: float = 30) -> PollingResult:
+        try:
+            with fail_after(timeout):
+                return await self._poller.poll(message_id)
+        except TimeoutError as e:
+            raise PollingTimeoutError() from e

mersal_polling-0.1.0/tests/conftest.py

@@ -0,0 +1,3 @@
+# pyright: reportWildcardImportFromLibrary=false
+
+from mersal_testing._internal.conftest import *

mersal_polling-0.1.0/tests/test_polling_plugin.py

@@ -0,0 +1,385 @@
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+import anyio
+import pytest
+
+from mersal.activation import (
+    BuiltinHandlerActivator,
+)
+from mersal.app import Mersal
+from mersal.lifespan.autosubscribe import AutosubscribeConfig
+from mersal.messages import MessageCompletedEvent
+from mersal.persistence.in_memory import (
+    InMemorySubscriptionStorage,
+)
+from mersal.pipeline import MessageContext
+from mersal.serialization.serializers import Serializer
+from mersal.transport.in_memory import InMemoryTransport
+from mersal_polling import (
+    DefaultPoller,
+    PollerWithTimeout,
+    PollingConfig,
+    PollingTimeoutError,
+)
+from mersal_polling.config import (
+    FailedCompletionCorrelation,
+    SuccessfulCompletionCorrelation,
+)
+from mersal_testing.message_handlers.message_handler_that_counts import MessageHandlerThatCounts
+
+__all__ = (
+    "Message1",
+    "Message1CompletedSuccessfully",
+    "Message1FailedToComplete",
+    "MessageHandler",
+    "MessageHandlerThatPublishes",
+    "SlowHandler",
+    "TestPollingPlugin",
+    "ThrowingMessageHandler",
+)
+
+
+pytestmark = pytest.mark.anyio
+
+
+class Message1:
+    pass
+
+
+class Message2:
+    pass
+
+
+@dataclass
+class Message1CompletedSuccessfully:
+    pass
+
+
+@dataclass
+class Message2CompletedSuccessfully:
+    pass
+
+
+@dataclass
+class Message1FailedToComplete:
+    pass
+
+
+@dataclass
+class Message2FailedToComplete:
+    pass
+
+
+class MessageHandler:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    async def __call__(self, message: Any):
+        self.calls += 1
+
+
+class SlowHandler:
+    def __init__(self, delay: int) -> None:
+        self.calls = 0
+        self.delay = delay
+
+    async def __call__(self, message: Any):
+        self.calls += 1
+        await anyio.sleep(self.delay)
+
+
+class ThrowingMessageHandler:
+    async def __call__(self, message: Any):
+        raise Exception()
+
+
+class MessageHandlerThatPublishes:
+    def __init__(self, message_context: MessageContext, app: Mersal, published_message: Any) -> None:
+        self.calls = 0
+        self.app = app
+        self.message_context = message_context
+        self.published_message = published_message
+
+    async def __call__(self, message: Any):
+        self.calls += 1
+        await self.app.publish(self.published_message)
+
+
+class TestPollingPlugin:
+    async def test_polling(
+        self,
+        in_memory_transport: InMemoryTransport,
+        in_memory_subscription_storage: InMemorySubscriptionStorage,
+        serializer: Serializer,
+    ):
+        activator = BuiltinHandlerActivator()
+        poller = DefaultPoller()
+        message_handler = MessageHandlerThatCounts()
+        completion_event_handler = MessageHandlerThatCounts()
+        activator.register(Message1, lambda __, _: message_handler)
+        activator.register(MessageCompletedEvent, lambda _, __: completion_event_handler)
+        message1_id = uuid.uuid4()
+
+        app = Mersal(
+            "m1",
+            activator,
+            transport=in_memory_transport,
+            serializer=serializer,
+            subscription_storage=in_memory_subscription_storage,
+            autosubscribe=AutosubscribeConfig(set()),
+            plugins=[
+                PollingConfig(
+                    poller,
+                    auto_publish_completion_events=True,
+                ).plugin
+            ],
+        )
+        await app.start()
+
+        await anyio.sleep(0.5)
+
+        await app.send_local(Message1(), headers={"message_id": message1_id})
+
+        await anyio.sleep(0.5)
+
+        assert message_handler.count == 1
+        assert completion_event_handler.count == 1
+        assert isinstance(completion_event_handler.message, MessageCompletedEvent)
+        assert completion_event_handler.message.completed_message_id == message1_id
+
+        result = await poller.poll(message1_id)
+        assert result
+        assert not result.exception
+
+        await app.send_local(Message1(), headers={"message_id": uuid.uuid4()})
+        await anyio.sleep(0.5)
+        assert message_handler.count == 2
+        assert completion_event_handler.count == 2
+
+        await app.stop()
+
+    async def test_polling_with_custom_success_completion_event(
+        self,
+        in_memory_transport: InMemoryTransport,
+        in_memory_subscription_storage: InMemorySubscriptionStorage,
+        serializer: Serializer,
+    ):
+        activator = BuiltinHandlerActivator()
+        poller = DefaultPoller()
+        app = Mersal(
+            "m1",
+            activator,
+            transport=in_memory_transport,
+            serializer=serializer,
+            subscription_storage=in_memory_subscription_storage,
+            autosubscribe=AutosubscribeConfig(set()),
+            plugins=[
+                PollingConfig(
+                    poller,
+                    successful_completion_events_map={
+                        Message1CompletedSuccessfully: SuccessfulCompletionCorrelation(),
+                        Message2CompletedSuccessfully: SuccessfulCompletionCorrelation(),
+                    },
+                    exclude_from_completion_events={
+                        Message1,
+                        Message2,
+                    },
+                ).plugin
+            ],
+        )
+        activator.register(
+            Message1,
+            lambda m, b: MessageHandlerThatPublishes(m, b, Message1CompletedSuccessfully()),
+        )
+        activator.register(
+            Message2,
+            lambda m, b: MessageHandlerThatPublishes(m, b, Message2CompletedSuccessfully()),
+        )
+        message1_id = uuid.uuid4()
+        message2_id = uuid.uuid4()
+        await app.start()
+
+        await app.send_local(Message1(), headers={"message_id": message1_id})
+        await app.send_local(Message2(), headers={"message_id": message2_id})
+        await anyio.sleep(0.5)
+        result1 = await poller.poll(message1_id)
+        result2 = await poller.poll(message2_id)
+        assert result1
+        assert not result1.exception
+        assert result2
+        assert not result2.exception
+
+        await app.stop()
+
+    async def test_polling_with_custom_failure_completion_event(
+        self,
+        in_memory_transport: InMemoryTransport,
+        in_memory_subscription_storage: InMemorySubscriptionStorage,
+        serializer: Serializer,
+    ):
+        activator = BuiltinHandlerActivator()
+        poller = DefaultPoller()
+        app = Mersal(
+            "m1",
+            activator,
+            transport=in_memory_transport,
+            serializer=serializer,
+            subscription_storage=in_memory_subscription_storage,
+            autosubscribe=AutosubscribeConfig(set()),
+            plugins=[
+                PollingConfig(
+                    poller,
+                    failed_completion_events_map={
+                        Message1FailedToComplete: FailedCompletionCorrelation(
+                            exception_builder=lambda event: ValueError("hi")
+                        ),
+                        Message2FailedToComplete: FailedCompletionCorrelation(
+                            exception_builder=lambda event: ValueError("hi-bye")
+                        ),
+                    },
+                    exclude_from_completion_events={
+                        Message1,
+                        Message2,
+                    },
+                ).plugin
+            ],
+        )
+        activator.register(
+            Message1,
+            lambda m, b: MessageHandlerThatPublishes(m, b, Message1FailedToComplete()),
+        )
+        activator.register(
+            Message2,
+            lambda m, b: MessageHandlerThatPublishes(m, b, Message2FailedToComplete()),
+        )
+        message1_id = uuid.uuid4()
+        message2_id = uuid.uuid4()
+        await app.start()
+
+        await app.send_local(Message1(), headers={"message_id": message1_id})
+        await app.send_local(Message2(), headers={"message_id": message2_id})
+        await anyio.sleep(0.5)
+
+        result1 = await poller.poll(message1_id)
+        result2 = await poller.poll(message2_id)
+
+        assert result1
+        assert result1.exception
+        assert type(result1.exception) is ValueError
+        assert result2
+        assert result2.exception
+        assert type(result2.exception) is ValueError
+
+        await app.stop()
+
+    async def test_polling_with_exception(
+        self,
+        in_memory_transport: InMemoryTransport,
+        in_memory_subscription_storage: InMemorySubscriptionStorage,
+        serializer: Serializer,
+    ):
+        activator = BuiltinHandlerActivator()
+        poller = DefaultPoller()
+        app = Mersal(
+            "m1",
+            activator,
+            transport=in_memory_transport,
+            serializer=serializer,
+            subscription_storage=in_memory_subscription_storage,
+            autosubscribe=AutosubscribeConfig(set()),
+            plugins=[PollingConfig(poller).plugin],
+        )
+
+        handler = ThrowingMessageHandler()
+        activator.register(Message1, lambda __, _: handler)
+        message_id = uuid.uuid4()
+        await app.start()
+
+        await app.send_local(Message1(), headers={"message_id": message_id})
+        await anyio.sleep(0.1)
+        result = await poller.poll(message_id)
+        assert result
+        assert result.exception
+
+        await app.stop()
+
+    async def test_polling_with_timeout(
+        self,
+        in_memory_transport: InMemoryTransport,
+        in_memory_subscription_storage: InMemorySubscriptionStorage,
+        serializer: Serializer,
+    ):
+        activator = BuiltinHandlerActivator()
+        _poller = DefaultPoller()
+        poller = PollerWithTimeout(_poller)
+        app = Mersal(
+            "m1",
+            activator,
+            transport=in_memory_transport,
+            serializer=serializer,
+            subscription_storage=in_memory_subscription_storage,
+            autosubscribe=AutosubscribeConfig(set()),
+            plugins=[PollingConfig(_poller).plugin],
+        )
+
+        handler = SlowHandler(1)
+        activator.register(Message1, lambda __, _: handler)
+        message_id = uuid.uuid4()
+        await app.start()
+
+        await app.send_local(Message1(), headers={"message_id": message_id})
+        with pytest.raises(PollingTimeoutError):
+            await poller.poll(message_id, timeout=0.5)
+
+        await app.stop()
+
+    async def test_auto_completion_event_with_polling_plugin_excluded(
+        self,
+        in_memory_transport: InMemoryTransport,
+        in_memory_subscription_storage: InMemorySubscriptionStorage,
+        serializer: Serializer,
+    ):
+        activator = BuiltinHandlerActivator()
+        message = Message1()
+
+        completion_event_handler = MessageHandlerThatCounts()
+        activator.register(MessageCompletedEvent, lambda _, __: completion_event_handler)
+
+        message_handler = MessageHandlerThatCounts()
+        activator.register(Message1, lambda m, b: message_handler)
+
+        poller = DefaultPoller()
+
+        plugins = [
+            PollingConfig(
+                poller,
+                auto_publish_completion_events=True,
+                exclude_from_completion_events={Message1},
+            ).plugin,
+        ]
+
+        app = Mersal(
+            "m1",
+            activator,
+            transport=in_memory_transport,
+            serializer=serializer,
+            subscription_storage=in_memory_subscription_storage,
+            plugins=plugins,
+        )
+
+        await app.start()
+
+        message_id = uuid.uuid4()
+        await app.send_local(message, headers={"message_id": message_id})
+
+        await anyio.sleep(0.1)
+        await app.stop()
+
+        assert message_handler.count == 1
+        assert completion_event_handler.count == 0
+
+        _poller = PollerWithTimeout(poller)
+        with pytest.raises(PollingTimeoutError):
+            _ = await _poller.poll(message_id, 1)