tests: add test

Author: giancarloromeo

packages/models-library/src/models_library/rpc/notifications/messages.py

@@ -1,5 +1,5 @@
 from abc import ABC
-from typing import Annotated, Any, Literal, TypeAlias
+from typing import Annotated, Any, TypeAlias
 
 from pydantic import BaseModel, Field
 
@@ -9,12 +9,12 @@ class BaseRecipient(BaseModel, ABC):
 
 
 class SMSRecipient(BaseRecipient):
-    type: Literal["sms"]
+    type: Annotated[str, Field(frozen=True)] = "sms"
     phone_number: str
 
 
 class EmailRecipient(BaseRecipient):
-    type: Literal["email"]
+    type: Annotated[str, Field(frozen=True)] = "email"
     address: str
 
 

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/notifications/messages.py

@@ -2,7 +2,7 @@
 
 from models_library.api_schemas_notifications import NOTIFICATIONS_RPC_NAMESPACE
 from models_library.rabbitmq_basic_types import RPCMethodName
-from models_library.rpc.notifications.messages import NotificationMessage, Recipient
+from models_library.rpc.notifications.messages import BaseRecipient, NotificationMessage
 from pydantic import NonNegativeInt, TypeAdapter
 
 from ... import RabbitMQRPCClient
@@ -14,7 +14,7 @@ async def send_notification_message(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     message: NotificationMessage,
-    recipients: list[Recipient],
+    recipients: list[BaseRecipient],
 ) -> None:
     await rabbitmq_rpc_client.request(
         NOTIFICATIONS_RPC_NAMESPACE,

services/notifications/src/simcore_service_notifications/api/rest/_health.py

@@ -4,13 +4,11 @@
 from fastapi import APIRouter, Depends
 from models_library.api_schemas__common.health import HealthCheckGet
 from models_library.errors import (
-    POSRGRES_DATABASE_UNHEALTHY_MSG,
     RABBITMQ_CLIENT_UNHEALTHY_MSG,
 )
 from servicelib.rabbitmq import RabbitMQClient
 
-from ...clients.postgres import PostgresLiveness
-from .dependencies import get_postgres_liveness, get_rabbitmq_client
+from .dependencies import get_rabbitmq_client
 
 router = APIRouter()
 
@@ -22,12 +20,8 @@ class HealthCheckError(RuntimeError):
 @router.get("/", response_model=HealthCheckGet)
 async def check_service_health(
     rabbitmq_client: Annotated[RabbitMQClient, Depends(get_rabbitmq_client)],
-    postgres_liveness: Annotated[PostgresLiveness, Depends(get_postgres_liveness)],
 ):
     if not rabbitmq_client.healthy:
         raise HealthCheckError(RABBITMQ_CLIENT_UNHEALTHY_MSG)
 
-    if not postgres_liveness.is_responsive:
-        raise HealthCheckError(POSRGRES_DATABASE_UNHEALTHY_MSG)
-
     return HealthCheckGet(timestamp=f"{__name__}@{arrow.utcnow().datetime.isoformat()}")

services/notifications/src/simcore_service_notifications/api/rest/dependencies.py

@@ -5,9 +5,6 @@
 from fastapi import Depends, FastAPI, Request
 from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
 
-from ...clients.postgres import PostgresLiveness
-from ...clients.postgres import get_postgres_liveness as get_postgress_db_liveness
-
 
 def get_application(request: Request) -> FastAPI:
     return cast(FastAPI, request.app)
@@ -18,9 +15,3 @@ def get_rabbitmq_client(
 ) -> RabbitMQRPCClient:
     assert isinstance(app.state.rabbitmq_rpc_server, RabbitMQRPCClient)  # nosec
     return app.state.rabbitmq_rpc_server
-
-
-def get_postgres_liveness(
-    app: Annotated[FastAPI, Depends(get_application)],
-) -> PostgresLiveness:
-    return get_postgress_db_liveness(app)

services/notifications/src/simcore_service_notifications/clients/postgres/__init__.py

@@ -8,13 +8,11 @@
 )
 from servicelib.fastapi.postgres_lifespan import (
     create_postgres_database_input_state,
-    postgres_database_lifespan,
 )
 
 from .._meta import APP_FINISHED_BANNER_MSG, APP_STARTED_BANNER_MSG
 from ..api.rpc.routes import rpc_api_routes_lifespan
 from ..clients.celery import celery_lifespan
-from ..clients.postgres import postgres_lifespan
 from ..clients.rabbitmq import rabbitmq_lifespan
 from .settings import ApplicationSettings
 
@@ -41,10 +39,6 @@ def create_app_lifespan(settings: ApplicationSettings) -> LifespanManager:
     app_lifespan = LifespanManager()
     app_lifespan.add(_settings_lifespan)
 
-    # - postgres
-    app_lifespan.add(postgres_database_lifespan)
-    app_lifespan.add(postgres_lifespan)
-
     if settings.NOTIFICATIONS_CELERY and not settings.NOTIFICATIONS_WORKER_MODE:
         # - rabbitmq
         app_lifespan.add(rabbitmq_lifespan)

services/notifications/src/simcore_service_notifications/clients/postgres/_liveness.py

