@incodetech/core 2.0.0-alpha.1

package/src/phone/phoneManager.test.ts

@@ -0,0 +1,393 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { mockPhoneConfig, mockPhoneConfigNoOtp } from './__mocks__/phoneMocks';
+import { createPhoneManager, type PhoneState } from './phoneManager';
+
+// Mock the phone services
+vi.mock('./phoneServices', () => ({
+  fetchPhone: vi.fn().mockResolvedValue({ phone: '+14155551234' }),
+  fetchStartInfo: vi
+    .fn()
+    .mockResolvedValue({ ipIsoCode: 'US', phonePrefix: '+1' }),
+  addPhone: vi.fn().mockResolvedValue({ success: true }),
+  addPhoneInstantVerify: vi.fn().mockResolvedValue({ success: true }),
+  sendOtp: vi.fn().mockResolvedValue(undefined),
+  verifyOtp: vi.fn().mockResolvedValue({ success: true }),
+}));
+
+// Mock the events module
+vi.mock('../events/addEvent', () => ({
+  addEvent: vi.fn().mockResolvedValue(undefined),
+}));
+
+describe('createPhoneManager', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Re-setup default mock implementations
+    const phoneServices = await import('./phoneServices');
+    vi.mocked(phoneServices.fetchPhone).mockResolvedValue({
+      phone: '+14155551234',
+    });
+    vi.mocked(phoneServices.fetchStartInfo).mockResolvedValue({
+      ipIsoCode: 'US',
+      phonePrefix: '+1',
+      country: 'United States',
+    });
+    vi.mocked(phoneServices.addPhone).mockResolvedValue({ success: true });
+    vi.mocked(phoneServices.sendOtp).mockResolvedValue(undefined);
+    vi.mocked(phoneServices.verifyOtp).mockResolvedValue({ success: true });
+  });
+
+  describe('Initial state', () => {
+    it('should create a phone manager with all API methods', () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      expect(manager).toBeDefined();
+      expect(manager.getState).toBeDefined();
+      expect(manager.subscribe).toBeDefined();
+      expect(manager.stop).toBeDefined();
+      expect(manager.load).toBeDefined();
+      expect(manager.setPhoneNumber).toBeDefined();
+      expect(manager.setOptInGranted).toBeDefined();
+      expect(manager.submit).toBeDefined();
+      expect(manager.submitOtp).toBeDefined();
+      expect(manager.resendOtp).toBeDefined();
+      expect(manager.back).toBeDefined();
+      expect(manager.reset).toBeDefined();
+
+      manager.stop();
+    });
+
+    it('should start in idle state', () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      expect(manager.getState()).toEqual({ status: 'idle' });
+
+      manager.stop();
+    });
+  });
+
+  describe('Headless phone flow without OTP', () => {
+    it('should transition through phone flow states', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfigNoOtp });
+      const states: PhoneState[] = [];
+
+      manager.subscribe((state) => states.push(state));
+
+      // Load the manager
+      manager.load();
+
+      // Wait for inputting state
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      // Verify we reached inputting
+      expect(states.some((s) => s.status === 'inputting')).toBe(true);
+
+      // Set phone number and submit
+      manager.setPhoneNumber('+14155551234', true);
+      manager.submit();
+
+      // Wait for any progression past inputting
+      await vi.waitFor(
+        () => {
+          const status = manager.getState().status;
+          return (
+            status === 'submitting' ||
+            status === 'success' ||
+            status === 'error'
+          );
+        },
+        { timeout: 2000 },
+      );
+
+      manager.stop();
+    });
+  });
+
+  describe('Headless phone flow with OTP', () => {
+    it('should reach awaitingOtp state after phone submission', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      // Set phone number - must be marked as valid
+      manager.setPhoneNumber('+14155551234', true);
+
+      // Small delay to ensure state update
+      await vi.waitFor(() => {
+        manager.submit();
+        return true;
+      });
+
+      // Wait for OTP states
+      await vi.waitFor(
+        () => {
+          const status = manager.getState().status;
+          return (
+            status === 'submitting' ||
+            status === 'sendingOtp' ||
+            status === 'awaitingOtp' ||
+            status === 'success'
+          );
+        },
+        { timeout: 2000 },
+      );
+
+      manager.stop();
+    });
+
+    it('should verify OTP and reach success', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.setPhoneNumber('+14155551234', true);
+      manager.submit();
+
+      await vi.waitFor(
+        () => {
+          const status = manager.getState().status;
+          return status === 'awaitingOtp';
+        },
+        { timeout: 2000 },
+      );
+
+      manager.submitOtp('ABC123');
+
+      await vi.waitFor(
+        () => {
+          const status = manager.getState().status;
+          return status === 'success' || status === 'verifyingOtp';
+        },
+        { timeout: 2000 },
+      );
+
+      manager.stop();
+    });
+
+    it('should handle back navigation from OTP screen', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.setPhoneNumber('+14155551234', true);
+      manager.submit();
+
+      await vi.waitFor(
+        () => {
+          const status = manager.getState().status;
+          return status === 'awaitingOtp';
+        },
+        { timeout: 2000 },
+      );
+
+      manager.back();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.stop();
+    });
+  });
+
+  describe('api.load()', () => {
+    it('should transition through loading states', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      manager.load();
+
+      // Should eventually reach inputting
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.stop();
+    });
+  });
+
+  describe('api.setPhoneNumber()', () => {
+    it('should update phone number in context', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.setPhoneNumber('+14155559999', true);
+
+      // Phone number is stored in context but not exposed in state
+      // The important thing is the action doesn't error
+      expect(manager.getState().status).toBe('inputting');
+
+      manager.stop();
+    });
+  });
+
+  describe('api.setOptInGranted()', () => {
+    it('should update opt-in status', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.setOptInGranted(true);
+
+      // Opt-in is stored in context
+      expect(manager.getState().status).toBe('inputting');
+
+      manager.stop();
+    });
+  });
+
+  describe('api.reset()', () => {
+    it('should not reset from inputting state (RESET not handled there)', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.reset();
+
+      // RESET is only handled in success/error states
+      expect(manager.getState().status).toBe('inputting');
+
+      manager.stop();
+    });
+  });
+
+  describe('subscribe()', () => {
+    it('should notify subscribers of state changes', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+      const states: PhoneState[] = [];
+
+      manager.subscribe((state) => states.push(state));
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      expect(states.length).toBeGreaterThan(0);
+      expect(states.some((s) => s.status === 'inputting')).toBe(true);
+
+      manager.stop();
+    });
+
+    it('should return unsubscribe function', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+      const listener = vi.fn();
+
+      const unsubscribe = manager.subscribe(listener);
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      const callCountAfterLoad = listener.mock.calls.length;
+
+      unsubscribe();
+
+      manager.setPhoneNumber('+14155551234', true);
+
+      // Should not have been called after unsubscribe
+      expect(listener.mock.calls.length).toBe(callCountAfterLoad);
+
+      manager.stop();
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle phone submission errors', async () => {
+      const { addPhone } = await import('./phoneServices');
+      vi.mocked(addPhone).mockRejectedValueOnce(new Error('Network error'));
+
+      const manager = createPhoneManager({ config: mockPhoneConfigNoOtp });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      manager.setPhoneNumber('+14155551234', true);
+      manager.submit();
+
+      await vi.waitFor(() => {
+        const state = manager.getState();
+        // Should either show error in inputting state or error state
+        return state.status === 'inputting' || state.status === 'error';
+      });
+
+      manager.stop();
+    });
+  });
+
+  describe('Headless API usage', () => {
+    it('exposes all methods needed for headless integration', () => {
+      // This test documents the headless API surface
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+
+      // Manager provides these methods for headless usage:
+      expect(typeof manager.load).toBe('function');
+      expect(typeof manager.setPhoneNumber).toBe('function');
+      expect(typeof manager.setOptInGranted).toBe('function');
+      expect(typeof manager.submit).toBe('function');
+      expect(typeof manager.submitOtp).toBe('function');
+      expect(typeof manager.resendOtp).toBe('function');
+      expect(typeof manager.back).toBe('function');
+      expect(typeof manager.reset).toBe('function');
+      expect(typeof manager.getState).toBe('function');
+      expect(typeof manager.subscribe).toBe('function');
+      expect(typeof manager.stop).toBe('function');
+
+      manager.stop();
+    });
+
+    it('can track state changes via subscribe', async () => {
+      const manager = createPhoneManager({ config: mockPhoneConfig });
+      const stateHistory: string[] = [];
+
+      // Subscribe to track all state changes
+      manager.subscribe((state) => {
+        stateHistory.push(state.status);
+      });
+
+      manager.load();
+
+      await vi.waitFor(() => {
+        expect(manager.getState().status).toBe('inputting');
+      });
+
+      // Verify we captured state transitions
+      expect(stateHistory.length).toBeGreaterThan(0);
+      expect(stateHistory.includes('inputting')).toBe(true);
+
+      manager.stop();
+    });
+  });
+});