feat: Adds celery integration (PR #8)

Pull requested created by @angeloalvarez  - #8

Author: thiarthur

.pre-commit-config.yaml

@@ -30,8 +30,9 @@ repos:
       rev: v1.10.1
       hooks:
           - id: mypy
+            args: [--config-file=./pyproject.toml, "."]
             additional_dependencies: [types-requests]
-            exclude: ^tests/
+            pass_filenames: false
     - repo: local
       hooks:
           - id: pytest

eolic/base.py

@@ -3,7 +3,7 @@
 import functools
 from typing import Any, Callable, List, TypeVar, cast
 
-from eolic.integrations.base import Integration
+from .integrations.base import Integration
 
 from .listener import EventListenerHandler
 from .meta.singleton import Singleton

eolic/helpers/modules.py

@@ -0,0 +1,30 @@
+"""File containing helpers for modules."""
+
+import importlib.util
+
+from typing import Any
+
+
+def is_module_installed(module_name: str) -> bool:
+    """
+    Check if a Python module is installed.
+
+    Args:
+        module_name (str): The name of the module to check.
+
+    Returns:
+        bool: True if the module is installed, False otherwise.
+    """
+    return importlib.util.find_spec(module_name) is not None
+
+
+def get_module(module_name: str) -> Any:
+    """
+    Import and returns a module by its name.
+
+    Args:
+        module_name (str): The name of the module to import, as a string.
+    Returns:
+        Any: The imported module.
+    """
+    return importlib.import_module(module_name)

eolic/integrations/celery.py

@@ -0,0 +1,65 @@
+"""Module for Celery integration."""
+
+from typing import TYPE_CHECKING, Optional
+
+from ..base import Integration
+from ..model import EventDTO
+from ..helpers.modules import is_module_installed
+
+if TYPE_CHECKING:
+    from celery import Celery
+    from ..base import Eolic
+
+
+class CeleryIntegration(Integration):
+    """Class for CeleryIntegration integration setup with Eolic."""
+
+    def __init__(
+        self,
+        app: Optional["Celery"],
+        event_function: str = "events",
+        queue_name: str = "eolic",
+    ) -> None:
+        """
+        Initialize the Celery integration.
+
+        Args:
+            app (Celery): The Celery app instance.
+            event_function (str): The event hook function event receiving.
+
+        Raises:
+            Exception: If Celery extra is not installed.
+            Exception: If Celery is None.
+        """
+        if not is_module_installed("celery"):
+            raise Exception(
+                "Celery Integration is not installed. "
+                "Please install eolic[celery] (using celery extras) to use this integration."
+            )
+
+        if app is None:
+            raise Exception("Please declare you app to setup the integration.")
+
+        super().__init__()
+        self.app = app
+        self.event_function = event_function
+        self.queue_name = queue_name
+
+    def setup(self, eolic: "Eolic") -> None:
+        """
+        Apply the Celery integration setup.
+
+        Args:
+            eolic (Eolic): The Eolic instance to integrate with.
+        """
+        self.eolic = eolic
+        event_function = self.event_function
+
+        if event_function is None:
+            raise Exception("Event function is required for Celery integration.")
+
+        def listener_event(event_name: str, *args, **kwargs):
+            event = EventDTO(event=event_name, args=args, kwargs=kwargs)
+            self.forward_event(event)
+
+        self.app.task(listener_event, name=self.event_function, queue=self.queue_name)

eolic/integrations/fastapi.py

@@ -1,9 +1,10 @@
 """Module for FastAPI integration."""
 
-import sys
 from typing import TYPE_CHECKING, Optional
+
 from ..base import Integration
 from ..model import EventDTO
+from ..helpers.modules import is_module_installed
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
@@ -25,7 +26,7 @@ def __init__(self, app: Optional["FastAPI"], event_route: str = "/events") -> No
             Exception: If FastAPI extra is is not installed.
             Exception: If FastAPI is None.
         """
-        if "fastapi" not in sys.modules:
+        if not is_module_installed("fastapi"):
             raise Exception(
                 """FastAPI Integration is not installed.
                     Please install eolic[fastapi] (using fastapi extras) to use this integration."""

eolic/meta/__init__.py

@@ -0,0 +1 @@
+"""Module containing metaclasses."""

eolic/model.py

@@ -61,6 +61,19 @@ class EventRemoteURLTarget(EventRemoteTarget):
     headers: Dict[str, Any] = {}
 
 
+class EventRemoteCeleryTarget(EventRemoteTarget):
+    """
+    Model for Celery event remote targets.
+
+    Attributes:
+        queue_name: String of queue used in celery worker, default: eolic.
+        function_name: String of function name used in celery worker, default: events.
+    """
+
+    queue_name: str = "eolic"
+    function_name: str = "events"
+
+
 class EventListener(BaseModel):
     """
     Model for event listeners.

eolic/remote.py

@@ -7,13 +7,13 @@
 
 from __future__ import annotations
 
-from enum import Enum
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
 import requests
 
-from eolic.task_manager import TaskManager
+from .task_manager import TaskManager
 
 from .helpers.coroutines import run_coroutine
 
@@ -22,7 +22,9 @@
     EventRemoteTarget,
     EventRemoteTargetType,
     EventRemoteURLTarget,
+    EventRemoteCeleryTarget,
 )
