@bernierllc/sender-identity-verification 1.0.0

package/__tests__/branch-coverage.test.ts

@@ -0,0 +1,509 @@
+/*
+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 } from '../src/SenderIdentityVerification';
+import { SenderIdentityConfig } from '../src/config';
+import { EmailProvider, SenderStatus } from '../src/types';
+
+describe('Branch Coverage Tests', () => {
+  let service: SenderIdentityVerification;
+  let config: SenderIdentityConfig;
+
+  beforeEach(() => {
+    config = {
+      emailSenderConfig: {
+        provider: 'smtp'
+      },
+      domainVerificationConfig: {},
+      verificationBaseUrl: 'https://example.com',
+      verificationFromEmail: 'verify@example.com',
+      verificationFromName: 'Verification Service'
+    };
+
+    service = new SenderIdentityVerification(config);
+  });
+
+  describe('SendVerificationEmail Branches', () => {
+    it('should handle sendVerificationEmail with undefined emailSender', async () => {
+      const createResult = await service.createSender({
+        email: 'no-sender@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      // Should succeed even without emailSender configured
+      expect(createResult.success).toBe(true);
+      expect(createResult.data?.status).toBe(SenderStatus.VERIFICATION_SENT);
+    });
+
+    it('should handle sendVerificationEmail when crypto utils not available', async () => {
+      // Service uses fallback token generation when cryptoUtils is undefined
+      const createResult = await service.createSender({
+        email: 'no-crypto@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      expect(createResult.success).toBe(true);
+      expect(createResult.data?.verificationToken).toBeDefined();
+    });
+
+    it('should resend verification and update attempts', async () => {
+      const createResult = await service.createSender({
+        email: 'resend-test@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+      sender.status = SenderStatus.PENDING;
+      sender.verificationAttempts = 1;
+
+      const resendResult = await service.resendVerification(sender.id);
+
+      expect(resendResult.success).toBe(true);
+
+      // Check that attempts were incremented
+      const senderResult = await service.getSender(sender.id);
+      expect(senderResult.data?.verificationAttempts).toBeGreaterThan(1);
+    });
+  });
+
+  describe('CreateSender Branches', () => {
+    it('should handle createSender without isDefault flag', async () => {
+      const createResult = await service.createSender({
+        email: 'no-default@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      expect(createResult.success).toBe(true);
+      expect(createResult.data?.isDefault).toBe(false);
+    });
+
+    it('should handle createSender with custom replyTo', async () => {
+      const createResult = await service.createSender({
+        email: 'custom-reply@example.com',
+        name: 'Test User',
+        replyToEmail: 'reply@example.com',
+        replyToName: 'Reply User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      expect(createResult.success).toBe(true);
+      expect(createResult.data?.replyToEmail).toBe('reply@example.com');
+      expect(createResult.data?.replyToName).toBe('Reply User');
+    });
+
+    it('should handle createSender with skipVerification true', async () => {
+      const createResult = await service.createSender({
+        email: 'skip-verify@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      expect(createResult.success).toBe(true);
+      expect(createResult.data?.status).toBe(SenderStatus.VERIFIED);
+    });
+
+    it('should handle createSender with skipVerification false', async () => {
+      const createResult = await service.createSender({
+        email: 'dont-skip-verify@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: false
+      });
+
+      expect(createResult.success).toBe(true);
+      expect(createResult.data?.status).toBe(SenderStatus.VERIFICATION_SENT);
+    });
+  });
+
+  describe('UpdateSender Branches', () => {
+    it('should handle updateSender with all optional fields undefined', async () => {
+      const createResult = await service.createSender({
+        email: 'update-undef@example.com',
+        name: 'Original Name',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const updateResult = await service.updateSender(createResult.data.id, {
+        // All fields undefined to test branches
+      });
+
+      expect(updateResult.success).toBe(true);
+    });
+
+    it('should handle updateSender with name only', async () => {
+      const createResult = await service.createSender({
+        email: 'update-name@example.com',
+        name: 'Original Name',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const updateResult = await service.updateSender(createResult.data.id, {
+        name: 'New Name'
+      });
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.name).toBe('New Name');
+    });
+
+    it('should handle updateSender with replyToName only', async () => {
+      const createResult = await service.createSender({
+        email: 'update-reply-name@example.com',
+        name: 'Original Name',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const updateResult = await service.updateSender(createResult.data.id, {
+        replyToName: 'New Reply Name'
+      });
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.replyToName).toBe('New Reply Name');
+    });
+
+    it('should handle updateSender with isDefault false', async () => {
+      const createResult = await service.createSender({
+        email: 'update-default-false@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        isDefault: true,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const updateResult = await service.updateSender(createResult.data.id, {
+        isDefault: false
+      });
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.isDefault).toBe(false);
+    });
+
+    it('should handle updateSender with isActive only', async () => {
+      const createResult = await service.createSender({
+        email: 'update-active@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const updateResult = await service.updateSender(createResult.data.id, {
+        isActive: false
+      });
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.isActive).toBe(false);
+    });
+  });
+
+  describe('ListSenders Branches', () => {
+    beforeEach(async () => {
+      // Create test data
+      await service.createSender({
+        email: 'active1@example.com',
+        name: 'Active 1',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      await service.createSender({
+        email: 'active2@example.com',
+        name: 'Active 2',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+    });
+
+    it('should list senders without any filters', async () => {
+      const result = await service.listSenders({});
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data!.length).toBeGreaterThan(0);
+    });
+
+    it('should list senders with only provider filter', async () => {
+      const result = await service.listSenders({
+        provider: EmailProvider.SMTP
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data!.every(s => s.provider === EmailProvider.SMTP)).toBe(true);
+    });
+
+    it('should list senders with only status filter', 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 list senders with only domain filter', async () => {
+      const result = await service.listSenders({
+        domain: 'example.com'
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data!.every(s => s.domain === 'example.com')).toBe(true);
+    });
+
+    it('should apply default limit when not specified', async () => {
+      const result = await service.listSenders({});
+
+      expect(result.success).toBe(true);
+      // Default limit is 50, but we should have fewer senders
+      expect(result.data!.length).toBeLessThanOrEqual(50);
+    });
+
+    it('should apply default offset when not specified', async () => {
+      const result = await service.listSenders({ limit: 1 });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+    });
+  });
+
+  describe('CheckCompliance Branches', () => {
+    it('should check compliance without domain verification', async () => {
+      const createResult = await service.createSender({
+        email: 'no-domain-check@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const complianceResult = await service.checkCompliance(createResult.data.id);
+
+      expect(complianceResult.success).toBe(true);
+      // Without domain verification, these default to true
+      expect(complianceResult.data?.checks.domainVerified).toBe(true);
+      expect(complianceResult.data?.checks.spfValid).toBe(true);
+      expect(complianceResult.data?.checks.dkimValid).toBe(true);
+    });
+
+    it('should check compliance for non-SendGrid provider', async () => {
+      const createResult = await service.createSender({
+        email: 'smtp-compliance@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const complianceResult = await service.checkCompliance(createResult.data.id);
+
+      expect(complianceResult.success).toBe(true);
+      // Non-SendGrid providers don't get the warning about missing sender ID
+      expect(complianceResult.data?.warnings).toBeDefined();
+    });
+  });
+
+  describe('ResendVerification Branches', () => {
+    it('should handle resend when verificationSentAt is undefined', async () => {
+      const createResult = await service.createSender({
+        email: 'no-sent-time@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+      sender.status = SenderStatus.PENDING;
+      sender.verificationSentAt = undefined;
+
+      const resendResult = await service.resendVerification(sender.id);
+
+      expect(resendResult.success).toBe(true);
+    });
+
+    it('should handle resend when verificationSentAt is old', async () => {
+      const createResult = await service.createSender({
+        email: 'old-sent-time@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+      sender.status = SenderStatus.PENDING;
+      sender.verificationSentAt = new Date(Date.now() - 2 * 60 * 60 * 1000); // 2 hours ago
+      sender.verificationAttempts = 5;
+
+      const resendResult = await service.resendVerification(sender.id);
+
+      expect(resendResult.success).toBe(true);
+    });
+  });
+
+  describe('VerifySender Branches', () => {
+    it('should handle verification with missing provider credentials (SendGrid)', async () => {
+      const noKeyConfig: SenderIdentityConfig = {
+        ...config,
+        sendgridApiKey: undefined
+      };
+
+      const noKeyService = new SenderIdentityVerification(noKeyConfig);
+
+      const createResult = await noKeyService.createSender({
+        email: 'no-sg-key@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SENDGRID,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+      sender.verificationToken = 'test-token';
+      sender.status = SenderStatus.VERIFICATION_SENT;
+
+      const verifyResult = await noKeyService.verifySender('test-token');
+
+      expect(verifyResult.success).toBe(false);
+      expect(verifyResult.errors).toContain('SendGrid API key not configured');
+    });
+
+    it('should handle verification with missing SES credentials', async () => {
+      const noSesConfig: SenderIdentityConfig = {
+        ...config,
+        sesAccessKey: undefined,
+        sesSecretKey: undefined,
+        sesRegion: undefined
+      };
+
+      const noSesService = new SenderIdentityVerification(noSesConfig);
+
+      const createResult = await noSesService.createSender({
+        email: 'no-ses@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SES,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+      sender.verificationToken = 'test-token';
+      sender.status = SenderStatus.VERIFICATION_SENT;
+
+      const verifyResult = await noSesService.verifySender('test-token');
+
+      expect(verifyResult.success).toBe(false);
+      expect(verifyResult.errors).toContain('SES credentials not configured');
+    });
+
+    it('should handle verification with Mailgun (no API key needed)', async () => {
+      const noMailgunConfig: SenderIdentityConfig = {
+        ...config,
+        mailgunApiKey: undefined
+      };
+
+      const noMailgunService = new SenderIdentityVerification(noMailgunConfig);
+
+      const createResult = await noMailgunService.createSender({
+        email: 'no-mg@example.com',
+        name: 'Test User',
+        provider: EmailProvider.MAILGUN,
+        skipVerification: true
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+      sender.verificationToken = 'test-token';
+      sender.status = SenderStatus.VERIFICATION_SENT;
+
+      const verifyResult = await noMailgunService.verifySender('test-token');
+
+      // Mailgun succeeds without API key
+      expect(verifyResult.success).toBe(true);
+    });
+  });
+
+  describe('Validation Branches', () => {
+    it('should use fallback email validation when emailValidator is undefined', async () => {
+      // Service uses fallback regex when emailValidator is not available
+      const createResult = await service.createSender({
+        email: 'fallback-validation@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      expect(createResult.success).toBe(true);
+    });
+
+    it('should reject invalid email with fallback validation', async () => {
+      const createResult = await service.createSender({
+        email: 'invalid@',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        skipVerification: true
+      });
+
+      expect(createResult.success).toBe(false);
+      expect(createResult.error).toContain('Invalid email');
+    });
+  });
+});

package/__tests__/config.test.ts

@@ -0,0 +1,119 @@
+/*
+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 { loadConfigFromEnv } from '../src/config';
+
+describe('Configuration', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  describe('loadConfigFromEnv', () => {
+    it('should load SendGrid config from env', () => {
+      process.env.SENDGRID_API_KEY = 'test-key';
+
+      const config = loadConfigFromEnv();
+
+      expect(config.sendgridApiKey).toBe('test-key');
+    });
+
+    it('should load Mailgun config from env', () => {
+      process.env.MAILGUN_API_KEY = 'test-mailgun-key';
+
+      const config = loadConfigFromEnv();
+
+      expect(config.mailgunApiKey).toBe('test-mailgun-key');
+    });
+
+    it('should load SES config from env', () => {
+      process.env.AWS_SES_ACCESS_KEY = 'test-ses-key';
+      process.env.AWS_SES_SECRET_KEY = 'test-ses-secret';
+      process.env.AWS_SES_REGION = 'us-west-2';
+
+      const config = loadConfigFromEnv();
+
+      expect(config.sesAccessKey).toBe('test-ses-key');
+      expect(config.sesSecretKey).toBe('test-ses-secret');
+      expect(config.sesRegion).toBe('us-west-2');
+    });
+
+    it('should load verification config', () => {
+      process.env.SENDER_VERIFICATION_FROM_EMAIL = 'verify@example.com';
+      process.env.SENDER_VERIFICATION_FROM_NAME = 'Verification Team';
+      process.env.SENDER_VERIFICATION_BASE_URL = 'https://example.com/verify';
+
+      const config = loadConfigFromEnv();
+
+      expect(config.verificationFromEmail).toBe('verify@example.com');
+      expect(config.verificationFromName).toBe('Verification Team');
+      expect(config.verificationBaseUrl).toBe('https://example.com/verify');
+    });
+
+    it('should load database URL config', () => {
+      process.env.DATABASE_URL = 'postgres://localhost/test';
+
+      const config = loadConfigFromEnv();
+
+      expect(config.databaseUrl).toBe('postgres://localhost/test');
+    });
+
+    it('should use default values for missing optional config', () => {
+      const config = loadConfigFromEnv();
+
+      expect(config).toBeDefined();
+      expect(config.verificationFromEmail).toBe('noreply@example.com');
+      expect(config.verificationFromName).toBe('Email Verification');
+      expect(config.sendgridApiKey).toBeUndefined();
+      expect(config.mailgunApiKey).toBeUndefined();
+      expect(config.sesAccessKey).toBeUndefined();
+    });
+
+    it('should load all providers config together', () => {
+      process.env.SENDGRID_API_KEY = 'sg-key';
+      process.env.MAILGUN_API_KEY = 'mg-key';
+      process.env.AWS_SES_ACCESS_KEY = 'ses-key';
+      process.env.AWS_SES_SECRET_KEY = 'ses-secret';
+      process.env.AWS_SES_REGION = 'eu-west-1';
+
+      const config = loadConfigFromEnv();
+
+      expect(config.sendgridApiKey).toBe('sg-key');
+      expect(config.mailgunApiKey).toBe('mg-key');
+      expect(config.sesAccessKey).toBe('ses-key');
+      expect(config.sesSecretKey).toBe('ses-secret');
+      expect(config.sesRegion).toBe('eu-west-1');
+    });
+
+    it('should accept config overrides', () => {
+      const config = loadConfigFromEnv({
+        emailSenderConfig: {
+          provider: 'sendgrid',
+          apiKey: 'override-key'
+        },
+        verificationBaseUrl: 'https://override.com/verify'
+      });
+
+      expect(config.emailSenderConfig.provider).toBe('sendgrid');
+      expect(config.emailSenderConfig.apiKey).toBe('override-key');
+      expect(config.verificationBaseUrl).toBe('https://override.com/verify');
+    });
+
+    it('should default SES region to us-east-1', () => {
+      const config = loadConfigFromEnv();
+
+      expect(config.sesRegion).toBe('us-east-1');
+    });
+  });
+});