pn-new-crm/tests/unit/webhook-event-map.test.ts

import { describe, it, expect } from 'vitest';
import { INTERNAL_TO_WEBHOOK_MAP, WEBHOOK_EVENTS } from '@/lib/services/webhook-event-map';

describe('INTERNAL_TO_WEBHOOK_MAP', () => {
  it('every internal event key maps to a value present in WEBHOOK_EVENTS', () => {
    const validEvents = new Set<string>(WEBHOOK_EVENTS);
    for (const [internalKey, webhookEvent] of Object.entries(INTERNAL_TO_WEBHOOK_MAP)) {
      expect(
        validEvents.has(webhookEvent),
        `"${internalKey}" maps to unknown event "${webhookEvent}"`,
      ).toBe(true);
    }
  });

  it('all webhook event values use dot-style notation (contain a dot, no colons)', () => {
    for (const webhookEvent of Object.values(INTERNAL_TO_WEBHOOK_MAP)) {
      expect(webhookEvent, `"${webhookEvent}" does not contain a dot`).toMatch(/\./);
      expect(webhookEvent, `"${webhookEvent}" contains a colon`).not.toMatch(/:/);
    }
  });

  it('"interest:stageChanged" maps to "interest.stage_changed"', () => {
    expect(INTERNAL_TO_WEBHOOK_MAP['interest:stageChanged']).toBe('interest.stage_changed');
  });

  it('"client:created" maps to "client.created"', () => {
    expect(INTERNAL_TO_WEBHOOK_MAP['client:created']).toBe('client.created');
  });

  it('"document:signed" maps to "document.signed"', () => {
    expect(INTERNAL_TO_WEBHOOK_MAP['document:signed']).toBe('document.signed');
  });

  it('"registration:new" maps to "registration.new"', () => {
    expect(INTERNAL_TO_WEBHOOK_MAP['registration:new']).toBe('registration.new');
  });

  it('has no duplicate values in the map', () => {
    const values = Object.values(INTERNAL_TO_WEBHOOK_MAP);
    const unique = new Set(values);
    expect(unique.size).toBe(values.length);
  });
});

describe('WEBHOOK_EVENTS', () => {
  it('contains all values present in INTERNAL_TO_WEBHOOK_MAP', () => {
    const eventsSet = new Set<string>(WEBHOOK_EVENTS);
    for (const webhookEvent of Object.values(INTERNAL_TO_WEBHOOK_MAP)) {
      expect(eventsSet.has(webhookEvent), `"${webhookEvent}" missing from WEBHOOK_EVENTS`).toBe(
        true,
      );
    }
  });

  it('all entries use dot-style notation', () => {
    for (const event of WEBHOOK_EVENTS) {
      expect(event).toMatch(/\./);
      expect(event).not.toMatch(/:/);
    }
  });

  it('contains "interest.stage_changed"', () => {
    expect(WEBHOOK_EVENTS).toContain('interest.stage_changed');
  });

  it('contains "client.created"', () => {
    expect(WEBHOOK_EVENTS).toContain('client.created');
  });

  it('contains "registration.new"', () => {
    expect(WEBHOOK_EVENTS).toContain('registration.new');
  });

  it('has no duplicate entries', () => {
    const unique = new Set(WEBHOOK_EVENTS);
    expect(unique.size).toBe(WEBHOOK_EVENTS.length);
  });
});

describe('new resource events (yachts, companies, memberships, reservations)', () => {
  it('includes all yacht events in the catalog', () => {
    const events = new Set<string>(WEBHOOK_EVENTS);
    ['yacht.created', 'yacht.updated', 'yacht.ownership_transferred', 'yacht.archived'].forEach(
      (e) => {
        expect(events.has(e), `missing ${e}`).toBe(true);
      },
    );
  });

  it('includes all company events', () => {
    const events = new Set<string>(WEBHOOK_EVENTS);
    ['company.created', 'company.updated', 'company.archived'].forEach((e) => {
      expect(events.has(e)).toBe(true);
    });
  });

  it('includes all membership events', () => {
    const events = new Set<string>(WEBHOOK_EVENTS);
    ['company_membership.added', 'company_membership.updated', 'company_membership.ended'].forEach(
      (e) => {
        expect(events.has(e)).toBe(true);
      },
    );
  });

  it('includes all berth reservation lifecycle events', () => {
    const events = new Set<string>(WEBHOOK_EVENTS);
    [
      'berth_reservation.created',
      'berth_reservation.activated',
      'berth_reservation.ended',
      'berth_reservation.cancelled',
    ].forEach((e) => {
      expect(events.has(e)).toBe(true);
    });
  });

  it('yacht:ownership_transferred maps to yacht.ownership_transferred', () => {
    expect(INTERNAL_TO_WEBHOOK_MAP['yacht:ownership_transferred']).toBe(
      'yacht.ownership_transferred',
    );
  });

  it('berth_reservation:activated maps to berth_reservation.activated', () => {
    expect(INTERNAL_TO_WEBHOOK_MAP['berth_reservation:activated']).toBe(
      'berth_reservation.activated',
    );
  });
});