@bernierllc/sender-identity-verification 1.0.0

package/__tests__/SenderIdentityVerification.test.ts

@@ -0,0 +1,461 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import {
+  SenderIdentityVerification,
+  EmailProvider,
+  SenderStatus,
+  CreateSenderInput,
+  UpdateSenderInput
+} from '../src/index';
+
+describe('SenderIdentityVerification', () => {
+  let service: SenderIdentityVerification;
+
+  beforeEach(async () => {
+    service = new SenderIdentityVerification({
+      verificationBaseUrl: 'https://test.example.com',
+      verificationFromEmail: 'noreply@test.com',
+      verificationFromName: 'Test Verification',
+      sendgridApiKey: 'test-key',
+      emailSenderConfig: {},
+      domainVerificationConfig: {}
+    });
+
+    await service.initialize();
+  });
+
+  describe('createSender', () => {
+    it('should create sender successfully with valid input', async () => {
+      const input: CreateSenderInput = {
+        email: 'sender@example.com',
+        name: 'Test Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      };
+
+      const result = await service.createSender(input);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data?.email).toBe('sender@example.com');
+      expect(result.data?.name).toBe('Test Sender');
+      expect(result.data?.status).toBe(SenderStatus.VERIFIED);
+    });
+
+    it('should create sender with pending status when not skipping verification', async () => {
+      const input: CreateSenderInput = {
+        email: 'pending@example.com',
+        name: 'Pending Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: false
+      };
+
+      const result = await service.createSender(input);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.status).toBe(SenderStatus.VERIFICATION_SENT);
+    });
+
+    it('should fail when creating duplicate sender', async () => {
+      const input: CreateSenderInput = {
+        email: 'duplicate@example.com',
+        name: 'Duplicate Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      };
+
+      // Create first sender
+      await service.createSender(input);
+
+      // Try to create duplicate
+      const result = await service.createSender(input);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('already exists');
+    });
+
+    it('should fail with invalid email format', async () => {
+      const input: CreateSenderInput = {
+        email: 'invalid-email',
+        name: 'Invalid Sender',
+        provider: EmailProvider.SENDGRID
+      };
+
+      const result = await service.createSender(input);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid email');
+    });
+
+    it('should set default reply-to email if not provided', async () => {
+      const input: CreateSenderInput = {
+        email: 'sender@example.com',
+        name: 'Test Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      };
+
+      const result = await service.createSender(input);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.replyToEmail).toBe('sender@example.com');
+      expect(result.data?.replyToName).toBe('Test Sender');
+    });
+
+    it('should use custom reply-to if provided', async () => {
+      const input: CreateSenderInput = {
+        email: 'sender@example.com',
+        name: 'Test Sender',
+        replyToEmail: 'support@example.com',
+        replyToName: 'Support Team',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      };
+
+      const result = await service.createSender(input);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.replyToEmail).toBe('support@example.com');
+      expect(result.data?.replyToName).toBe('Support Team');
+    });
+
+    it('should set isDefault correctly', async () => {
+      const input: CreateSenderInput = {
+        email: 'default@example.com',
+        name: 'Default Sender',
+        provider: EmailProvider.SENDGRID,
+        isDefault: true,
+        skipVerification: true
+      };
+
+      const result = await service.createSender(input);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.isDefault).toBe(true);
+    });
+  });
+
+  describe('getSender', () => {
+    it('should retrieve sender by ID', async () => {
+      const createResult = await service.createSender({
+        email: 'get@example.com',
+        name: 'Get Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      const senderId = createResult.data!.id;
+      const getResult = await service.getSender(senderId);
+
+      expect(getResult.success).toBe(true);
+      expect(getResult.data?.id).toBe(senderId);
+      expect(getResult.data?.email).toBe('get@example.com');
+    });
+
+    it('should fail when sender not found', async () => {
+      const result = await service.getSender('non-existent-id');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('listSenders', () => {
+    beforeEach(async () => {
+      // Create multiple senders
+      await service.createSender({
+        email: 'sendgrid1@example.com',
+        name: 'SendGrid 1',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      await service.createSender({
+        email: 'sendgrid2@example.com',
+        name: 'SendGrid 2',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      await service.createSender({
+        email: 'mailgun1@example.com',
+        name: 'Mailgun 1',
+        provider: EmailProvider.MAILGUN,
+        skipVerification: true
+      });
+    });
+
+    it('should list all senders', async () => {
+      const result = await service.listSenders();
+
+      expect(result.success).toBe(true);
+      expect(result.data?.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('should filter by provider', async () => {
+      const result = await service.listSenders({
+        provider: EmailProvider.SENDGRID
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.every(s => s.provider === EmailProvider.SENDGRID)).toBe(true);
+    });
+
+    it('should filter by status', async () => {
+      const result = await service.listSenders({
+        status: SenderStatus.VERIFIED
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.every(s => s.status === SenderStatus.VERIFIED)).toBe(true);
+    });
+
+    it('should filter by active status', async () => {
+      const result = await service.listSenders({
+        isActive: true
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.every(s => s.isActive === true)).toBe(true);
+    });
+
+    it('should handle pagination', async () => {
+      const result = await service.listSenders({
+        limit: 2,
+        offset: 0
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.length).toBeLessThanOrEqual(2);
+    });
+  });
+
+  describe('updateSender', () => {
+    it('should update sender name', async () => {
+      const createResult = await service.createSender({
+        email: 'update@example.com',
+        name: 'Original Name',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      const senderId = createResult.data!.id;
+      const updateInput: UpdateSenderInput = {
+        name: 'Updated Name'
+      };
+
+      const updateResult = await service.updateSender(senderId, updateInput);
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.name).toBe('Updated Name');
+    });
+
+    it('should update reply-to email', async () => {
+      const createResult = await service.createSender({
+        email: 'update@example.com',
+        name: 'Test',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      const senderId = createResult.data!.id;
+      const updateInput: UpdateSenderInput = {
+        replyToEmail: 'new-reply@example.com'
+      };
+
+      const updateResult = await service.updateSender(senderId, updateInput);
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.replyToEmail).toBe('new-reply@example.com');
+    });
+
+    it('should set isDefault and unset other defaults', async () => {
+      // Create two senders
+      const sender1 = await service.createSender({
+        email: 'sender1@example.com',
+        name: 'Sender 1',
+        provider: EmailProvider.SENDGRID,
+        isDefault: true,
+        skipVerification: true
+      });
+
+      const sender2 = await service.createSender({
+        email: 'sender2@example.com',
+        name: 'Sender 2',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      // Set sender2 as default
+      await service.updateSender(sender2.data!.id, { isDefault: true });
+
+      // Check that sender1 is no longer default
+      const getSender1 = await service.getSender(sender1.data!.id);
+      expect(getSender1.data?.isDefault).toBe(false);
+
+      // Check that sender2 is default
+      const getSender2 = await service.getSender(sender2.data!.id);
+      expect(getSender2.data?.isDefault).toBe(true);
+    });
+
+    it('should fail when updating non-existent sender', async () => {
+      const result = await service.updateSender('non-existent', { name: 'Test' });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('deleteSender', () => {
+    it('should soft delete sender', async () => {
+      const createResult = await service.createSender({
+        email: 'delete@example.com',
+        name: 'Delete Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      const senderId = createResult.data!.id;
+      const deleteResult = await service.deleteSender(senderId);
+
+      expect(deleteResult.success).toBe(true);
+
+      // Should not be able to get deleted sender
+      const getResult = await service.getSender(senderId);
+      expect(getResult.success).toBe(false);
+    });
+
+    it('should fail when deleting non-existent sender', async () => {
+      const result = await service.deleteSender('non-existent');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('verifySender', () => {
+    it('should verify sender with valid token', async () => {
+      const createResult = await service.createSender({
+        email: 'verify@example.com',
+        name: 'Verify Sender',
+        provider: EmailProvider.SMTP, // Use SMTP to avoid provider API calls
+        skipVerification: false
+      });
+
+      const sender = createResult.data!;
+
+      // Get the verification token from the sender
+      const senderResult = await service.getSender(sender.id);
+      const token = senderResult.data!.verificationToken!;
+
+      // Verify with token
+      const verifyResult = await service.verifySender(token);
+
+      expect(verifyResult.success).toBe(true);
+      expect(verifyResult.status).toBe(SenderStatus.VERIFIED);
+      expect(verifyResult.verifiedAt).toBeDefined();
+    });
+
+    it('should return already verified for already verified sender', async () => {
+      await service.createSender({
+        email: 'already@example.com',
+        name: 'Already Verified',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      // Try to verify with a fake token (sender is already verified)
+      const result = await service.verifySender('fake-token');
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('Invalid');
+    });
+
+    it('should fail with invalid token', async () => {
+      const result = await service.verifySender('invalid-token');
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Token not found or already used');
+    });
+  });
+
+  describe('getDefaultSender', () => {
+    it('should return default sender for provider', async () => {
+      await service.createSender({
+        email: 'default@example.com',
+        name: 'Default Sender',
+        provider: EmailProvider.SENDGRID,
+        isDefault: true,
+        skipVerification: true
+      });
+
+      const result = await service.getDefaultSender(EmailProvider.SENDGRID);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.email).toBe('default@example.com');
+      expect(result.data?.isDefault).toBe(true);
+    });
+
+    it('should fail when no default sender exists', async () => {
+      const result = await service.getDefaultSender(EmailProvider.MAILGUN);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('No default sender found');
+    });
+  });
+
+  describe('checkCompliance', () => {
+    it('should check compliance for sender', async () => {
+      const createResult = await service.createSender({
+        email: 'compliance@example.com',
+        name: 'Compliance Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      const senderId = createResult.data!.id;
+      const complianceResult = await service.checkCompliance(senderId);
+
+      expect(complianceResult.success).toBe(true);
+      expect(complianceResult.data?.checks).toBeDefined();
+      expect(complianceResult.data?.checks.emailFormat).toBe(true);
+    });
+
+    it('should fail when checking compliance for non-existent sender', async () => {
+      const result = await service.checkCompliance('non-existent');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+  });
+
+  describe('resendVerification', () => {
+    it('should fail when resending for verified sender', async () => {
+      const createResult = await service.createSender({
+        email: 'resend@example.com',
+        name: 'Resend Sender',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      const senderId = createResult.data!.id;
+      const result = await service.resendVerification(senderId);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('already verified');
+    });
+
+    it('should fail when resending for non-existent sender', async () => {
+      const result = await service.resendVerification('non-existent');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+  });
+});

package/__tests__/__mocks__/fetch-mock.ts

@@ -0,0 +1,156 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+/**
+ * Fetch mock utilities for testing HTTP calls
+ */
+
+export interface MockResponse {
+  status: number;
+  ok: boolean;
+  statusText: string;
+  data: unknown;
+}
+
+export class FetchMock {
+  private responses: Map<string, MockResponse[]> = new Map();
+  private callHistory: Array<{ url: string; method: string; body?: string }> = [];
+
+  /**
+   * Mock a successful response
+   */
+  mockSuccess(url: string, data: unknown, status = 200): void {
+    const existing = this.responses.get(url) || [];
+    existing.push({
+      status,
+      ok: true,
+      statusText: 'OK',
+      data
+    });
+    this.responses.set(url, existing);
+  }
+
+  /**
+   * Mock an error response
+   */
+  mockError(url: string, status: number, data: unknown): void {
+    const existing = this.responses.get(url) || [];
+    existing.push({
+      status,
+      ok: false,
+      statusText: this.getStatusText(status),
+      data
+    });
+    this.responses.set(url, existing);
+  }
+
+  /**
+   * Mock a network error
+   */
+  mockNetworkError(url: string, message = 'Network error'): void {
+    const existing = this.responses.get(url) || [];
+    existing.push({
+      status: 0,
+      ok: false,
+      statusText: 'Network Error',
+      data: { error: message }
+    });
+    this.responses.set(url, existing);
+  }
+
+  /**
+   * Get the mock fetch function
+   */
+  getFetchMock(): typeof fetch {
+    return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+      const url = typeof input === 'string' ? input : input.toString();
+      const method = init?.method || 'GET';
+      const body = init?.body?.toString();
+
+      // Record the call
+      this.callHistory.push({ url, method, body });
+
+      // Get response for this URL
+      const responses = this.responses.get(url);
+      if (!responses || responses.length === 0) {
+        throw new Error(`No mock response configured for ${method} ${url}`);
+      }
+
+      // Get and remove first response (FIFO)
+      const response = responses.shift()!;
+
+      // Network error case
+      if (response.status === 0) {
+        throw new Error(response.data && typeof response.data === 'object' && 'error' in response.data
+          ? String(response.data.error)
+          : 'Network error');
+      }
+
+      // Create mock Response object
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => response.data,
+        text: async () => JSON.stringify(response.data),
+        blob: async () => new Blob(),
+        arrayBuffer: async () => new ArrayBuffer(0),
+        formData: async () => new FormData(),
+        clone: function() { return this; },
+        body: null,
+        bodyUsed: false,
+        url,
+        redirected: false,
+        type: 'basic'
+      } as Response;
+    };
+  }
+
+  /**
+   * Get call history
+   */
+  getCallHistory(): Array<{ url: string; method: string; body?: string }> {
+    return [...this.callHistory];
+  }
+
+  /**
+   * Clear all mocks
+   */
+  clear(): void {
+    this.responses.clear();
+    this.callHistory = [];
+  }
+
+  /**
+   * Get HTTP status text
+   */
+  private getStatusText(status: number): string {
+    const statusTexts: Record<number, string> = {
+      200: 'OK',
+      201: 'Created',
+      204: 'No Content',
+      400: 'Bad Request',
+      401: 'Unauthorized',
+      403: 'Forbidden',
+      404: 'Not Found',
+      429: 'Too Many Requests',
+      500: 'Internal Server Error',
+      502: 'Bad Gateway',
+      503: 'Service Unavailable'
+    };
+    return statusTexts[status] || 'Unknown';
+  }
+}
+
+/**
+ * Create a new fetch mock instance
+ */
+export function createFetchMock(): FetchMock {
+  return new FetchMock();
+}