devsms.test.ts

import { DevSmsProvider } from '../providers/devsms';
import type { SmsSendRequest } from '../providers/types';

const request: SmsSendRequest = {
  to: '+14155550123',
  body: 'Your sign-in code is 123456. Do not share this code.',
  senderId: 'TestSender',
  metadata: {
    jobId: 'job-1',
    databaseId: 'db-1',
    purpose: 'sign_in_otp'
  }
};

const jsonResponse = (body: unknown, status = 201): Response =>
  new Response(JSON.stringify(body), {
    status,
    headers: { 'content-type': 'application/json' }
  });

describe('DevSmsProvider', () => {
  it('sends the correct URL, method, headers, and request body', async () => {
    const fetchImpl = jest.fn().mockResolvedValue(jsonResponse({
      id: 'row_1',
      provider_message_id: 'SM123',
      status: 'queued'
    }));
    const provider = new DevSmsProvider({
      baseUrl: 'http://devsms:4000',
      requestTimeoutMs: 5000,
      fetchImpl: fetchImpl as unknown as typeof fetch
    });

    await provider.send(request);

    expect(fetchImpl).toHaveBeenCalledWith(
      'http://devsms:4000/api/sms/send/twilio',
      expect.objectContaining({
        method: 'POST',
        headers: { 'content-type': 'application/json' },
        body: JSON.stringify({
          From: 'TestSender',
          To: '+14155550123',
          Body: 'Your sign-in code is 123456. Do not share this code.'
        })
      })
    );
  });

  it('maps provider responses to SmsSendResult', async () => {
    const fetchImpl = jest.fn().mockResolvedValue(jsonResponse({
      id: 'row_1',
      provider_message_id: 'SM123',
      status: 'sent'
    }));
    const provider = new DevSmsProvider({
      baseUrl: 'http://devsms:4000/',
      requestTimeoutMs: 5000,
      fetchImpl: fetchImpl as unknown as typeof fetch
    });

    await expect(provider.send(request)).resolves.toEqual({
      provider: 'devsms',
      messageId: 'SM123',
      status: 'sent'
    });
  });

  it('throws for non-2xx responses without exposing the response body', async () => {
    const fetchImpl = jest.fn().mockResolvedValue(jsonResponse({
      error: 'OTP 123456 failed for +14155550123'
    }, 400));
    const provider = new DevSmsProvider({
      baseUrl: 'http://devsms:4000',
      requestTimeoutMs: 5000,
      fetchImpl: fetchImpl as unknown as typeof fetch
    });

    const error = await provider.send(request).then(
      () => undefined,
      (cause: unknown) => cause as Error
    );

    expect(error).toBeInstanceOf(Error);
    expect(error?.message).toBe('DevSmsProvider request failed with 400');
    expect(error?.message).not.toContain('123456');
    expect(error?.message).not.toContain('+14155550123');
  });

  it('throws on timeout', async () => {
    jest.useFakeTimers();
    const fetchImpl = jest.fn((_url: string, init: RequestInit) =>
      new Promise((_resolve, reject) => {
        init.signal?.addEventListener('abort', () => {
          const error = new Error('aborted');
          error.name = 'AbortError';
          reject(error);
        });
      })
    );
    const provider = new DevSmsProvider({
      baseUrl: 'http://devsms:4000',
      requestTimeoutMs: 10,
      fetchImpl: fetchImpl as unknown as typeof fetch
    });

    const promise = provider.send(request);
    jest.advanceTimersByTime(10);
    await expect(promise).rejects.toThrow('DevSmsProvider timed out after 10ms');
    jest.useRealTimers();
  });

  it('throws for invalid JSON responses', async () => {
    const fetchImpl = jest.fn().mockResolvedValue(new Response('not-json', { status: 201 }));
    const provider = new DevSmsProvider({
      baseUrl: 'http://devsms:4000',
      requestTimeoutMs: 5000,
      fetchImpl: fetchImpl as unknown as typeof fetch
    });

    await expect(provider.send(request)).rejects.toThrow('DevSmsProvider returned invalid JSON');
  });

  it('throws when the response is missing a message ID', async () => {
    const fetchImpl = jest.fn().mockResolvedValue(jsonResponse({ status: 'queued' }));
    const provider = new DevSmsProvider({
      baseUrl: 'http://devsms:4000',
      requestTimeoutMs: 5000,
      fetchImpl: fetchImpl as unknown as typeof fetch
    });

    await expect(provider.send(request)).rejects.toThrow('DevSmsProvider response missing message ID');
  });
});