+from .helpers.modules import is_module_installed, get_module
 
 
 class EventRemoteTargetHandler(TaskManager):
@@ -41,7 +43,8 @@ def __init__(self) -> None:
         """Initialize the EventRemoteTargetHandler."""
         super().__init__()
 
-    def _parse_target(self, target: Any) -> EventRemoteTarget:
+    @staticmethod
+    def _parse_target(target: Union[str, Dict[str, Any]]) -> EventRemoteTarget:
         """
         Parse and convert a target to an EventRemoteTarget instance.
 
@@ -52,18 +55,60 @@ def _parse_target(self, target: Any) -> EventRemoteTarget:
             EventRemoteTarget: Parsed remote target.
         """
         if isinstance(target, str):
-            return EventRemoteURLTarget(
-                type=EventRemoteTargetType("url"), address=target
+            target = {"type": "url", "address": target}
+
+        if not isinstance(target, dict):
+            raise TypeError(
+                "Target needs to be of type str or Dict[str, str] but received {}".format(
+                    type(target)
+                )
             )
 
-        if isinstance(target, dict):
+        target_type = target.get("type")
+
+        if not isinstance(target_type, str):
+            raise TypeError(
+                "Target type needs to be of type str but received {}".format(
+                    type(target_type)
+                )
+            )
+
+        event_remote_target_type = EventRemoteTargetType[target_type]
+
+        if event_remote_target_type == EventRemoteTargetType.url:
             return EventRemoteURLTarget(
-                type=EventRemoteTargetType("url"),
+                type=event_remote_target_type,
                 address=target["address"],
                 headers=target.get("headers", {}),
                 events=target.get("events"),
             )
 
+        elif event_remote_target_type == EventRemoteTargetType.celery:
+            address = str(target["address"])
+            events: Optional[List[Any]] = target.get("events")
+
+            queue_name = (
+                str(target.get("queue_name")) if target.get("queue_name") else None
+            )
+            function_name = (
+                str(target.get("function_name"))
+                if target.get("function_name")
+                else None
+            )
+
+            optional_kwargs = {}
+
+            if queue_name:
+                optional_kwargs["queue_name"] = queue_name
+            if function_name:
+                optional_kwargs["function_name"] = function_name
+
+            return EventRemoteCeleryTarget(
+                type=event_remote_target_type,
+                address=address,
+                events=events,
+                **optional_kwargs,
+            )
         return EventRemoteTarget(**target)
 
     def register(self, target: Any) -> None:
@@ -127,6 +172,9 @@ def create(self, target: EventRemoteTarget) -> EventRemoteDispatcher:
         if isinstance(target, EventRemoteURLTarget):
             return EventRemoteURLDispatcher(target)
 
+        if isinstance(target, EventRemoteCeleryTarget):
+            return EventRemoteCeleryDispatcher(target)
+
         raise NotImplementedError(
             f"EventRemoteDispatcher for {target.type} not implemented"
         )
@@ -199,3 +247,47 @@ async def dispatch(self, event: Any, *args, **kwargs) -> None:
             timeout=10,
         )
         logging.debug(f"Response from {self.target.address}: {response.status_code}")
