@incodetech/core 2.0.0-alpha.2 → 2.0.0-alpha.4

package/src/email/emailStateMachine.test.ts

@@ -1,741 +0,0 @@
-import { createActor } from '@incodetech/infra';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { mockEmailConfig, mockEmailConfigNoOtp } from './__mocks__/emailMocks';
-import { type EmailEvent, emailMachine } from './emailStateMachine';
-
-// Mock the email services - using same pattern as phone tests
-vi.mock('./emailServices', () => ({
-  fetchEmail: vi.fn().mockResolvedValue({ email: 'user@example.com' }),
-  addEmail: vi.fn().mockResolvedValue({ success: true }),
-  sendEmailOtp: vi.fn().mockResolvedValue(undefined),
-  verifyEmailOtp: vi.fn().mockResolvedValue({ success: true }),
-}));
-
-// Mock the events module
-vi.mock('../events/addEvent', () => ({
-  addEvent: vi.fn().mockResolvedValue(undefined),
-}));
-
-describe('emailMachine', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Initial state', () => {
-    it('should start in idle state', () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      expect(actor.getSnapshot().value).toBe('idle');
-
-      actor.stop();
-    });
-
-    it('should have initial context with config', () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      const { context } = actor.getSnapshot();
-      expect(context.config).toEqual(mockEmailConfig);
-      expect(context.email).toBe('');
-      expect(context.isValid).toBe(false);
-
-      actor.stop();
-    });
-  });
-
-  describe('LOAD event', () => {
-    it('should transition to inputting when prefill is disabled', () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      expect(actor.getSnapshot().value).toBe('inputting');
-
-      actor.stop();
-    });
-
-    it('should transition to loadingPrefill when prefill is enabled', () => {
-      const configWithPrefill = { ...mockEmailConfig, prefill: true };
-      const actor = createActor(emailMachine, {
-        input: { config: configWithPrefill },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      expect(actor.getSnapshot().value).toBe('loadingPrefill');
-
-      actor.stop();
-    });
-  });
-
-  describe('EMAIL_CHANGED event', () => {
-    it('should update email and isValid in context', () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-
-      const { context } = actor.getSnapshot();
-      expect(context.email).toBe('user@example.com');
-      expect(context.isValid).toBe(true);
-      expect(context.emailError).toBeUndefined();
-
-      actor.stop();
-    });
-
-    it('should set emailError when email is invalid', () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'invalid-email',
-        isValid: false,
-      } as EmailEvent);
-
-      const { context } = actor.getSnapshot();
-      expect(context.email).toBe('invalid-email');
-      expect(context.isValid).toBe(false);
-      expect(context.emailError).toBe('Invalid email address');
-
-      actor.stop();
-    });
-  });
-
-  describe('SUBMIT event', () => {
-    it('should transition to submitting when email is valid', () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      expect(actor.getSnapshot().value).toBe('submitting');
-
-      actor.stop();
-    });
-
-    it('should not transition when email is invalid', () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'invalid-email',
-        isValid: false,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      expect(actor.getSnapshot().value).toBe('inputting');
-
-      actor.stop();
-    });
-  });
-
-  describe('OTP flow', () => {
-    it('should transition to sendingOtp when otpVerification is enabled', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'sendingOtp' || value === 'awaitingOtp';
-      });
-
-      actor.stop();
-    });
-
-    it('should transition to success when otpVerification is disabled', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'success';
-      });
-
-      actor.stop();
-    });
-
-    it('should handle OTP_CHANGED event', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'ABC123' } as EmailEvent);
-
-      const { context } = actor.getSnapshot();
-      expect(context.otpCode).toBe('ABC123');
-      expect(context.otpError).toBeUndefined();
-
-      actor.stop();
-    });
-
-    it('should handle VERIFY_OTP event', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        return actor.getSnapshot().value === 'awaitingOtp';
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'ABC123' } as EmailEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'verifyingOtp' || value === 'success';
-      });
-
-      actor.stop();
-    });
-
-    it('should handle RESEND_OTP event', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        return actor.getSnapshot().value === 'awaitingOtp';
-      });
-
-      // Wait for timer to expire
-      await vi.waitFor(() => {
-        const { context } = actor.getSnapshot();
-        return !context.resendTimerActive;
-      });
-
-      actor.send({ type: 'RESEND_OTP' });
-
-      await vi.waitFor(() => {
-        return actor.getSnapshot().value === 'sendingOtp';
-      });
-
-      actor.stop();
-    });
-
-    it('should handle BACK event from awaitingOtp', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      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('Error handling', () => {
-    it('should handle email submission error', async () => {
-      // Import and set up the rejection mock before creating the actor
-      const emailServices = await import('./emailServices');
-      vi.mocked(emailServices.addEmail).mockRejectedValueOnce(
-        new Error('Network error'),
-      );
-
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      // Wait for the state machine to handle the error and return to inputting
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        // Should either be back in inputting (with error) or stay in submitting
-        return value === 'inputting' || value === 'error';
-      });
-
-      actor.stop();
-    });
-
-    it('should handle OTP verification error', async () => {
-      const { verifyEmailOtp } = await import('./emailServices');
-      vi.mocked(verifyEmailOtp).mockResolvedValueOnce({ success: false });
-
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        return actor.getSnapshot().value === 'awaitingOtp';
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG' } as EmailEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        const value = actor.getSnapshot().value;
-        return value === 'otpError' || value === 'error';
-      });
-
-      actor.stop();
-    });
-  });
-
-  describe('RESET event', () => {
-    it('should reset context and return to idle from success', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('success');
-      });
-
-      actor.send({ type: 'RESET' });
-
-      expect(actor.getSnapshot().value).toBe('idle');
-      const { context } = actor.getSnapshot();
-      expect(context.email).toBe('');
-      expect(context.isValid).toBe(false);
-
-      actor.stop();
-    });
-
-    it('should reset context and return to idle from error', async () => {
-      const { addEmail } = await import('./emailServices');
-      vi.mocked(addEmail).mockRejectedValueOnce(new Error('Fatal error'));
-
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfigNoOtp },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      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('Prefill flow', () => {
-    it('should load prefilled email and transition to inputting', async () => {
-      const configWithPrefill = { ...mockEmailConfig, prefill: true };
-      const actor = createActor(emailMachine, {
-        input: { config: configWithPrefill },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      const { context } = actor.getSnapshot();
-      expect(context.prefilledEmail).toBe('user@example.com');
-      expect(context.email).toBe('user@example.com');
-
-      actor.stop();
-    });
-
-    it('should handle prefill fetch error and still transition to inputting', async () => {
-      const { fetchEmail } = await import('./emailServices');
-      vi.mocked(fetchEmail).mockRejectedValueOnce(new Error('Network error'));
-
-      const configWithPrefill = { ...mockEmailConfig, prefill: true };
-      const actor = createActor(emailMachine, {
-        input: { config: configWithPrefill },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      // Should still be in inputting even if prefill failed
-      const { context } = actor.getSnapshot();
-      expect(context.prefilledEmail).toBeUndefined();
-
-      actor.stop();
-    });
-  });
-
-  describe('OTP error handling', () => {
-    it('should transition to otpError when OTP verification fails with attempts remaining', async () => {
-      const { verifyEmailOtp } = await import('./emailServices');
-      vi.mocked(verifyEmailOtp).mockResolvedValueOnce({ success: false });
-
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG1' } as EmailEvent);
-      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 { verifyEmailOtp } = await import('./emailServices');
-      vi.mocked(verifyEmailOtp).mockResolvedValueOnce({ success: false });
-
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG1' } as EmailEvent);
-      actor.send({ type: 'VERIFY_OTP' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('otpError');
-      });
-
-      // OTP_CHANGED from otpError should transition back to awaitingOtp
-      actor.send({ type: 'OTP_CHANGED', code: 'RETRY' } as EmailEvent);
-
-      expect(actor.getSnapshot().value).toBe('awaitingOtp');
-
-      actor.stop();
-    });
-
-    it('should transition to error when all OTP attempts are exhausted', async () => {
-      const { verifyEmailOtp } = await import('./emailServices');
-      vi.mocked(verifyEmailOtp).mockResolvedValue({ success: false });
-
-      const configWith1Attempt = { ...mockEmailConfig, maxOtpAttempts: 1 };
-      const actor = createActor(emailMachine, {
-        input: { config: configWith1Attempt },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG' } as EmailEvent);
-      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 { verifyEmailOtp } = await import('./emailServices');
-      vi.mocked(verifyEmailOtp).mockResolvedValueOnce({ success: false });
-
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      actor.send({ type: 'SUBMIT' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('awaitingOtp');
-      });
-
-      actor.send({ type: 'OTP_CHANGED', code: 'WRONG' } as EmailEvent);
-      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(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      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();
-    });
-  });
-
-  describe('SendOtp error handling', () => {
-    it('should handle sendOtp error and still transition to awaitingOtp', async () => {
-      const { sendEmailOtp } = await import('./emailServices');
-      vi.mocked(sendEmailOtp).mockRejectedValueOnce(new Error('SMS failed'));
-
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      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();
-    });
-  });
-
-  describe('Resend timer', () => {
-    it('should initialize resend timer when entering awaitingOtp', async () => {
-      const actor = createActor(emailMachine, {
-        input: { config: mockEmailConfig },
-      }).start();
-
-      actor.send({ type: 'LOAD' });
-
-      await vi.waitFor(() => {
-        expect(actor.getSnapshot().value).toBe('inputting');
-      });
-
-      actor.send({
-        type: 'EMAIL_CHANGED',
-        email: 'user@example.com',
-        isValid: true,
-      } as EmailEvent);
-      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();
-    });
-  });
-});