@incodetech/core 2.0.0-alpha.1

package/src/email/emailStateMachine.test.ts

@@ -0,0 +1,741 @@
+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();
+    });
+  });
+});