@@ -15,7 +15,7 @@
     start_worker,
 )
 from celery.signals import worker_init, worker_shutdown  # type: ignore[import-untyped]
-from celery.worker.worker import WorkController  # type: ignore[import-untyped]
+from celery.worker.worker import WorkController
 from celery_library.signals import on_worker_init, on_worker_shutdown
 from models_library.basic_types import BootModeEnum
 from pytest_simcore.helpers.monkeypatch_envs import EnvVarsDict, setenvs_from_dict
@@ -32,7 +32,6 @@
     "pytest_simcore.docker_compose",
     "pytest_simcore.docker_swarm",
     "pytest_simcore.environment_configs",
-    "pytest_simcore.postgres_service",
     "pytest_simcore.rabbit_service",
     "pytest_simcore.redis_service",
     "pytest_simcore.repository_paths",
@@ -81,7 +80,7 @@ def celery_config() -> dict[str, Any]:
 
 @pytest.fixture
 async def with_celery_worker(
-    mock_environment: EnvVarsDict,
+    app_environment: EnvVarsDict,
     celery_app: Celery,
     monkeypatch: pytest.MonkeyPatch,
 ) -> AsyncIterator[TestWorkController]:

services/notifications/src/simcore_service_notifications/core/events.py

@@ -2,43 +2,62 @@
 # pylint: disable=unused-argument
 
 from collections.abc import AsyncIterator
+from typing import Final
 
 import pytest
-import sqlalchemy as sa
 from asgi_lifespan import LifespanManager
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 from pytest_simcore.helpers.monkeypatch_envs import EnvVarsDict, setenvs_from_dict
 from settings_library.rabbit import RabbitSettings
+from settings_library.redis import RedisSettings
 from simcore_service_notifications.core.application import create_app
 from simcore_service_notifications.core.settings import ApplicationSettings
 
+_LIFESPAN_TIMEOUT: Final[int] = 30
+
 
 @pytest.fixture
 def app_environment(
     monkeypatch: pytest.MonkeyPatch,
     mock_environment: EnvVarsDict,
-    rabbit_service: RabbitSettings,
-    postgres_db: sa.engine.Engine,  # waiting for postgres service to start
-    postgres_env_vars_dict: EnvVarsDict,
 ) -> EnvVarsDict:
     return setenvs_from_dict(
         monkeypatch,
         {
             **mock_environment,
-            "RABBIT_HOST": rabbit_service.RABBIT_HOST,
-            "RABBIT_PASSWORD": rabbit_service.RABBIT_PASSWORD.get_secret_value(),
-            "RABBIT_PORT": f"{rabbit_service.RABBIT_PORT}",
-            "RABBIT_SECURE": f"{rabbit_service.RABBIT_SECURE}",
-            "RABBIT_USER": rabbit_service.RABBIT_USER,
-            **postgres_env_vars_dict,
         },
     )
 
 
 @pytest.fixture
-async def initialized_app(app_environment: EnvVarsDict) -> AsyncIterator[FastAPI]:
-    app: FastAPI = create_app(ApplicationSettings.create_from_envs())
+def enabled_rabbitmq(
+    app_environment: EnvVarsDict, rabbit_service: RabbitSettings
+) -> RabbitSettings:
+    return rabbit_service
+
+
+@pytest.fixture
+def enabled_redis(
+    app_environment: EnvVarsDict, redis_service: RedisSettings
+) -> RedisSettings:
+    return redis_service
+
+
+@pytest.fixture
+def app_settings(
+    app_environment: EnvVarsDict,
+    enabled_rabbitmq: RabbitSettings,
+    enabled_redis: RedisSettings,
+) -> ApplicationSettings:
+    settings = ApplicationSettings.create_from_envs()
+    print(f"{settings.model_dump_json(indent=2)=}")
+    return settings
+
+
+@pytest.fixture
+async def initialized_app(app_settings: ApplicationSettings) -> AsyncIterator[FastAPI]:
+    app: FastAPI = create_app(app_settings)
 
     async with LifespanManager(app, startup_timeout=30, shutdown_timeout=30):
         yield app

services/notifications/tests/conftest.py

@@ -1,9 +1,28 @@
 from celery.contrib.testing.worker import TestWorkController
+from fastapi import FastAPI
+from models_library.rpc.notifications.messages import NotificationMessage
 from servicelib.rabbitmq import RabbitMQRPCClient
+from servicelib.rabbitmq.rpc_interfaces.notifications.messages import (
+    send_notification_message,
+)
+from simcore_service_notifications.clients.celery import EmailRecipient
+
+pytest_simcore_core_services_selection = [
+    "rabbit",
+    "redis",
+]
 
 
 async def test_send_email(
+    initialized_app: FastAPI,
     notifications_rabbitmq_rpc_client: RabbitMQRPCClient,
     with_celery_worker: TestWorkController,
 ):
-    pass
+    await send_notification_message(
+        notifications_rabbitmq_rpc_client,
+        message=NotificationMessage(
+            event="test_event",
+            context={"key": "value"},
+        ),
+        recipients=[EmailRecipient(address="[email protected]")],
+    )