+
+
+class EventRemoteCeleryDispatcher(EventRemoteDispatcher):
+    """Dispatcher for Celery remote targets."""
+
+    def __init__(self, target: EventRemoteCeleryTarget) -> None:
+        """
+        Initialize the Celery dispatcher with a target.
+
+        Args:
+            target (EventRemoteCeleryTarget): The Celery remote target.
+        """
+        self.target = target
+
+        if not is_module_installed("celery"):
+            raise Exception(
+                "Celery Integration is not installed. "
+                "Please install eolic[celery] (using celery extras) to use this integration."
+            )
+
+        self.celery = get_module("celery").Celery(self.target.address)
+
+    async def dispatch(self, event: Any, *args, **kwargs) -> None:
+        """
+        Dispatch the event to the URL remote target.
+
+        Args:
+            event (Any): The event to dispatch.
+            *args: Variable length argument list for the event.
+            **kwargs: Arbitrary keyword arguments for the event.
+        """
+        event_value = str(event)
+
+        if isinstance(event, Enum):
+            event_value = event.value
+
+        task = self.celery.send_task(
+            self.target.function_name,
+            args=[event_value, *args],
+            kwargs=kwargs,
+            queue=self.target.queue_name,
+        )
+
+        logging.debug(f"Celery task id {task}")

eolic/task_manager.py

@@ -4,7 +4,7 @@
 import atexit
 import signal
 from typing import Any, Callable
-from eolic.helpers.coroutines import run_coroutine
+from .helpers.coroutines import run_coroutine
 
 
 class TaskManager:

examples/integrations/celery_plugin/celery_notification_service.py

@@ -0,0 +1,28 @@
+"""Notification service example with celery."""
+
+from celery import Celery
+
+from eolic import Eolic
+from eolic.integrations.celery import CeleryIntegration
+
+app = Celery(
+    "tasks",
+    backend=False,
+)
+
+eolic = Eolic()
+
+
+# Create an instance of CeleryIntegration with a custom event function
+celery_integration = CeleryIntegration(app)
+# Set up the integration
+eolic.setup_integration(celery_integration)
+
+
+@eolic.on("user_created")
+def handle_user_created(id_: int, name: str, email: str):
+    """Handle the user created event."""
+    # Handle the user created event (e.g., send a notification)
+    print(f"Notification: [{id_}] User {name} with email {email} was created!")
+    # TODO: Send-email for email confirmation
+    return {}

examples/integrations/celery_plugin/celery_user_service.py

@@ -0,0 +1,34 @@
+"""User service example with celery."""
+
+from typing import List
+
+from pydantic import BaseModel
+
+from eolic import Eolic
+
+eolic = Eolic(remote_targets=[{"type": "celery", "address": "amqp://localhost:5672"}])
+
+
+class User(BaseModel):
+    """User model."""
+
+    id: int
+    name: str
+    email: str
+
+
+users: List[User] = []
+
+
+def create_user(user: User):
+    """Endpoint to create a user."""
+    if any(u.id == user.id for u in users):
+        raise NotImplementedError("User already exists")
+
+    users.append(user)
+    eolic.emit("user_created", user.id, user.name, user.email)
+
+    return user
+
+
+create_user(User(id=1, name="Name", email="email@example.com"))

examples/integrations/celery_plugin/readme.md

