@bernierllc/email-campaign-management 1.0.1

package/__tests__/hooks/useCampaignStore.test.ts

@@ -0,0 +1,450 @@
+/*
+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 { act, renderHook } from '@testing-library/react';
+import { useCampaignStore } from '../../src/hooks/useCampaignStore';
+import * as campaignAPI from '../../src/api/campaigns';
+import { Campaign } from '../../src/types';
+
+jest.mock('../../src/api/campaigns');
+
+const mockCampaignAPI = campaignAPI as jest.Mocked<typeof campaignAPI>;
+
+const createMockCampaign = (overrides: Partial<Campaign> = {}): Campaign => ({
+  id: 'campaign-1',
+  name: 'Test Campaign',
+  description: 'Test description',
+  type: 'one-time',
+  status: 'draft',
+  workflow: {
+    id: 'workflow-1',
+    nodes: [],
+    edges: []
+  },
+  audience: {
+    type: 'all'
+  },
+  schedule: {
+    type: 'immediate'
+  },
+  createdAt: new Date('2025-01-01'),
+  updatedAt: new Date('2025-01-01'),
+  createdBy: 'user-123',
+  ...overrides
+});
+
+describe('useCampaignStore', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Reset store state between tests
+    const store = useCampaignStore.getState();
+    store.campaigns = [];
+    store.activeCampaign = null;
+    store.loading = false;
+    store.error = null;
+  });
+
+  describe('initial state', () => {
+    it('should have empty campaigns array', () => {
+      const { result } = renderHook(() => useCampaignStore());
+      expect(result.current.campaigns).toEqual([]);
+    });
+
+    it('should have null activeCampaign', () => {
+      const { result } = renderHook(() => useCampaignStore());
+      expect(result.current.activeCampaign).toBeNull();
+    });
+
+    it('should have loading false', () => {
+      const { result } = renderHook(() => useCampaignStore());
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('should have null error', () => {
+      const { result } = renderHook(() => useCampaignStore());
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe('fetchCampaigns', () => {
+    it('should set loading to true while fetching', async () => {
+      mockCampaignAPI.getCampaigns.mockImplementation(
+        () => new Promise((resolve) => setTimeout(() => resolve({
+          success: true,
+          data: []
+        }), 100))
+      );
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      act(() => {
+        result.current.fetchCampaigns();
+      });
+
+      expect(result.current.loading).toBe(true);
+    });
+
+    it('should fetch and store campaigns on success', async () => {
+      const mockCampaigns = [
+        createMockCampaign({ id: 'campaign-1', name: 'Campaign 1' }),
+        createMockCampaign({ id: 'campaign-2', name: 'Campaign 2' })
+      ];
+
+      mockCampaignAPI.getCampaigns.mockResolvedValue({
+        success: true,
+        data: mockCampaigns
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.fetchCampaigns();
+      });
+
+      expect(result.current.campaigns).toEqual(mockCampaigns);
+      expect(result.current.loading).toBe(false);
+      expect(result.current.error).toBeNull();
+    });
+
+    it('should set error on failure', async () => {
+      mockCampaignAPI.getCampaigns.mockResolvedValue({
+        success: false,
+        error: 'Failed to fetch campaigns'
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.fetchCampaigns();
+      });
+
+      expect(result.current.error).toBe('Failed to fetch campaigns');
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('should use default error message when no error provided', async () => {
+      mockCampaignAPI.getCampaigns.mockResolvedValue({
+        success: false
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.fetchCampaigns();
+      });
+
+      expect(result.current.error).toBe('Failed to fetch campaigns');
+    });
+
+    it('should clear previous error before fetching', async () => {
+      // Set up initial error state
+      const store = useCampaignStore.getState();
+      store.error = 'Previous error';
+
+      mockCampaignAPI.getCampaigns.mockResolvedValue({
+        success: true,
+        data: []
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.fetchCampaigns();
+      });
+
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe('createCampaign', () => {
+    it('should create campaign and add to store on success', async () => {
+      const newCampaign = createMockCampaign({ id: 'new-campaign', name: 'New Campaign' });
+
+      mockCampaignAPI.createCampaign.mockResolvedValue({
+        success: true,
+        data: newCampaign
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      let createdCampaign: Campaign | null = null;
+      await act(async () => {
+        createdCampaign = await result.current.createCampaign({ name: 'New Campaign' });
+      });
+
+      expect(createdCampaign).toEqual(newCampaign);
+      expect(result.current.campaigns).toContainEqual(newCampaign);
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('should set loading while creating', async () => {
+      mockCampaignAPI.createCampaign.mockImplementation(
+        () => new Promise((resolve) => setTimeout(() => resolve({
+          success: true,
+          data: createMockCampaign()
+        }), 100))
+      );
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      act(() => {
+        result.current.createCampaign({ name: 'Test' });
+      });
+
+      expect(result.current.loading).toBe(true);
+    });
+
+    it('should set error and return null on failure', async () => {
+      mockCampaignAPI.createCampaign.mockResolvedValue({
+        success: false,
+        error: 'Creation failed'
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      let createdCampaign: Campaign | null = null;
+      await act(async () => {
+        createdCampaign = await result.current.createCampaign({ name: 'Test' });
+      });
+
+      expect(createdCampaign).toBeNull();
+      expect(result.current.error).toBe('Creation failed');
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('should use default error message when no error provided', async () => {
+      mockCampaignAPI.createCampaign.mockResolvedValue({
+        success: false
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.createCampaign({ name: 'Test' });
+      });
+
+      expect(result.current.error).toBe('Failed to create campaign');
+    });
+  });
+
+  describe('updateCampaign', () => {
+    beforeEach(() => {
+      const store = useCampaignStore.getState();
+      store.campaigns = [
+        createMockCampaign({ id: 'campaign-1', name: 'Campaign 1' }),
+        createMockCampaign({ id: 'campaign-2', name: 'Campaign 2' })
+      ];
+    });
+
+    it('should update campaign in store on success', async () => {
+      const updatedCampaign = createMockCampaign({ id: 'campaign-1', name: 'Updated Name' });
+
+      mockCampaignAPI.updateCampaign.mockResolvedValue({
+        success: true,
+        data: updatedCampaign
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.updateCampaign('campaign-1', { name: 'Updated Name' });
+      });
+
+      const updated = result.current.campaigns.find(c => c.id === 'campaign-1');
+      expect(updated?.name).toBe('Updated Name');
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('should update activeCampaign if it matches the updated campaign', async () => {
+      const store = useCampaignStore.getState();
+      store.activeCampaign = createMockCampaign({ id: 'campaign-1', name: 'Original' });
+
+      const updatedCampaign = createMockCampaign({ id: 'campaign-1', name: 'Updated Active' });
+
+      mockCampaignAPI.updateCampaign.mockResolvedValue({
+        success: true,
+        data: updatedCampaign
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.updateCampaign('campaign-1', { name: 'Updated Active' });
+      });
+
+      expect(result.current.activeCampaign?.name).toBe('Updated Active');
+    });
+
+    it('should not update activeCampaign if it does not match', async () => {
+      const store = useCampaignStore.getState();
+      store.activeCampaign = createMockCampaign({ id: 'campaign-2', name: 'Other Campaign' });
+
+      const updatedCampaign = createMockCampaign({ id: 'campaign-1', name: 'Updated' });
+
+      mockCampaignAPI.updateCampaign.mockResolvedValue({
+        success: true,
+        data: updatedCampaign
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.updateCampaign('campaign-1', { name: 'Updated' });
+      });
+
+      expect(result.current.activeCampaign?.name).toBe('Other Campaign');
+    });
+
+    it('should set error on failure', async () => {
+      mockCampaignAPI.updateCampaign.mockResolvedValue({
+        success: false,
+        error: 'Update failed'
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.updateCampaign('campaign-1', { name: 'Test' });
+      });
+
+      expect(result.current.error).toBe('Update failed');
+    });
+
+    it('should use default error message when no error provided', async () => {
+      mockCampaignAPI.updateCampaign.mockResolvedValue({
+        success: false
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.updateCampaign('campaign-1', { name: 'Test' });
+      });
+
+      expect(result.current.error).toBe('Failed to update campaign');
+    });
+  });
+
+  describe('deleteCampaign', () => {
+    beforeEach(() => {
+      const store = useCampaignStore.getState();
+      store.campaigns = [
+        createMockCampaign({ id: 'campaign-1', name: 'Campaign 1' }),
+        createMockCampaign({ id: 'campaign-2', name: 'Campaign 2' })
+      ];
+    });
+
+    it('should remove campaign from store on success', async () => {
+      mockCampaignAPI.deleteCampaign.mockResolvedValue({
+        success: true
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.deleteCampaign('campaign-1');
+      });
+
+      expect(result.current.campaigns.find(c => c.id === 'campaign-1')).toBeUndefined();
+      expect(result.current.campaigns).toHaveLength(1);
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('should clear activeCampaign if it matches deleted campaign', async () => {
+      const store = useCampaignStore.getState();
+      store.activeCampaign = createMockCampaign({ id: 'campaign-1' });
+
+      mockCampaignAPI.deleteCampaign.mockResolvedValue({
+        success: true
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.deleteCampaign('campaign-1');
+      });
+
+      expect(result.current.activeCampaign).toBeNull();
+    });
+
+    it('should not clear activeCampaign if it does not match deleted campaign', async () => {
+      const store = useCampaignStore.getState();
+      store.activeCampaign = createMockCampaign({ id: 'campaign-2' });
+
+      mockCampaignAPI.deleteCampaign.mockResolvedValue({
+        success: true
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.deleteCampaign('campaign-1');
+      });
+
+      expect(result.current.activeCampaign?.id).toBe('campaign-2');
+    });
+
+    it('should set error on failure', async () => {
+      mockCampaignAPI.deleteCampaign.mockResolvedValue({
+        success: false,
+        error: 'Delete failed'
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.deleteCampaign('campaign-1');
+      });
+
+      expect(result.current.error).toBe('Delete failed');
+      // Campaign should still be in the list
+      expect(result.current.campaigns).toHaveLength(2);
+    });
+
+    it('should use default error message when no error provided', async () => {
+      mockCampaignAPI.deleteCampaign.mockResolvedValue({
+        success: false
+      });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      await act(async () => {
+        await result.current.deleteCampaign('campaign-1');
+      });
+
+      expect(result.current.error).toBe('Failed to delete campaign');
+    });
+  });
+
+  describe('setActiveCampaign', () => {
+    it('should set the active campaign', () => {
+      const campaign = createMockCampaign({ id: 'campaign-1', name: 'Active Campaign' });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      act(() => {
+        result.current.setActiveCampaign(campaign);
+      });
+
+      expect(result.current.activeCampaign).toEqual(campaign);
+    });
+
+    it('should clear the active campaign when set to null', () => {
+      const store = useCampaignStore.getState();
+      store.activeCampaign = createMockCampaign({ id: 'campaign-1' });
+
+      const { result } = renderHook(() => useCampaignStore());
+
+      act(() => {
+        result.current.setActiveCampaign(null);
+      });
+
+      expect(result.current.activeCampaign).toBeNull();
+    });
+  });
+});

package/__tests__/hooks/useWorkflowValidation.test.ts

@@ -0,0 +1,176 @@
+/*
+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 { renderHook } from '@testing-library/react';
+import { useWorkflowValidation } from '../../src/hooks/useWorkflowValidation';
+import { CampaignWorkflow } from '../../src/types';
+
+describe('useWorkflowValidation', () => {
+  const createValidWorkflow = (): CampaignWorkflow => ({
+    id: 'workflow-1',
+    nodes: [
+      {
+        id: 'email-1',
+        type: 'email',
+        position: { x: 0, y: 0 },
+        data: { templateId: 'template-1' }
+      },
+      {
+        id: 'email-2',
+        type: 'email',
+        position: { x: 200, y: 0 },
+        data: { templateId: 'template-2' }
+      }
+    ],
+    edges: [
+      {
+        id: 'edge-1',
+        source: 'email-1',
+        target: 'email-2'
+      }
+    ]
+  });
+
+  it('should return valid result for a valid workflow', () => {
+    const workflow = createValidWorkflow();
+    const { result } = renderHook(() => useWorkflowValidation(workflow));
+
+    expect(result.current.valid).toBe(true);
+    expect(result.current.errors).toEqual([]);
+  });
+
+  it('should return errors for workflow without nodes', () => {
+    const workflow: CampaignWorkflow = {
+      id: 'workflow-1',
+      nodes: [],
+      edges: []
+    };
+
+    const { result } = renderHook(() => useWorkflowValidation(workflow));
+
+    expect(result.current.valid).toBe(false);
+    expect(result.current.errors.length).toBeGreaterThan(0);
+  });
+
+  it('should memoize result when workflow does not change', () => {
+    const workflow = createValidWorkflow();
+    const { result, rerender } = renderHook(() => useWorkflowValidation(workflow));
+
+    const firstResult = result.current;
+    rerender();
+    const secondResult = result.current;
+
+    expect(firstResult).toBe(secondResult);
+  });
+
+  it('should recompute when workflow changes', () => {
+    let workflow = createValidWorkflow();
+    const { result, rerender } = renderHook(
+      ({ wf }) => useWorkflowValidation(wf),
+      { initialProps: { wf: workflow } }
+    );
+
+    const firstResult = result.current;
+    expect(firstResult.valid).toBe(true);
+
+    // Change workflow to invalid one
+    const invalidWorkflow: CampaignWorkflow = {
+      id: 'workflow-2',
+      nodes: [],
+      edges: []
+    };
+
+    rerender({ wf: invalidWorkflow });
+    const secondResult = result.current;
+
+    expect(secondResult.valid).toBe(false);
+    expect(firstResult).not.toBe(secondResult);
+  });
+
+  it('should return errors for empty workflow', () => {
+    const workflow: CampaignWorkflow = {
+      id: 'workflow-1',
+      nodes: [],
+      edges: []
+    };
+
+    const { result } = renderHook(() => useWorkflowValidation(workflow));
+
+    expect(result.current.valid).toBe(false);
+    expect(result.current.errors.length).toBeGreaterThan(0);
+  });
+
+  it('should validate workflow with multiple email nodes', () => {
+    const workflow: CampaignWorkflow = {
+      id: 'workflow-1',
+      nodes: [
+        {
+          id: 'email-1',
+          type: 'email',
+          position: { x: 0, y: 0 },
+          data: { templateId: 'template-1' }
+        },
+        {
+          id: 'delay-1',
+          type: 'delay',
+          position: { x: 200, y: 0 },
+          data: { delayAmount: 1, delayUnit: 'days' }
+        },
+        {
+          id: 'email-2',
+          type: 'email',
+          position: { x: 400, y: 0 },
+          data: { templateId: 'template-2' }
+        }
+      ],
+      edges: [
+        { id: 'edge-1', source: 'email-1', target: 'delay-1' },
+        { id: 'edge-2', source: 'delay-1', target: 'email-2' }
+      ]
+    };
+
+    const { result } = renderHook(() => useWorkflowValidation(workflow));
+
+    expect(result.current.valid).toBe(true);
+    expect(result.current.errors).toEqual([]);
+  });
+
+  it('should handle workflow with condition node', () => {
+    const workflow: CampaignWorkflow = {
+      id: 'workflow-1',
+      nodes: [
+        {
+          id: 'email-1',
+          type: 'email',
+          position: { x: 0, y: 0 },
+          data: { templateId: 'template-1' }
+        },
+        {
+          id: 'condition-1',
+          type: 'condition',
+          position: { x: 200, y: 0 },
+          data: {
+            condition: {
+              field: 'email_opened',
+              operator: 'equals',
+              value: true
+            }
+          }
+        }
+      ],
+      edges: [
+        { id: 'edge-1', source: 'email-1', target: 'condition-1' }
+      ]
+    };
+
+    const { result } = renderHook(() => useWorkflowValidation(workflow));
+
+    // Should be valid with nodes and edges
+    expect(result.current.valid).toBe(true);
+  });
+});

package/__tests__/utils/formatting.test.ts

@@ -0,0 +1,48 @@
+/*
+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 { formatPercentage, formatNumber, formatMetricRate } from '../../src/utils/formatting';
+
+describe('Formatting Utils', () => {
+  describe('formatPercentage', () => {
+    it('should format percentage with 2 decimals by default', () => {
+      expect(formatPercentage(45.678)).toBe('45.68%');
+    });
+
+    it('should format percentage with custom decimals', () => {
+      expect(formatPercentage(45.678, 1)).toBe('45.7%');
+      expect(formatPercentage(45.678, 0)).toBe('46%');
+    });
+  });
+
+  describe('formatNumber', () => {
+    it('should format number with thousands separator', () => {
+      expect(formatNumber(1000)).toMatch(/1[,\s]000/);
+      expect(formatNumber(1234567)).toMatch(/1[,\s]234[,\s]567/);
+    });
+
+    it('should format small numbers without separator', () => {
+      expect(formatNumber(100)).toBe('100');
+    });
+  });
+
+  describe('formatMetricRate', () => {
+    it('should calculate percentage rate', () => {
+      expect(formatMetricRate(45, 100)).toBe(45);
+      expect(formatMetricRate(1, 4)).toBe(25);
+    });
+
+    it('should handle zero denominator', () => {
+      expect(formatMetricRate(10, 0)).toBe(0);
+    });
+
+    it('should handle zero numerator', () => {
+      expect(formatMetricRate(0, 100)).toBe(0);
+    });
+  });
+});