@startsimpli/funnels 0.1.4 → 0.1.5

package/src/api/client.test.ts

@@ -0,0 +1,640 @@
+/**
+ * Tests for FunnelApiClient
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FunnelApiClient, PaginatedResponse } from './client';
+import type { ApiAdapter } from './adapter';
+import { createApiError } from './adapter';
+import type {
+  Funnel,
+  FunnelStage,
+  FunnelRun,
+  FunnelResult,
+  CreateFunnelInput,
+} from '../types';
+
+/**
+ * Mock adapter for testing
+ */
+class MockAdapter implements ApiAdapter {
+  public lastRequest: {
+    method: string;
+    url: string;
+    data?: any;
+    params?: Record<string, any>;
+  } | null = null;
+
+  private responses = new Map<string, any>();
+  private errors = new Map<string, any>();
+
+  /**
+   * Mock a successful response
+   */
+  mockResponse(url: string, response: any): void {
+    this.responses.set(url, response);
+  }
+
+  /**
+   * Mock an error response
+   */
+  mockError(url: string, status: number, message: string): void {
+    this.errors.set(url, { status, message });
+  }
+
+  /**
+   * Clear mocks
+   */
+  clear(): void {
+    this.responses.clear();
+    this.errors.clear();
+    this.lastRequest = null;
+  }
+
+  private async handleRequest<T>(
+    method: string,
+    url: string,
+    data?: any,
+    params?: Record<string, any>
+  ): Promise<T> {
+    this.lastRequest = { method, url, data, params };
+
+    // Check for error
+    if (this.errors.has(url)) {
+      const error = this.errors.get(url);
+      throw createApiError(error.message, error.status);
+    }
+
+    // Check for response
+    if (this.responses.has(url)) {
+      return this.responses.get(url);
+    }
+
+    throw createApiError(`No mock response for ${url}`, 404);
+  }
+
+  async get<T>(url: string, params?: Record<string, any>): Promise<T> {
+    return this.handleRequest<T>('GET', url, undefined, params);
+  }
+
+  async post<T>(url: string, data: any): Promise<T> {
+    return this.handleRequest<T>('POST', url, data);
+  }
+
+  async patch<T>(url: string, data: any): Promise<T> {
+    return this.handleRequest<T>('PATCH', url, data);
+  }
+
+  async delete<T>(url: string): Promise<T> {
+    return this.handleRequest<T>('DELETE', url);
+  }
+}
+
+describe('FunnelApiClient', () => {
+  let adapter: MockAdapter;
+  let client: FunnelApiClient;
+  const baseUrl = 'https://api.example.com';
+
+  beforeEach(() => {
+    adapter = new MockAdapter();
+    client = new FunnelApiClient(adapter, baseUrl);
+  });
+
+  // ============================================================================
+  // Funnel CRUD
+  // ============================================================================
+
+  describe('listFunnels', () => {
+    it('should fetch list of funnels', async () => {
+      const mockResponse: PaginatedResponse<Funnel> = {
+        count: 2,
+        next: null,
+        previous: null,
+        results: [
+          {
+            id: 'funnel-1',
+            name: 'Investor Qualification',
+            status: 'active',
+            input_type: 'contacts',
+            stages: [],
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z',
+          },
+          {
+            id: 'funnel-2',
+            name: 'Recipe Recommendations',
+            status: 'draft',
+            input_type: 'any',
+            stages: [],
+            created_at: '2024-01-02T00:00:00Z',
+            updated_at: '2024-01-02T00:00:00Z',
+          },
+        ],
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/`, mockResponse);
+
+      const result = await client.listFunnels();
+
+      expect(result.count).toBe(2);
+      expect(result.results).toHaveLength(2);
+      expect(adapter.lastRequest?.method).toBe('GET');
+      expect(adapter.lastRequest?.url).toBe(`${baseUrl}/api/v1/funnels/`);
+    });
+
+    it('should pass filters as query params', async () => {
+      const mockResponse: PaginatedResponse<Funnel> = {
+        count: 1,
+        next: null,
+        previous: null,
+        results: [],
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/`, mockResponse);
+
+      await client.listFunnels({
+        status: 'active',
+        page: 2,
+        page_size: 10,
+        ordering: '-created_at',
+      });
+
+      expect(adapter.lastRequest?.params).toEqual({
+        status: 'active',
+        page: 2,
+        page_size: 10,
+        ordering: '-created_at',
+      });
+    });
+  });
+
+  describe('getFunnel', () => {
+    it('should fetch single funnel', async () => {
+      const mockFunnel: Funnel = {
+        id: 'funnel-1',
+        name: 'Test Funnel',
+        status: 'active',
+        input_type: 'contacts',
+        stages: [
+          {
+            id: 'stage-1',
+            order: 0,
+            name: 'Stage 1',
+            filter_logic: 'AND',
+            rules: [],
+            match_action: 'continue',
+            no_match_action: 'exclude',
+          },
+        ],
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/funnel-1/`, mockFunnel);
+
+      const result = await client.getFunnel('funnel-1');
+
+      expect(result.id).toBe('funnel-1');
+      expect(result.name).toBe('Test Funnel');
+      expect(result.stages).toHaveLength(1);
+    });
+
+    it('should throw 404 for non-existent funnel', async () => {
+      adapter.mockError(`${baseUrl}/api/v1/funnels/invalid/`, 404, 'Not found');
+
+      await expect(client.getFunnel('invalid')).rejects.toThrow('Not found');
+    });
+  });
+
+  describe('createFunnel', () => {
+    it('should create new funnel', async () => {
+      const input: CreateFunnelInput = {
+        name: 'New Funnel',
+        status: 'draft',
+        input_type: 'contacts',
+        stages: [],
+      };
+
+      const mockResponse: Funnel = {
+        ...input,
+        id: 'funnel-new',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/`, mockResponse);
+
+      const result = await client.createFunnel(input);
+
+      expect(result.id).toBe('funnel-new');
+      expect(result.name).toBe('New Funnel');
+      expect(adapter.lastRequest?.method).toBe('POST');
+      expect(adapter.lastRequest?.data).toEqual(input);
+    });
+
+    it('should throw 400 for invalid input', async () => {
+      adapter.mockError(`${baseUrl}/api/v1/funnels/`, 400, 'Invalid input');
+
+      const input: CreateFunnelInput = {
+        name: '', // Invalid: empty name
+        status: 'draft',
+        input_type: 'contacts',
+        stages: [],
+      };
+
+      await expect(client.createFunnel(input)).rejects.toThrow('Invalid input');
+    });
+  });
+
+  describe('updateFunnel', () => {
+    it('should update funnel', async () => {
+      const mockResponse: Funnel = {
+        id: 'funnel-1',
+        name: 'Updated Funnel',
+        status: 'active',
+        input_type: 'contacts',
+        stages: [],
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-02T00:00:00Z',
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/funnel-1/`, mockResponse);
+
+      const result = await client.updateFunnel('funnel-1', { name: 'Updated Funnel' });
+
+      expect(result.name).toBe('Updated Funnel');
+      expect(adapter.lastRequest?.method).toBe('PATCH');
+      expect(adapter.lastRequest?.data).toEqual({ name: 'Updated Funnel' });
+    });
+  });
+
+  describe('deleteFunnel', () => {
+    it('should delete funnel', async () => {
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/funnel-1/`, undefined);
+
+      await client.deleteFunnel('funnel-1');
+
+      expect(adapter.lastRequest?.method).toBe('DELETE');
+      expect(adapter.lastRequest?.url).toBe(`${baseUrl}/api/v1/funnels/funnel-1/`);
+    });
+  });
+
+  // ============================================================================
+  // Stage CRUD
+  // ============================================================================
+
+  describe('createStage', () => {
+    it('should create stage', async () => {
+      const input = {
+        order: 0,
+        name: 'New Stage',
+        filter_logic: 'AND' as const,
+        rules: [],
+        match_action: 'continue' as const,
+        no_match_action: 'exclude' as const,
+      };
+
+      const mockResponse: FunnelStage = {
+        ...input,
+        id: 'stage-new',
+      };
+
+      adapter.mockResponse(
+        `${baseUrl}/api/v1/funnels/funnel-1/stages/`,
+        mockResponse
+      );
+
+      const result = await client.createStage('funnel-1', input);
+
+      expect(result.id).toBe('stage-new');
+      expect(result.name).toBe('New Stage');
+      expect(adapter.lastRequest?.method).toBe('POST');
+    });
+  });
+
+  describe('updateStage', () => {
+    it('should update stage', async () => {
+      const mockResponse: FunnelStage = {
+        id: 'stage-1',
+        order: 0,
+        name: 'Updated Stage',
+        filter_logic: 'AND',
+        rules: [],
+        match_action: 'continue',
+        no_match_action: 'exclude',
+      };
+
+      adapter.mockResponse(
+        `${baseUrl}/api/v1/funnels/funnel-1/stages/stage-1/`,
+        mockResponse
+      );
+
+      const result = await client.updateStage('funnel-1', 'stage-1', {
+        name: 'Updated Stage',
+      });
+
+      expect(result.name).toBe('Updated Stage');
+      expect(adapter.lastRequest?.method).toBe('PATCH');
+    });
+  });
+
+  describe('deleteStage', () => {
+    it('should delete stage', async () => {
+      adapter.mockResponse(
+        `${baseUrl}/api/v1/funnels/funnel-1/stages/stage-1/`,
+        undefined
+      );
+
+      await client.deleteStage('funnel-1', 'stage-1');
+
+      expect(adapter.lastRequest?.method).toBe('DELETE');
+    });
+  });
+
+  // ============================================================================
+  // Run Operations
+  // ============================================================================
+
+  describe('runFunnel', () => {
+    it('should trigger funnel run', async () => {
+      const mockRun: FunnelRun = {
+        id: 'run-1',
+        funnel_id: 'funnel-1',
+        status: 'pending',
+        trigger_type: 'manual',
+        started_at: '2024-01-01T00:00:00Z',
+        total_input: 0,
+        total_matched: 0,
+        total_excluded: 0,
+        total_tagged: 0,
+        stage_stats: {},
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/funnel-1/run/`, mockRun);
+
+      const result = await client.runFunnel('funnel-1', { trigger_type: 'manual' });
+
+      expect(result.id).toBe('run-1');
+      expect(result.status).toBe('pending');
+      expect(adapter.lastRequest?.method).toBe('POST');
+    });
+  });
+
+  describe('getFunnelRuns', () => {
+    it('should fetch run history', async () => {
+      const mockResponse: PaginatedResponse<FunnelRun> = {
+        count: 1,
+        next: null,
+        previous: null,
+        results: [
+          {
+            id: 'run-1',
+            funnel_id: 'funnel-1',
+            status: 'completed',
+            trigger_type: 'manual',
+            started_at: '2024-01-01T00:00:00Z',
+            completed_at: '2024-01-01T00:01:00Z',
+            total_input: 100,
+            total_matched: 50,
+            total_excluded: 50,
+            total_tagged: 50,
+            stage_stats: {},
+          },
+        ],
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/funnel-1/runs/`, mockResponse);
+
+      const result = await client.getFunnelRuns('funnel-1');
+
+      expect(result.count).toBe(1);
+      expect(result.results[0].status).toBe('completed');
+    });
+
+    it('should pass filters', async () => {
+      const mockResponse: PaginatedResponse<FunnelRun> = {
+        count: 0,
+        next: null,
+        previous: null,
+        results: [],
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/funnel-1/runs/`, mockResponse);
+
+      await client.getFunnelRuns('funnel-1', {
+        status: 'completed',
+        page: 1,
+        page_size: 20,
+      });
+
+      expect(adapter.lastRequest?.params).toEqual({
+        status: 'completed',
+        page: 1,
+        page_size: 20,
+      });
+    });
+  });
+
+  describe('getFunnelRun', () => {
+    it('should fetch single run', async () => {
+      const mockRun: FunnelRun = {
+        id: 'run-1',
+        funnel_id: 'funnel-1',
+        status: 'completed',
+        trigger_type: 'manual',
+        started_at: '2024-01-01T00:00:00Z',
+        completed_at: '2024-01-01T00:01:00Z',
+        total_input: 100,
+        total_matched: 50,
+        total_excluded: 50,
+        total_tagged: 50,
+        stage_stats: {},
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnel-runs/run-1/`, mockRun);
+
+      const result = await client.getFunnelRun('run-1');
+
+      expect(result.id).toBe('run-1');
+      expect(result.status).toBe('completed');
+    });
+  });
+
+  describe('getFunnelResults', () => {
+    it('should fetch run results', async () => {
+      const mockResponse: PaginatedResponse<FunnelResult> = {
+        count: 2,
+        next: null,
+        previous: null,
+        results: [
+          {
+            entity: { id: 'entity-1', name: 'Test Entity' },
+            matched: true,
+            accumulated_tags: ['qualified'],
+            context: {},
+          },
+          {
+            entity: { id: 'entity-2', name: 'Test Entity 2' },
+            matched: false,
+            excluded_at_stage: 'stage-1',
+            accumulated_tags: [],
+            context: {},
+          },
+        ],
+      };
+
+      adapter.mockResponse(
+        `${baseUrl}/api/v1/funnel-runs/run-1/results/`,
+        mockResponse
+      );
+
+      const result = await client.getFunnelResults('run-1');
+
+      expect(result.count).toBe(2);
+      expect(result.results[0].matched).toBe(true);
+      expect(result.results[1].matched).toBe(false);
+    });
+
+    it('should filter by matched', async () => {
+      const mockResponse: PaginatedResponse<FunnelResult> = {
+        count: 1,
+        next: null,
+        previous: null,
+        results: [],
+      };
+
+      adapter.mockResponse(
+        `${baseUrl}/api/v1/funnel-runs/run-1/results/`,
+        mockResponse
+      );
+
+      await client.getFunnelResults('run-1', { matched: true });
+
+      expect(adapter.lastRequest?.params).toEqual({ matched: true });
+    });
+  });
+
+  describe('cancelFunnelRun', () => {
+    it('should cancel running funnel', async () => {
+      const mockRun: FunnelRun = {
+        id: 'run-1',
+        funnel_id: 'funnel-1',
+        status: 'cancelled',
+        trigger_type: 'manual',
+        started_at: '2024-01-01T00:00:00Z',
+        total_input: 0,
+        total_matched: 0,
+        total_excluded: 0,
+        total_tagged: 0,
+        stage_stats: {},
+      };
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnel-runs/run-1/cancel/`, mockRun);
+
+      const result = await client.cancelFunnelRun('run-1');
+
+      expect(result.status).toBe('cancelled');
+      expect(adapter.lastRequest?.method).toBe('POST');
+    });
+  });
+
+  // ============================================================================
+  // Error Handling
+  // ============================================================================
+
+  describe('error handling', () => {
+    it('should handle 404 errors', async () => {
+      adapter.mockError(`${baseUrl}/api/v1/funnels/invalid/`, 404, 'Not found');
+
+      await expect(client.getFunnel('invalid')).rejects.toMatchObject({
+        message: 'Not found',
+        status: 404,
+      });
+    });
+
+    it('should handle 500 errors', async () => {
+      adapter.mockError(
+        `${baseUrl}/api/v1/funnels/`,
+        500,
+        'Internal server error'
+      );
+
+      await expect(client.listFunnels()).rejects.toMatchObject({
+        message: 'Internal server error',
+        status: 500,
+      });
+    });
+
+    it('should handle network errors', async () => {
+      // No mock response = network error
+      await expect(client.getFunnel('funnel-1')).rejects.toThrow();
+    });
+  });
+
+  // ============================================================================
+  // Preview
+  // ============================================================================
+
+  describe('preview', () => {
+    it('should throw for client-side preview (not implemented)', async () => {
+      const funnel: Funnel = {
+        id: 'funnel-1',
+        name: 'Test Funnel',
+        status: 'active',
+        input_type: 'contacts',
+        stages: [],
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+      };
+
+      await expect(
+        client.previewFunnel(funnel, [{ id: 'entity-1' }])
+      ).rejects.toThrow('Client-side preview requires evaluation engine');
+    });
+
+    it('should call server-side preview', async () => {
+      const mockPreview = {
+        matched_entities: [{ id: 'entity-1' }],
+        excluded_entities: [],
+        stage_breakdown: [],
+        total_input: 1,
+        total_matched: 1,
+        total_excluded: 0,
+      };
+
+      adapter.mockResponse(
+        `${baseUrl}/api/v1/funnels/funnel-1/preview/`,
+        mockPreview
+      );
+
+      const result = await client.previewFunnelServer('funnel-1', [
+        { id: 'entity-1' },
+      ]);
+
+      expect(result.total_matched).toBe(1);
+      expect(adapter.lastRequest?.method).toBe('POST');
+      expect(adapter.lastRequest?.data).toEqual({
+        entities: [{ id: 'entity-1' }],
+      });
+    });
+  });
+
+  // ============================================================================
+  // URL Handling
+  // ============================================================================
+
+  describe('URL handling', () => {
+    it('should remove trailing slash from baseUrl', () => {
+      const clientWithTrailingSlash = new FunnelApiClient(
+        adapter,
+        'https://api.example.com/'
+      );
+
+      adapter.mockResponse(`${baseUrl}/api/v1/funnels/`, { count: 0, results: [] });
+
+      clientWithTrailingSlash.listFunnels();
+
+      expect(adapter.lastRequest?.url).toBe(`${baseUrl}/api/v1/funnels/`);
+    });
+  });
+});