@@ -0,0 +1,57 @@
+# Eolic Celery Integration Example
+
+This example demonstrates how to integrate Eolic Celery to handle events, such as sending notifications between a User Service and a Notification Service.
+
+## Overview
+
+- **User Service**: Create a new user and emit an event.
+- **Notification Service**: Listens for user creation events and handles them by sending a notification.
+
+## Prerequisites
+
+- Python 3.8+
+- Celery
+- Eolic with Celery extras: eolic[**celery**]
+
+## Installation
+
+1. **Clone the repository**:
+   ```bash
+   git clone git@github.com:thiarthur/eolic.git
+    ```
+
+2. **Create a virtual env (optional)**:
+    ```bash
+    python -m venv venv
+    source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+    ```
+
+3. **Install the dependencies**:
+    ```bash
+    pip install requirements.txt
+    ```
+
+## Running
+
+**Note:** To run Celery, you will need a queue service or any other backend to run it. In this example, we are using [RabbitMQ](https://www.rabbitmq.com/tutorials). See more at the [Celery documentation](https://docs.celeryq.dev/en/stable/getting-started/introduction.html).
+
+
+1. **Start the Notification Service**:
+    ```bash
+    celery -A 'examples.integrations.celery_plugin.celery_notification_service' worker --loglevel=INFO -Q eolic
+    ```
+
+2. **Create a New User**:
+
+    ```bash
+    python examples/integrations/celery_plugin/celery_user_service.py
+    ```
+
+3. **Check Notifications**:
+Check the output of the Notification Service to see the notification for the new user creation.
+
+
+
+## Conclusion
+
+This example illustrates the process of setting up and using Celery integration with Eolic to efficiently handle events across microservices, ensuring smooth and reliable communication between services.

examples/integrations/fastapi_plugin/notification_service.py examples/integrations/fastapi_plugin/fastapi_notification_service.py

@@ -38,13 +38,13 @@ This example demonstrates how to use Eolic to integrate event handling between t
 1. **Start the User Service**:
 
     ```bash
-    python user_service.py
+    python fastapi_user_service.py
     Start the Notification Service:
     ```
 
 2. **Start the Notification Service**:
     ```bash
-    python notification_service.py
+    python fastapi_notification_service.py
     ```
 
 3. **Create a New User**:

examples/integrations/fastapi_plugin/user_service.py examples/integrations/fastapi_plugin/fastapi_user_service.py

@@ -16,10 +16,12 @@ pydantic = "^2.8.2"
 requests = "^2.32.3"
 fastapi = { version="*", optional= true }
 uvicorn = { version="*", optional= true }
+celery = { version="*", optional= true }
 
 [tool.poetry.extras]
 fastapi = ["fastapi", "uvicorn"]
-all = ["fastapi", "uvicorn"]
+celery = ["celery"]
+all = ["fastapi", "uvicorn", "celery"]
 
 [tool.poetry.group.dev.dependencies]
 black = "^24.4.2"
@@ -32,7 +34,6 @@ flake8-pyproject = "^1.2.3"
 commitizen = "^3.28.0"
 httpx = "^0.27.0"
 
-
 [tool.poetry.group.test.dependencies]
 pytest = "^8.2.2"
 pytest-mock = "^3.14.0"
@@ -54,6 +55,8 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.mypy]
 exclude = ["tests/"]
+no_namespace_packages = true
+ignore_missing_imports = true
 
 [tool.flake8]
 max-line-length = 105

examples/integrations/fastapi_plugin/readme.md

@@ -1,9 +1,52 @@
+amqp==5.2.0 ; python_version >= "3.9" and python_version < "4.0"
 annotated-types==0.7.0 ; python_version >= "3.9" and python_version < "4.0"
+anyio==4.4.0 ; python_version >= "3.9" and python_version < "4.0"
+billiard==4.2.0 ; python_version >= "3.9" and python_version < "4.0"
+celery==5.4.0 ; python_version >= "3.9" and python_version < "4.0"
 certifi==2024.7.4 ; python_version >= "3.9" and python_version < "4.0"
 charset-normalizer==3.3.2 ; python_version >= "3.9" and python_version < "4.0"
+click-didyoumean==0.3.1 ; python_version >= "3.9" and python_version < "4.0"
+click-plugins==1.1.1 ; python_version >= "3.9" and python_version < "4.0"
+click-repl==0.3.0 ; python_version >= "3.9" and python_version < "4.0"
+click==8.1.7 ; python_version >= "3.9" and python_version < "4.0"
+colorama==0.4.6 ; python_version >= "3.9" and python_version < "4.0" and (sys_platform == "win32" or platform_system == "Windows")
+dnspython==2.6.1 ; python_version >= "3.9" and python_version < "4.0"
+email-validator==2.2.0 ; python_version >= "3.9" and python_version < "4.0"
+exceptiongroup==1.2.2 ; python_version >= "3.9" and python_version < "3.11"
+fastapi-cli==0.0.4 ; python_version >= "3.9" and python_version < "4.0"
+fastapi==0.111.1 ; python_version >= "3.9" and python_version < "4.0"
+h11==0.14.0 ; python_version >= "3.9" and python_version < "4.0"
+httpcore==1.0.5 ; python_version >= "3.9" and python_version < "4.0"
+httptools==0.6.1 ; python_version >= "3.9" and python_version < "4.0"
+httpx==0.27.0 ; python_version >= "3.9" and python_version < "4.0"
 idna==3.7 ; python_version >= "3.9" and python_version < "4.0"
