Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

7.8 KB
Raw Blame
import { DataSource, Repository } from 'typeorm';
import { mkdtempSync, rmSync } from 'fs';
import { join } from 'path';
import { tmpdir } from 'os';
import { WebhookDeliveryFailure } from '../entities/webhook-delivery-failure.entity';
import { clearDeliveryFailureRows, recordWebhookDeliveryFailure, statusCodeFromError } from './record-delivery-failure';

const input = {
  webhookId: 'w',
  sessionId: 's',
  event: 'message.received',
  url: 'https://receiver.example',
  idempotencyKey: 'key',
  deliveryId: 'd',
  attempts: 3,
  lastStatusCode: 503,
  lastError: 'HTTP 503: down',
};

describe('webhook failure persistence', () => {
  let ds: DataSource;
  let second: DataSource;
  let directory: string;
  let repo: Repository<WebhookDeliveryFailure>;
  const logger = { error: jest.fn() };
  beforeEach(async () => {
    directory = mkdtempSync(join(tmpdir(), 'webhook-failures-'));
    const options = {
      type: 'better-sqlite3' as const,
      database: join(directory, 'data.sqlite'),
      entities: [WebhookDeliveryFailure],
    };
    ds = await new DataSource({ ...options, synchronize: true }).initialize();
    second = await new DataSource(options).initialize();
    repo = ds.getRepository(WebhookDeliveryFailure);
    logger.error.mockClear();
  });
  afterEach(async () => {
    jest.restoreAllMocks();
    await second.destroy();
    await ds.destroy();
    rmSync(directory, { recursive: true, force: true });
  });

  it('parses HTTP status while leaving network errors unclassified', () => {
    expect(statusCodeFromError('HTTP 503: down')).toBe(503);
    expect(statusCodeFromError('fetch failed')).toBeNull();
  });
  it('keeps a terminal payload and updates attempts and the latest error on repeat', async () => {
    const payload = { body: 'private' };
    await expect(recordWebhookDeliveryFailure(repo, logger, { ...input, payload })).resolves.toBe(true);
    await expect(
      recordWebhookDeliveryFailure(repo, logger, {
        ...input,
        attempts: 1,
        lastStatusCode: 504,
        lastError: 'HTTP 504: timeout',
      }),
    ).resolves.toBe(false);
    const rows = await repo.find({
      select: { id: true, attempts: true, lastStatusCode: true, lastError: true, payload: true },
    });
    expect(rows).toEqual([
      expect.objectContaining({ attempts: 4, lastStatusCode: 504, lastError: 'HTTP 504: timeout', payload }),
    ]);
  });
  it('does not resurrect an expired payload when refreshing a terminal failure', async () => {
    await recordWebhookDeliveryFailure(repo, logger, input);
    await repo.update({ idempotencyKey: 'key' }, { payload: null, createdAt: new Date(Date.now() - 25 * 3600000) });
    await recordWebhookDeliveryFailure(repo, logger, { ...input, payload: { body: 'private' } });
    const row = await repo.findOneOrFail({ where: { idempotencyKey: 'key' }, select: { id: true, payload: true } });
    expect(row.payload).toBeNull();
  });

  it('converges simultaneous recorders from two connections on one terminal identity', async () => {
    const results = await Promise.all([
      recordWebhookDeliveryFailure(repo, logger, input),
      recordWebhookDeliveryFailure(second.getRepository(WebhookDeliveryFailure), logger, { ...input, attempts: 1 }),
    ]);
    expect(results.sort()).toEqual([false, true]);
    expect(await repo.count()).toBe(1);
    expect((await repo.findOneByOrFail({ idempotencyKey: 'key' })).attempts).toBe(4);
  });
  it('replaces an unattempted row only after the terminal row is stored', async () => {
    await recordWebhookDeliveryFailure(repo, logger, { ...input, attempts: 0, payload: { body: 'unused' } });
    await recordWebhookDeliveryFailure(repo, logger, { ...input, payload: { body: 'retained' } });
    expect(await repo.count()).toBe(1);
    expect((await repo.findOneByOrFail({ idempotencyKey: 'key' })).attempts).toBe(3);
  });
  it('keeps an unattempted row when terminal persistence fails', async () => {
    await recordWebhookDeliveryFailure(repo, logger, { ...input, attempts: 0 });
    jest.spyOn(repo, 'insert').mockRejectedValueOnce(new Error('disk unavailable'));
    await expect(recordWebhookDeliveryFailure(repo, logger, input)).resolves.toBeNull();
    expect((await repo.findOneByOrFail({ idempotencyKey: 'key' })).attempts).toBe(0);
    expect(logger.error).toHaveBeenCalled();
  });
  it('returns a persistence failure when refreshing a terminal row fails', async () => {
    await recordWebhookDeliveryFailure(repo, logger, input);
    jest.spyOn(repo, 'update').mockRejectedValueOnce(new Error('disk unavailable'));
    await expect(recordWebhookDeliveryFailure(repo, logger, input)).resolves.toBeNull();
  });
  it('removes an unattempted row that an earlier terminal record left behind', async () => {
    // A crash, or a failed delete, right after the terminal insert leaves both rows. Nothing else
    // reconciles the unattempted one, so every repeat of the terminal record finishes the clean-up.
    await recordWebhookDeliveryFailure(repo, logger, input);
    await repo.insert({ ...input, attempts: 0, lastStatusCode: null, lastError: 'ConcurrencyLimiter closed' });

    await expect(recordWebhookDeliveryFailure(repo, logger, { ...input, attempts: 1 })).resolves.toBe(false);

    expect(await repo.count({ where: { attempts: 0 } })).toBe(0);
    expect((await repo.findOneByOrFail({ idempotencyKey: 'key' })).attempts).toBe(4);
  });
  it('still reports an unattempted duplicate as not recorded when refreshing its reason fails', async () => {
    // A true here would count a loss that is already counted.
    await recordWebhookDeliveryFailure(repo, logger, { ...input, attempts: 0 });
    jest.spyOn(repo, 'update').mockRejectedValueOnce(new Error('disk unavailable'));

    await expect(
      recordWebhookDeliveryFailure(repo, logger, { ...input, attempts: 0, lastError: 'too large' }),
    ).resolves.toBe(false);

    expect(logger.error).toHaveBeenCalledWith(
      'Failed to refresh the reason of an unsent webhook delivery',
      'disk unavailable',
      expect.objectContaining({ action: 'webhook_failure_record_error' }),
    );
    expect((await repo.findOneByOrFail({ idempotencyKey: 'key' })).lastError).toBe('HTTP 503: down');
  });
  it('records unkeyed losses separately and stores no replay payload by default', async () => {
    await recordWebhookDeliveryFailure(repo, logger, { ...input, idempotencyKey: undefined });
    await recordWebhookDeliveryFailure(repo, logger, { ...input, idempotencyKey: undefined });
    expect(await repo.count()).toBe(2);
    const rows = await repo.find({ select: { id: true, payload: true } });
    expect(rows.every(r => r.payload === null)).toBe(true);
  });
  it('never keeps a payload on an unattempted row and refreshes its refusal reason', async () => {
    await recordWebhookDeliveryFailure(repo, logger, { ...input, attempts: 0, payload: { body: 'unused' } });
    await recordWebhookDeliveryFailure(repo, logger, { ...input, attempts: 0, lastError: 'too large' });
    const row = await repo.findOneOrFail({
      where: { idempotencyKey: 'key' },
      select: { id: true, lastError: true, payload: true },
    });
    expect(row).toMatchObject({ lastError: 'too large', payload: null });
  });
  it('clears only the matching identity and never deletes every row for an unkeyed loss', async () => {
    await recordWebhookDeliveryFailure(repo, logger, input);
    await recordWebhookDeliveryFailure(repo, logger, { ...input, idempotencyKey: 'other' });
    await clearDeliveryFailureRows(repo, logger, 'w', undefined);
    expect(await repo.count()).toBe(2);
    await clearDeliveryFailureRows(repo, logger, 'w', 'key');
    expect(await repo.count()).toBe(1);
  });
  it('logs a failed clear without changing the delivery outcome', async () => {
    jest.spyOn(repo, 'delete').mockRejectedValueOnce(new Error('disk unavailable'));
    await expect(clearDeliveryFailureRows(repo, logger, 'w', 'key')).resolves.toBeUndefined();
    expect(logger.error).toHaveBeenCalled();
  });
});