@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.11

package/src/phone/phoneStateMachine.test.ts

@@ -1,918 +0,0 @@
-import { createActor } from '@incodetech/infra';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { mockPhoneConfig, mockPhoneConfigNoOtp } from './__mocks__/phoneMocks';
-import { type PhoneEvent, phoneMachine } from './phoneStateMachine';
-
-// Mock the phone services
-vi.mock('./phoneServices', () => ({
-  fetchPhone: vi.fn().mockResolvedValue({ phone: '+14155551234' }),
-  fetchStartInfo: vi.fn().mockResolvedValue({
-    ipIsoCode: 'US',
-    phonePrefix: '+1',
-    country: 'United States',
-  }),
-  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('phoneMachine', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Initial state', () => {
-    it('should start in idle state', () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      expect(actor.getSnapshot().value).toBe('idle');
-
-      actor.stop();
-    });
-
-    it('should have initial context with config', () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      const { context } = actor.getSnapshot();
-      expect(context.config).toEqual(mockPhoneConfig);
-      expect(context.phone).toBe('');
-      expect(context.isValid).toBe(false);
-      // Country code and phone prefix are empty until start info is loaded
-      expect(context.countryCode).toBe('');
-      expect(context.phonePrefix).toBe('');
-
-      actor.stop();
-    });
-  });
-
-  describe('LOAD event', () => {
-    it('should transition to loadingStartInfo when prefill is disabled', () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      expect(actor.getSnapshot().value).toBe('loadingStartInfo');
-
-      actor.stop();
-    });
-
-    it('should transition to loadingPrefill when prefill is enabled', () => {
-      const configWithPrefill = { ...mockPhoneConfig, prefill: true };
-      const actor = createActor(phoneMachine, {
-        input: { config: configWithPrefill },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      expect(actor.getSnapshot().value).toBe('loadingPrefill');
-
-      actor.stop();
-    });
-  });
-
-  describe('Loading flow', () => {
-    it('should transition to inputting after loading start info', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      const { context } = actor.getSnapshot();
-      expect(context.countryCode).toBe('US');
-      expect(context.phonePrefix).toBe('+1');
-
-      actor.stop();
-    });
-  });
-
-  describe('Phone input', () => {
-    it('should update phone on PHONE_CHANGED event', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-
-      const { context } = actor.getSnapshot();
-      expect(context.phone).toBe('+14155551234');
-      expect(context.isValid).toBe(true);
-
-      actor.stop();
-    });
-
-    it('should update opt-in on OPT_IN_CHANGED event', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({ type: 'OPT_IN_CHANGED', granted: true } as PhoneEvent);
-
-      const { context } = actor.getSnapshot();
-      expect(context.optInGranted).toBe(true);
-
-      actor.stop();
-    });
-  });
-
-  describe('SUBMIT event', () => {
-    it('should not submit when phone is invalid', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      // Phone is invalid by default
-      actor.send({ type: 'SUBMIT' });
-
-      // Should still be in inputting state
-      expect(actor.getSnapshot().value).toBe('inputting');
-
-      actor.stop();
-    });
-
-    it('should transition to submitting when phone is valid', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      expect(actor.getSnapshot().value).toBe('submitting');
-
-      actor.stop();
-    });
-  });
-
-  describe('Phone submission without OTP', () => {
-    it('should transition to success after submitting phone', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('success');
-      });
-
-      actor.stop();
-    });
-  });
-
-  describe('OTP flow', () => {
-    it('should transition to sendingOtp after submitting phone with OTP enabled', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'sendingOtp' || value === 'awaitingOtp';
-      });
-
-      actor.stop();
-    });
-
-    it('should transition to awaitingOtp after sending OTP', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      const { context } = actor.getSnapshot();
-      expect(context.attemptsRemaining).toBe(3);
-
-      actor.stop();
-    });
-
-    it('should update OTP code on OTP_CHANGED event', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'ABC123' } as PhoneEvent);
-
-      const { context } = actor.getSnapshot();
-      expect(context.otpCode).toBe('ABC123');
-
-      actor.stop();
-    });
-
-    it('should transition to verifyingOtp on VERIFY_OTP event', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'ABC123' } as PhoneEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      expect(actor.getSnapshot().value).toBe('verifyingOtp');
-
-      actor.stop();
-    });
-
-    it('should transition to success on valid OTP', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'ABC123' } as PhoneEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('success');
-      });
-
-      actor.stop();
-    });
-  });
-
-  describe('BACK event', () => {
-    it('should transition from awaitingOtp to inputting', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'BACK' });
-
-      expect(actor.getSnapshot().value).toBe('inputting');
-
-      actor.stop();
-    });
-  });
-
-  describe('RESET event', () => {
-    it('should not reset from success state (final state)', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('success');
-      });
-
-      // Final states don't accept transitions - this is correct behavior for orchestration
-      actor.send({ type: 'RESET' });
-
-      // Should remain in success state (final state)
-      expect(actor.getSnapshot().value).toBe('success');
-
-      actor.stop();
-    });
-
-    it('should not reset context from success state (final state)', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('success');
-      });
-
-      // Final states don't accept transitions - context should remain unchanged
-      actor.send({ type: 'RESET' });
-
-      const { context } = actor.getSnapshot();
-      // Context remains unchanged because final state doesn't accept RESET
-      expect(context.phone).toBe('+14155551234');
-      expect(context.isValid).toBe(true);
-
-      actor.stop();
-    });
-
-    it('should not reset from inputting state (RESET not handled)', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({ type: 'RESET' });
-
-      // RESET is not handled in inputting state
-      expect(actor.getSnapshot().value).toBe('inputting');
-
-      actor.stop();
-    });
-  });
-
-  describe('Subscriptions', () => {
-    it('should notify subscribers of state changes', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      });
-
-      const states: string[] = [];
-      actor.subscribe((snapshot) => {
-        states.push(snapshot.value as string);
-      });
-
-      actor.start();
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      expect(states).toContain('idle');
-      expect(states).toContain('loadingStartInfo');
-      expect(states).toContain('inputting');
-
-      actor.stop();
-    });
-  });
-
-  describe('Prefill flow', () => {
-    it('should load prefilled phone and transition to inputting', async () => {
-      const configWithPrefill = { ...mockPhoneConfig, prefill: true };
-      const actor = createActor(phoneMachine, {
-        input: { config: configWithPrefill },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      const { context } = actor.getSnapshot();
-      expect(context.prefilledPhone).toBe('+14155551234');
-      expect(context.phone).toBe('+14155551234');
-
-      actor.stop();
-    });
-
-    it('should handle prefill fetch error and still transition to loadingStartInfo', async () => {
-      const { fetchPhone } = await import('./phoneServices');
-      vi.mocked(fetchPhone).mockRejectedValueOnce(new Error('Network error'));
-
-      const configWithPrefill = { ...mockPhoneConfig, prefill: true };
-      const actor = createActor(phoneMachine, {
-        input: { config: configWithPrefill },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.stop();
-    });
-  });
-
-  describe('OTP error handling', () => {
-    it('should transition to otpError when OTP verification fails with attempts remaining', async () => {
-      const { verifyOtp } = await import('./phoneServices');
-      vi.mocked(verifyOtp).mockResolvedValueOnce({ success: false });
-
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG1' } as PhoneEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('otpError');
-      });
-
-      const { context } = actor.getSnapshot();
-      expect(context.attemptsRemaining).toBe(2);
-      expect(context.otpError).toBe('Invalid OTP code');
-
-      actor.stop();
-    });
-
-    it('should allow retry from otpError state via OTP_CHANGED', async () => {
-      const { verifyOtp } = await import('./phoneServices');
-      vi.mocked(verifyOtp)
-        .mockResolvedValueOnce({ success: false })
-        .mockResolvedValueOnce({ success: true });
-
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG1' } as PhoneEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('otpError');
-      });
-
-      // Retry with correct code
-      actor.send({ type: 'OTP_CHANGED', code: 'CORRECT' } as PhoneEvent);
-
-      expect(actor.getSnapshot().value).toBe('awaitingOtp');
-
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('success');
-      });
-
-      actor.stop();
-    });
-
-    it('should transition to error when all OTP attempts are exhausted', async () => {
-      const { verifyOtp } = await import('./phoneServices');
-      vi.mocked(verifyOtp).mockResolvedValue({ success: false });
-
-      const configWith1Attempt = { ...mockPhoneConfig, maxOtpAttempts: 1 };
-      const actor = createActor(phoneMachine, {
-        input: { config: configWith1Attempt },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG' } as PhoneEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'error' || value === 'otpError';
-      });
-
-      actor.stop();
-    });
-
-    it('should handle BACK from otpError state', async () => {
-      const { verifyOtp } = await import('./phoneServices');
-      vi.mocked(verifyOtp).mockResolvedValueOnce({ success: false });
-
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG' } as PhoneEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('otpError');
-      });
-
-      actor.send({ type: 'BACK' });
-
-      expect(actor.getSnapshot().value).toBe('inputting');
-
-      actor.stop();
-    });
-  });
-
-  describe('Resend OTP flow', () => {
-    it('should not resend when timer is still active', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      // Timer should be active immediately after entering awaitingOtp
-      const { context } = actor.getSnapshot();
-      expect(context.resendTimerActive).toBe(true);
-
-      // Try to resend (should be blocked by guard)
-      actor.send({ type: 'RESEND_OTP' });
-
-      // Should still be in awaitingOtp, not sendingOtp
-      expect(actor.getSnapshot().value).toBe('awaitingOtp');
-
-      actor.stop();
-    });
-
-    it('should resend when timer has expired', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      // Wait for timer to expire
-      await vi.waitFor(
-        () => {
-          const { context } = actor.getSnapshot();
-          return !context.resendTimerActive;
-        },
-        { timeout: 35000 },
-      );
-
-      actor.send({ type: 'RESEND_OTP' });
-
-      await vi.waitFor(() => {
-        return actor.getSnapshot().value === 'sendingOtp';
-      });
-
-      actor.stop();
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should handle phone submission error', async () => {
-      const { addPhone } = await import('./phoneServices');
-      vi.mocked(addPhone).mockRejectedValueOnce(new Error('Network error'));
-
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'inputting' || value === 'error';
-      });
-
-      actor.stop();
-    });
-
-    it('should handle sendOtp error and still transition to awaitingOtp', async () => {
-      const { sendOtp } = await import('./phoneServices');
-      vi.mocked(sendOtp).mockRejectedValueOnce(new Error('SMS failed'));
-
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      // Even if sendOtp fails, should transition to awaitingOtp (with error in context)
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.stop();
-    });
-
-    it('should reset from error state', async () => {
-      const { addPhone } = await import('./phoneServices');
-      vi.mocked(addPhone).mockRejectedValueOnce(new Error('Fatal error'));
-
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'inputting' || value === 'error';
-      });
-
-      // If we're in error state, test RESET
-      if (actor.getSnapshot().value === 'error') {
-        actor.send({ type: 'RESET' });
-        expect(actor.getSnapshot().value).toBe('idle');
-      }
-
-      actor.stop();
-    });
-  });
-
-  describe('Resend timer', () => {
-    it('should initialize resend timer when entering awaitingOtp', async () => {
-      const actor = createActor(phoneMachine, {
-        input: { config: mockPhoneConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'PHONE_CHANGED',
-        phone: '+14155551234',
-        isValid: true,
-      } as PhoneEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      const { context } = actor.getSnapshot();
-      expect(context.resendTimer).toBe(30);
-      expect(context.resendTimerActive).toBe(true);
-
-      actor.stop();
-    });
-  });
-});