+jinja2==3.1.4 ; python_version >= "3.9" and python_version < "4.0"
+kombu==5.3.7 ; python_version >= "3.9" and python_version < "4.0"
+markdown-it-py==3.0.0 ; python_version >= "3.9" and python_version < "4.0"
+markupsafe==2.1.5 ; python_version >= "3.9" and python_version < "4.0"
+mdurl==0.1.2 ; python_version >= "3.9" and python_version < "4.0"
+prompt-toolkit==3.0.36 ; python_version >= "3.9" and python_version < "4.0"
 pydantic-core==2.20.1 ; python_version >= "3.9" and python_version < "4.0"
 pydantic==2.8.2 ; python_version >= "3.9" and python_version < "4.0"
+pygments==2.18.0 ; python_version >= "3.9" and python_version < "4.0"
+python-dateutil==2.9.0.post0 ; python_version >= "3.9" and python_version < "4.0"
+python-dotenv==1.0.1 ; python_version >= "3.9" and python_version < "4.0"
+python-multipart==0.0.9 ; python_version >= "3.9" and python_version < "4.0"
+pyyaml==6.0.1 ; python_version >= "3.9" and python_version < "4.0"
 requests==2.32.3 ; python_version >= "3.9" and python_version < "4.0"
+rich==13.7.1 ; python_version >= "3.9" and python_version < "4.0"
+shellingham==1.5.4 ; python_version >= "3.9" and python_version < "4.0"
+six==1.16.0 ; python_version >= "3.9" and python_version < "4.0"
+sniffio==1.3.1 ; python_version >= "3.9" and python_version < "4.0"
+starlette==0.37.2 ; python_version >= "3.9" and python_version < "4.0"
+typer==0.12.3 ; python_version >= "3.9" and python_version < "4.0"
 typing-extensions==4.12.2 ; python_version >= "3.9" and python_version < "4.0"
+tzdata==2024.1 ; python_version >= "3.9" and python_version < "4.0"
 urllib3==2.2.2 ; python_version >= "3.9" and python_version < "4.0"
+uvicorn==0.30.3 ; python_version >= "3.9" and python_version < "4.0"
+uvicorn[standard]==0.30.3 ; python_version >= "3.9" and python_version < "4.0"
+uvloop==0.19.0 ; (sys_platform != "win32" and sys_platform != "cygwin") and platform_python_implementation != "PyPy" and python_version >= "3.9" and python_version < "4.0"
+vine==5.1.0 ; python_version >= "3.9" and python_version < "4.0"
+watchfiles==0.22.0 ; python_version >= "3.9" and python_version < "4.0"
+wcwidth==0.2.13 ; python_version >= "3.9" and python_version < "4.0"
+websockets==12.0 ; python_version >= "3.9" and python_version < "4.0"

pyproject.toml

