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

package/src/selfie/selfieStateMachine.test.ts

@@ -1,283 +0,0 @@
-import {
-  createActor,
-  type FaceDetectionProvider,
-  IncodeCanvas,
-} from '@incodetech/infra';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  mockSelfieConfig,
-  mockSelfieConfigWithOneAttempt,
-} from './__mocks__/selfieMocks';
-import { selfieMachine } from './selfieStateMachine';
-
-vi.mock('../events/addEvent', () => ({
-  addEvent: vi.fn().mockResolvedValue(undefined),
-}));
-
-vi.mock('../permissions/permissionServices', () => ({
-  checkPermission: vi.fn().mockResolvedValue('granted'),
-  requestPermission: vi.fn().mockResolvedValue('granted'),
-}));
-
-vi.mock('./selfieServices', () => ({
-  encryptSelfieImage: vi.fn().mockResolvedValue('encrypted'),
-  initializeCamera: vi.fn().mockResolvedValue({
-    stream: new MediaStream(),
-    provider: { dispose: vi.fn().mockResolvedValue(undefined), reset: vi.fn() },
-  }),
-  startDetection: vi.fn().mockImplementation(() => ({
-    cleanup: vi.fn(),
-    reset: vi.fn(),
-  })),
-  startRecordingSession: vi.fn().mockResolvedValue(undefined),
-  stopRecording: vi.fn(),
-  stopStream: vi.fn(),
-  uploadSelfie: vi.fn().mockResolvedValue({
-    age: 0,
-    confidence: 0,
-    hasClosedEyes: false,
-    hasFaceMask: false,
-    hasHeadCover: false,
-    hasLenses: false,
-    isBright: true,
-    liveness: true,
-    imageBase64: '',
-    sessionStatus: 'ok',
-  }),
-}));
-
-type SelfieActor = ReturnType<typeof createTestActor>;
-
-function createTestActor(config = mockSelfieConfig) {
-  return createActor(selfieMachine, { input: { config } }).start();
-}
-
-function createCanvas(): IncodeCanvas {
-  const raw = document.createElement('canvas');
-  raw.width = 10;
-  raw.height = 10;
-  return new IncodeCanvas(raw);
-}
-
-async function waitForCaptureDetecting(actor: SelfieActor): Promise<void> {
-  await vi.waitFor(
-    () => {
-      if (!actor.getSnapshot().matches({ capture: 'detecting' })) {
-        throw new Error('Not detecting yet');
-      }
-    },
-    { timeout: 2000 },
-  );
-}
-
-describe('selfieMachine', () => {
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    const permissionServices = await import(
-      '../permissions/permissionServices'
-    );
-    vi.mocked(permissionServices.checkPermission).mockResolvedValue('granted');
-    vi.mocked(permissionServices.requestPermission).mockResolvedValue(
-      'granted',
-    );
-
-    const selfieServices = await import('./selfieServices');
-    const provider = {
-      dispose: vi.fn().mockResolvedValue(undefined),
-      reset: vi.fn(),
-    } as unknown as FaceDetectionProvider;
-    vi.mocked(selfieServices.initializeCamera).mockResolvedValue({
-      stream: new MediaStream(),
-      provider,
-    });
-    vi.mocked(selfieServices.startDetection).mockReturnValue({
-      cleanup: vi.fn(),
-      reset: vi.fn(),
-    });
-    vi.mocked(selfieServices.uploadSelfie).mockResolvedValue({
-      age: 0,
-      confidence: 0,
-      hasClosedEyes: false,
-      hasFaceMask: false,
-      hasHeadCover: false,
-      hasLenses: false,
-      isBright: true,
-      liveness: true,
-      imageBase64: '',
-      sessionStatus: 'ok',
-    });
-  });
-
-  it('starts in idle', () => {
-    const actor = createTestActor();
-    expect(actor.getSnapshot().value).toBe('idle');
-    actor.stop();
-  });
-
-  it('goes to permissions when permission is not granted', async () => {
-    const { checkPermission } = await import(
-      '../permissions/permissionServices'
-    );
-    vi.mocked(checkPermission).mockResolvedValue('prompt');
-
-    const actor = createTestActor();
-    actor.send({ type: 'LOAD' });
-
-    await vi.waitFor(() => {
-      expect(actor.getSnapshot().matches('permissions')).toBe(true);
-    });
-
-    actor.stop();
-  });
-
-  it('goes to capture.detecting when permission is granted and camera initializes', async () => {
-    const actor = createTestActor();
-    actor.send({ type: 'LOAD' });
-
-    await waitForCaptureDetecting(actor);
-
-    actor.stop();
-  });
-
-  it('invokes startRecordingSession when enableFaceRecording is true', async () => {
-    const selfieServices = await import('./selfieServices');
-    const startRecordingSession = vi.mocked(
-      selfieServices.startRecordingSession,
-    );
-    startRecordingSession.mockResolvedValueOnce(undefined);
-
-    const actor = createTestActor({
-      ...mockSelfieConfig,
-      enableFaceRecording: true,
-    });
-    actor.send({ type: 'LOAD' });
-    await waitForCaptureDetecting(actor);
-
-    expect(startRecordingSession).toHaveBeenCalledTimes(1);
-
-    actor.stop();
-  });
-
-  it('reaches finished after detection success and upload success', async () => {
-    const actor = createTestActor();
-    actor.send({ type: 'LOAD' });
-    await waitForCaptureDetecting(actor);
-
-    actor.send({
-      type: 'DETECTION_SUCCESS',
-      canvas: createCanvas(),
-    });
-
-    await vi.waitFor(
-      () => {
-        if (!actor.getSnapshot().matches('finished')) {
-          throw new Error('Not finished yet');
-        }
-      },
-      { timeout: 4000 },
-    );
-
-    actor.stop();
-  });
-
-  it('goes to uploadError on upload failure and decrements attemptsRemaining', async () => {
-    const { uploadSelfie } = await import('./selfieServices');
-    vi.mocked(uploadSelfie).mockRejectedValueOnce(new Error('UPLOAD_FAILED'));
-
-    const actor = createTestActor();
-    actor.send({ type: 'LOAD' });
-    await waitForCaptureDetecting(actor);
-
-    actor.send({
-      type: 'DETECTION_SUCCESS',
-      canvas: createCanvas(),
-    });
-
-    await vi.waitFor(() => {
-      expect(actor.getSnapshot().matches({ capture: 'uploadError' })).toBe(
-        true,
-      );
-    });
-
-    expect(actor.getSnapshot().context.attemptsRemaining).toBe(
-      mockSelfieConfig.captureAttempts - 1,
-    );
-    expect(actor.getSnapshot().context.uploadError).toBe('SERVER_ERROR');
-
-    actor.stop();
-  });
-
-  it('retries capture when attempts remain', async () => {
-    const { uploadSelfie } = await import('./selfieServices');
-    vi.mocked(uploadSelfie).mockRejectedValueOnce(new Error('UPLOAD_FAILED'));
-
-    const actor = createTestActor();
-    actor.send({ type: 'LOAD' });
-    await waitForCaptureDetecting(actor);
-
-    actor.send({
-      type: 'DETECTION_SUCCESS',
-      canvas: createCanvas(),
-    });
-
-    await vi.waitFor(() => {
-      expect(actor.getSnapshot().matches({ capture: 'uploadError' })).toBe(
-        true,
-      );
-    });
-
-    actor.send({ type: 'RETRY_CAPTURE' });
-
-    await waitForCaptureDetecting(actor);
-
-    expect(actor.getSnapshot().context.uploadError).toBeUndefined();
-    expect(actor.getSnapshot().context.capturedImage).toBeUndefined();
-
-    actor.stop();
-  });
-
-  it('blocks retry when no attempts remain', async () => {
-    const { uploadSelfie } = await import('./selfieServices');
-    vi.mocked(uploadSelfie).mockRejectedValueOnce(new Error('UPLOAD_FAILED'));
-
-    const actor = createTestActor(mockSelfieConfigWithOneAttempt);
-    actor.send({ type: 'LOAD' });
-    await waitForCaptureDetecting(actor);
-
-    actor.send({
-      type: 'DETECTION_SUCCESS',
-      canvas: createCanvas(),
-    });
-
-    await vi.waitFor(() => {
-      expect(actor.getSnapshot().matches({ capture: 'uploadError' })).toBe(
-        true,
-      );
-    });
-
-    expect(actor.getSnapshot().context.attemptsRemaining).toBe(0);
-
-    actor.send({ type: 'RETRY_CAPTURE' });
-    expect(actor.getSnapshot().matches({ capture: 'uploadError' })).toBe(true);
-
-    actor.stop();
-  });
-
-  it('goes to uploadError with SERVER_ERROR on manual capture when no frame exists', async () => {
-    const actor = createTestActor();
-    actor.send({ type: 'LOAD' });
-    await waitForCaptureDetecting(actor);
-
-    actor.send({ type: 'MANUAL_CAPTURE' });
-
-    await vi.waitFor(() => {
-      expect(actor.getSnapshot().matches({ capture: 'uploadError' })).toBe(
-        true,
-      );
-    });
-
-    expect(actor.getSnapshot().context.uploadError).toBe('SERVER_ERROR');
-
-    actor.stop();
-  });
-});