Testing

// services/sent.service.spec.ts
const mockClient = { messages: { send: vi.fn() } };
const service = new SentService(mockClient as any, mockLogger as any);

it('send maps the SDK response into the canonical shape', async () => {
  mockClient.messages.send.mockResolvedValue({
    data: {
      status: 'QUEUED',
      template_id: '7ba7b820-9dad-11d1-80b4-00c04fd430c8',
      template_name: 'welcome',
      recipients: [{ message_id: 'msg_123', to: '+14155550123', channel: 'sms' }],
    },
  });

  const result = await service.send({
    to: ['+14155550123'],
    channel: ['sms'],
    template: { name: 'welcome' },
  });

  // SDK snake_case → contract camelCase; message_id → id.
  expect(result).toEqual({
    status: 'QUEUED',
    templateId: '7ba7b820-9dad-11d1-80b4-00c04fd430c8',
    templateName: 'welcome',
    recipients: [{ id: 'msg_123', to: '+14155550123', channel: 'sms', body: undefined }],
  });
});

# tests/test_sent_service.py — pytest-asyncio
import pytest
from unittest.mock import AsyncMock, MagicMock
from app.models.schemas import CanonicalSendRequest
from app.services.sent_service import SentService

@pytest.mark.asyncio
async def test_send_canonical_maps_response():
    data = MagicMock(
        status="QUEUED",
        template_id="7ba7b820-9dad-11d1-80b4-00c04fd430c8",
        template_name="welcome",
        recipients=[MagicMock(message_id="msg_123", to="+14155550123",
                              channel="sms", body=None)],
    )
    client = MagicMock()
    client.messages.send = AsyncMock(return_value=MagicMock(data=data))
    service = SentService(client)

    result = await service.send_canonical(CanonicalSendRequest(
        to=["+14155550123"], channel=["sms"], template={"name": "welcome"},
    ))

    # SDK snake_case → contract camelCase; message_id → id.
    assert result.status == "QUEUED"
    assert result.templateId == "7ba7b820-9dad-11d1-80b4-00c04fd430c8"
    assert result.recipients[0].id == "msg_123"

// tests/messages.integration.spec.ts
import request from 'supertest';
import { createApp } from '../app';
import { setupTestContainer } from './setup';

beforeEach(() => {
  setupTestContainer({
    sentService: {
      send: vi.fn().mockResolvedValue({
        status: 'QUEUED',
        templateId: '550e8400-e29b-41d4-a716-446655440000',
        templateName: 'welcome',
        recipients: [{ id: 'msg_123', to: '+14155550123', channel: 'sms' }],
      }),
    } as any,
  });
  app = createApp();
});

it('POST /api/messages succeeds with a valid payload', async () => {
  const res = await request(app)
    .post('/api/messages')
    .set('Authorization', 'Bearer test-key')
    .send({
      to: ['+14155550123'],
      channel: ['sms'],
      template: { name: 'welcome', parameters: { name: 'Ada' } },
    });
  expect(res.status).toBe(200);
  expect(res.body.recipients[0].id).toBe('msg_123');
});

it('POST /api/messages returns 400 for an invalid body', async () => {
  const res = await request(app)
    .post('/api/messages')
    .set('Authorization', 'Bearer test-key')
    .send({ template: { name: 'welcome' } }); // missing `to`
  expect(res.status).toBe(400);
  expect(res.body.error.code).toBe('ValidationError');
});

# tests/test_messages.py — FastAPI TestClient (see conftest.py fixtures)
from app.models.schemas import CanonicalSendResponse, CanonicalRecipient

async def fake_send_canonical(self, request):
    # Return the real response model — the route iterates result.recipients as objects.
    return CanonicalSendResponse(
        status="QUEUED",
        templateId="550e8400-e29b-41d4-a716-446655440000",
        templateName="welcome",
        recipients=[CanonicalRecipient(id="msg_123", to="+14155550123", channel="sms")],
    )

def test_send_succeeds(client, monkeypatch):
    # send_canonical is async — replace it with an async stub.
    monkeypatch.setattr(
        "app.services.sent_service.SentService.send_canonical", fake_send_canonical
    )
    res = client.post(
        "/api/messages",
        headers={"Authorization": "Bearer test-key"},
        json={
            "to": ["+14155550123"],
            "channel": ["sms"],
            "template": {"name": "welcome", "parameters": {"name": "Ada"}},
        },
    )
    assert res.status_code == 200
    assert res.json()["recipients"][0]["id"] == "msg_123"

def test_health(client):
    res = client.get("/health")
    assert res.json() == {"status": "ok", "backend": "python", "framework": "fastapi"}