@@ -0,0 +1,252 @@
+import importlib.util
+from enum import Enum
+
+import pytest
+from celery import Celery
+
+from eolic.base import Eolic
+from eolic.helpers.modules import get_module
+from eolic.integrations.celery import CeleryIntegration
+from eolic.model import EventDTO, EventRemoteCeleryTarget
+from eolic.remote import (
+    EventRemoteTargetHandler,
+    EventRemoteCeleryDispatcher,
+    EventRemoteDispatcherFactory,
+)
+
+
+@pytest.fixture
+def app():
+    """
+    Fixture for creating a Celery app instance.
+
+    Returns:
+        Celery: An instance of Celery.
+    """
+    return Celery()
+
+
+@pytest.fixture
+def eolic():
+    """
+    Fixture for creating an Eolic instance.
+
+    Returns:
+        Eolic: An instance of Eolic.
+    """
+    return Eolic()
+
+
+@pytest.fixture
+def target_handler() -> EventRemoteTargetHandler:
+    """
+    Fixture to provide an instance of EventRemoteTargetHandler.
+
+    Returns:
+        EventRemoteTargetHandler: An instance of EventRemoteTargetHandler.
+    """
+    handler = EventRemoteTargetHandler()
+    return handler
+
+
+@pytest.fixture
+def event_remote_celery_target() -> EventRemoteCeleryTarget:
+    """
+    Fixture to provide an instance of EventRemoteCeleryTarget.
+
+    Returns:
+        EventRemoteCeleryTarget: An instance of EventRemoteCeleryTarget.
+    """
+    return EventRemoteCeleryTarget(type="celery", address="amqp://localhost:5672")
+
+
+@pytest.fixture
+def target_celery_handler(
+    event_remote_celery_target: EventRemoteCeleryTarget,
+) -> EventRemoteCeleryDispatcher:
+    """
+    Fixture to provide an instance of EventRemoteTargetHandler.
+
+    Args:
+        event_remote_celery_target (EventRemoteCeleryTarget): The EventRemoteCeleryTarget instance.
+
+    Returns:
+        EventRemoteTargetHandler: An instance of EventRemoteTargetHandler.
+    """
+    event_remote_celery_dispatcher = EventRemoteCeleryDispatcher(
+        event_remote_celery_target
+    )
+
+    return event_remote_celery_dispatcher
+
+
+@pytest.fixture
+def event_dto():
+    """
+    Fixture for creating an EventDTO instance.
+
+    Returns:
+        EventDTO: An instance of EventDTO with predefined attributes.
+    """
+    return EventDTO(event="test_event", args=("arg1",), kwargs={"key": "value"})
+
+
+def test_celery_integration_init(eolic: Eolic, app: Celery):
+    """
+    Test initialization of CeleryIntegration.
+
+    Args:
+        eolic (Eolic): The Eolic instance.
+        app (Celery): The Celery app instance.
+    """
+    integration = CeleryIntegration(app=app)
+    eolic.setup_integration(integration)
+
+    assert integration.eolic is not None
+    assert integration.app == app
+    assert integration.event_function == "events"
+    assert integration.queue_name == "eolic"
+
+
+def test_celery_integration_no_app():
+    """
+    Test that an exception is raised when CeleryIntegration is initialized with no app.
+    """
+    with pytest.raises(
+        Exception, match="Please declare you app to setup the integration."
+    ):
+        CeleryIntegration(app=None)
+
+
+def test_celery_not_installed(
+    monkeypatch: pytest.MonkeyPatch,
+    app: Celery,
+    target_celery_handler: EventRemoteCeleryDispatcher,
+    event_remote_celery_target: EventRemoteCeleryTarget,
+):
+    """
+    Test that an exception is raised when Celery is not installed.
+
+    Args:
+        monkeypatch: The pytest monkeypatch fixture.
+        app (Celery): The Celery app instance.
+        target_celery_handler (EventRemoteCeleryDispatcher): The EventRemoteCeleryDispatcher instance.
+        event_remote_celery_target (EventRemoteCeleryTarget): The EventRemoteCeleryTarget instance.
+    """
+    monkeypatch.setattr(importlib.util, "find_spec", lambda _: None)
+
+    with pytest.raises(Exception, match="Celery Integration is not installed.*"):
+        CeleryIntegration(app=app)
+
+    with pytest.raises(Exception, match="Celery Integration is not installed.*"):
+        EventRemoteCeleryDispatcher(event_remote_celery_target)
+
+
+def test_celery_empty_event_function(eolic: Eolic, app: Celery):
+    """
+    Test that an exception is raised when event_route is None.
+
+    Args:
+        eolic (Eolic): The Eolic instance.
+        app (Celery): The Celery app instance.
+    """
+    integration = CeleryIntegration(app, event_function=None)
+    with pytest.raises(
+        Exception, match="Event function is required for Celery integration."
+    ):
+        eolic.setup_integration(integration)
+
+
+def test_celery_listener_event(
+    monkeypatch: pytest.MonkeyPatch, eolic: Eolic, app: Celery
+):
+    """
+    Test that an exception is raised when event_route is None.
+
+    Args:
+        monkeypatch: The pytest monkeypatch fixture.
+        eolic (Eolic): The Eolic instance.
+        app (Celery): The Celery app instance.
+    """
+    integration = CeleryIntegration(app, event_function="event")
+    integration.setup(eolic)
+
+    def mock_lambda_handler(event, *args, **kwargs):
+        return event, args, kwargs
+
+    monkeypatch.setattr(integration, "forward_event", mock_lambda_handler)
+
+    integration.app.tasks["event"]("test_event", "arg1", key="value")
+
+
+def test_celery_module(eolic: Eolic, app: Celery):
+    """
+    Test that an exception is raised when event_route is None.
+
+    Args:
+        eolic (Eolic): The Eolic instance.
+        app (Celery): The Celery app instance.
+    """
+    assert isinstance(get_module("celery").Celery(), Celery)
+
+
+def test_parse_celery_target(target_handler: EventRemoteTargetHandler) -> None:
+    """
+    Test parsing a dictionary target.
+
+    Args:
+        target_handler (EventRemoteTargetHandler): An instance of EventRemoteTargetHandler.
+    """
+    target = {
+        "type": "celery",
+        "address": "amqp://localhost:5672",
+        "queue_name": "q",
+        "function_name": "f",
+    }
+
+    parsed_target = target_handler._parse_target(target)
+
+    assert isinstance(parsed_target, EventRemoteCeleryTarget)
+    assert parsed_target.address == "amqp://localhost:5672"
+    assert parsed_target.function_name == "f"
+    assert parsed_target.queue_name == "q"
+
+
+@pytest.mark.asyncio
+async def test_target_celery_handler(
+    monkeypatch: pytest.MonkeyPatch,
+    target_celery_handler: EventRemoteCeleryDispatcher,
+) -> None:
+    """
+    Test parsing a dictionary target.
+
+    Args:
+        monkeypatch: The pytest monkeypatch fixture.
+        target_celery_handler (EventRemoteCeleryDispatcher): An instance of EventRemoteCeleryDispatcher.
+    """
+
+    class Events(str, Enum):
+
+        event = "event"
+
+    def send_task_mock(function_name: str, *args, **kwargs):
+        print("{} - {} - {}".format(function_name, args, kwargs))
+
+    monkeypatch.setattr(target_celery_handler.celery, "send_task", send_task_mock)
+
+    await target_celery_handler.dispatch(Events.event, "1", "2", "3", k={"4": "4"})
+
+
+async def test_event_remote_dispatcher_factory(
+    target_celery_handler: EventRemoteCeleryDispatcher,
+    event_remote_celery_target: EventRemoteCeleryTarget,
+) -> None:
+    """
+    Test parsing a dictionary target.
+
+    Args:
+        target_celery_handler (EventRemoteCeleryDispatcher): An instance of EventRemoteCeleryDispatcher.
+        event_remote_celery_target (EventRemoteCeleryTarget): The EventRemoteCeleryTarget instance.
+    """
+
+    EventRemoteDispatcherFactory().create(event_remote_celery_target)

requirements.txt

@@ -1,9 +1,11 @@
-import sys
-from fastapi.testclient import TestClient
+import importlib.util
+
 import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
 from eolic.base import Eolic
 from eolic.integrations.fastapi import FastAPIIntegration
-from fastapi import FastAPI
 from eolic.model import EventDTO
 
 
@@ -96,7 +98,8 @@ def test_fastapi_not_installed(monkeypatch: pytest.MonkeyPatch, app: FastAPI):
         monkeypatch: The pytest monkeypatch fixture.
         app (FastAPI): The FastAPI app instance.
     """
-    monkeypatch.delitem(sys.modules, "fastapi", raising=False)
+    monkeypatch.setattr(importlib.util, "find_spec", lambda _: None)
+
     with pytest.raises(Exception, match="FastAPI Integration is not installed..*"):
         FastAPIIntegration(app=app)
 

tests/integrations/test_celery.py

@@ -5,9 +5,11 @@
 to remote targets using the EventRemoteTargetHandler class.
 """
 
+from unittest.mock import patch
+
 import pytest
+
 from eolic.remote import EventRemoteTargetHandler, EventRemoteURLTarget
-from unittest.mock import patch
 from tests.common import GameEvents
 
 
@@ -79,6 +81,27 @@ def test_parse_invalid_target(target_handler: EventRemoteTargetHandler) -> None:
         target_handler._parse_target(123)  # Invalid type
 
 
+def test_parse_target_type_error(target_handler: EventRemoteTargetHandler) -> None:
+    """
+    Test handling of invalid target formats.
+
+    Args:
+        target_handler (EventRemoteTargetHandler): An instance of EventRemoteTargetHandler.
+    """
+    with pytest.raises(TypeError):
+        target_handler._parse_target({"type": 123})  # Invalid type
+
+
+def test_event_remote_type_not_exists(target_handler: EventRemoteTargetHandler) -> None:
+    """
+    Test handling of invalid target formats.
+
+    Args:
+        target_handler (EventRemoteTargetHandler): An instance of EventRemoteTargetHandler.
+    """
+    target_handler._parse_target({"type": "rabbitmq", "address": ""})
+
+
 # Registering Targets