@fiado/type-kit 3.249.0 → 3.251.0

package/_test_/unit/kyc/KycStepCompletedV1.test.ts

@@ -1,239 +1,239 @@
-import 'reflect-metadata';
-import { plainToInstance } from 'class-transformer';
-import { validate } from 'class-validator';
-import {
-  KycStepCompletedV1,
-  KycVerificationChangedV1,
-  KycSubCheckNameEnum,
-  KycSubCheckStatusEnum,
-  KycWatchlistStatusEnum,
-  KYC_WATCHLIST_STEPS,
-} from '../../../src/kyc/index';
-
-/** Base válida de una estación binaria; cada caso pisa solo el campo que está probando. */
-const base = {
-  verificationId: 'ver-1',
-  directoryId: 'dir-1',
-  step: 'facematch',
-  status: 'PASS',
-  occurredAt: '2026-07-26T10:05:00.000Z',
-};
-
-const instancia = (raw: Record<string, unknown>): KycStepCompletedV1 =>
-  plainToInstance(KycStepCompletedV1, raw, { excludeExtraneousValues: true });
-
-describe('KycStepCompletedV1', () => {
-  it('valida el shape que publica el webhook desde un step_completed', async () => {
-    const dto = instancia({ ...base, metamapFlowId: 'flow-1' });
-
-    expect(await validate(dto as object)).toHaveLength(0);
-    expect(dto.step).toBe(KycSubCheckNameEnum.FACEMATCH);
-    expect(dto.status).toBe(KycSubCheckStatusEnum.PASS);
-  });
-
-  it('valida sin metamapFlowId (es opcional, solo diagnóstico)', async () => {
-    const dto = instancia(base);
-
-    expect(await validate(dto as object)).toHaveLength(0);
-    expect(dto.metamapFlowId).toBeUndefined();
-  });
-
-  // Sin directoryId el consumidor no puede encontrar la sesión: el evento no sirve para nada.
-  it('rechaza un evento sin directoryId (sin él no hay gate posible)', async () => {
-    const { directoryId: _omitido, ...sinDirectory } = base;
-    const errors = await validate(instancia(sinDirectory) as object);
-
-    expect(errors.map((e) => e.property)).toContain('directoryId');
-  });
-
-  // DEC-KYC-015: un '' pasa @IsString() en silencio y falla tres pasos río abajo.
-  it.each(['verificationId', 'directoryId'])('rechaza %s vacío', async (campo) => {
-    const errors = await validate(instancia({ ...base, [campo]: '' }) as object);
-
-    expect(errors.map((e) => e.property)).toContain(campo);
-  });
-
-  // Candado del contrato: solo viajan las 8 estaciones de KycSubChecks. Metamap emite 13 —
-  // 'selfie', 'voice', 'ipValidation' y compañía NO forman parte del contrato. Sin esto, el
-  // campo se podría degradar a @IsString() y una estación desconocida llegaría al progreso.
-  it('rechaza una estación que Metamap emite pero NO está en el contrato', async () => {
-    const errors = await validate(instancia({ ...base, step: 'selfie' }) as object);
-
-    expect(errors.map((e) => e.property)).toContain('step');
-  });
-
-  // ── El cruce step ↔ status: la razón de ser del validador custom ───────────
-
-  it.each(KYC_WATCHLIST_STEPS)('acepta CLEAR y HIT en la estación de lista %s', async (step) => {
-    const clear = await validate(instancia({ ...base, step, status: 'CLEAR' }) as object);
-    const hit = await validate(instancia({ ...base, step, status: 'HIT' }) as object);
-
-    expect(clear).toHaveLength(0);
-    expect(hit).toHaveLength(0);
-  });
-
-  /**
-   * El candado que justifica el validador. Un `@IsIn(['PASS','FAIL','CLEAR','HIT'])` dejaría pasar
-   * esto y el matiz se perdería: un HIT es "que lo mire cumplimiento", no una falla. Con este evento
-   * colado, la pantalla del vendedor marcaría como fallida una estación que solo pide revisión.
-   */
-  it.each(KYC_WATCHLIST_STEPS)('rechaza FAIL en la estación de lista %s (un HIT no es un fallo)', async (step) => {
-    const errors = await validate(instancia({ ...base, step, status: 'FAIL' }) as object);
-
-    expect(errors.map((e) => e.property)).toContain('status');
-  });
-
-  const BINARIOS = Object.values(KycSubCheckNameEnum).filter((s) => !KYC_WATCHLIST_STEPS.includes(s));
-
-  it.each(BINARIOS)('acepta PASS y FAIL en la estación binaria %s', async (step) => {
-    const pass = await validate(instancia({ ...base, step, status: 'PASS' }) as object);
-    const fail = await validate(instancia({ ...base, step, status: 'FAIL' }) as object);
-
-    expect(pass).toHaveLength(0);
-    expect(fail).toHaveLength(0);
-  });
-
-  it.each(BINARIOS)('rechaza HIT en la estación binaria %s', async (step) => {
-    const errors = await validate(instancia({ ...base, step, status: 'HIT' }) as object);
-
-    expect(errors.map((e) => e.property)).toContain('status');
-  });
-
-  it('rechaza un status inventado', async () => {
-    const errors = await validate(instancia({ ...base, status: 'MAS_O_MENOS' }) as object);
-
-    expect(errors.map((e) => e.property)).toContain('status');
-  });
-
-  // Con un step inválido no hay vocabulario contra el cual medir el status: fallan los dos.
-  it('rechaza el status cuando el step no es reconocido', async () => {
-    const errors = await validate(instancia({ ...base, step: 'inventado' }) as object);
-
-    expect(errors.map((e) => e.property)).toEqual(expect.arrayContaining(['step', 'status']));
-  });
-
-  // ── Orden ─────────────────────────────────────────────────────────────────
-
-  /**
-   * SQS estándar no garantiza orden. El consumidor descarta las estaciones que llegan más viejas
-   * que lo que ya escribió, y para eso `occurredAt` tiene que ser léxicamente ordenable.
-   */
-  it('rechaza occurredAt con formato no ISO-8601', async () => {
-    const errors = await validate(instancia({ ...base, occurredAt: '26/07/2026' }) as object);
-
-    expect(errors.map((e) => e.property)).toContain('occurredAt');
-  });
-
-  it('rechaza un evento sin occurredAt (sin marca de tiempo no hay cómo ordenar)', async () => {
-    const { occurredAt: _omitido, ...sinFecha } = base;
-    const errors = await validate(instancia(sinFecha) as object);
-
-    expect(errors.map((e) => e.property)).toContain('occurredAt');
-  });
-
-  /**
-   * `@IsISO8601()` a secas acepta TODOS estos, y cada uno rompe la comparación léxica de distinta
-   * forma. El offset es el peligroso: `T15:05:00+05:00` son las 10:05 UTC, pero léxicamente es
-   * "mayor" que un `T10:06:00Z` posterior — el consumidor lo lee como más nuevo, descarta la
-   * estación real y esa casilla nunca se pinta. Sin este candado el `@Matches` se puede quitar y
-   * la suite sigue verde.
-   */
-  it.each([
-    ['offset positivo en vez de Z', '2026-07-26T15:05:00+05:00'],
-    ['offset negativo en vez de Z', '2026-07-26T05:05:00-05:00'],
-    ['solo fecha, sin hora', '2026-07-26'],
-    ['formato básico sin guiones', '20260726T100500Z'],
-    ['fecha de semana ISO', '2026-W30-1'],
-    ['fecha imposible', '2026-02-30T10:05:00.000Z'],
-    ['sin zona horaria', '2026-07-26T10:05:00'],
-  ])('rechaza occurredAt %s', async (_etiqueta, valor) => {
-    const errors = await validate(instancia({ ...base, occurredAt: valor }) as object);
-
-    expect(errors.map((e) => e.property)).toContain('occurredAt');
-  });
-
-  it.each([
-    ['con milisegundos', '2026-07-26T10:05:00.000Z'],
-    ['sin milisegundos', '2026-07-26T10:05:00Z'],
-  ])('acepta occurredAt en UTC %s', async (_etiqueta, valor) => {
-    expect(await validate(instancia({ ...base, occurredAt: valor }) as object)).toHaveLength(0);
-  });
-
-  // ── eventType: el discriminador explícito ─────────────────────────────────
-
-  it('acepta el eventType explícito', async () => {
-    const dto = instancia({ ...base, eventType: 'KycStepCompletedV1' });
-
-    expect(await validate(dto as object)).toHaveLength(0);
-    expect(dto.eventType).toBe('KycStepCompletedV1');
-  });
-
-  // Opcional a propósito: agregarlo ahora es gratis, hacerlo obligatorio después del primer
-  // deploy sería breaking. Este candado prueba que hoy NO lo es.
-  it('valida sin eventType (es opcional para no romper al webhook antes de que lo mande)', async () => {
-    const dto = instancia(base);
-
-    expect(await validate(dto as object)).toHaveLength(0);
-    expect(dto.eventType).toBeUndefined();
-  });
-
-  // Si el día de mañana llega un `KycStepStartedV1`, tiene que caer como "no soportado" en el
-  // ruteo, no colarse por esta rama y morir en el DLQ como "corrupto".
-  it('rechaza un eventType de otro evento', async () => {
-    const errors = await validate(instancia({ ...base, eventType: 'KycStepStartedV1' }) as object);
-
-    expect(errors.map((e) => e.property)).toContain('eventType');
-  });
-
-  // ── Convivencia en la misma cola ──────────────────────────────────────────
-
-  /**
-   * Los dos eventos comparten `RetailKycInboundQueue` y el discriminador es la presencia de `step`.
-   * Estos dos candados prueban que un evento NO se puede hacer pasar por el otro: si alguien
-   * agregara campos que los volvieran mutuamente válidos, el consumidor tomaría la rama equivocada
-   * y el cierre de la verificación se procesaría como una estación suelta (o al revés).
-   */
-  it('un cierre de verificación NO valida como evento de estación', async () => {
-    const cierre = {
-      verificationId: 'ver-1', directoryId: 'dir-1', peopleId: 'ppl-1',
-      verificationStatus: 'COMPLETED', verificationResult: 'VERIFIED',
-      updateDate: '2026-07-26T10:05:00.000Z',
-    };
-
-    const errors = await validate(instancia(cierre) as object);
-
-    expect(errors.map((e) => e.property)).toEqual(expect.arrayContaining(['step', 'status', 'occurredAt']));
-  });
-
-  it('un evento de estación NO valida como cierre de verificación', async () => {
-    const dto = plainToInstance(KycVerificationChangedV1, base, { excludeExtraneousValues: true });
-    const errors = await validate(dto as object);
-
-    expect(errors.map((e) => e.property)).toEqual(
-      expect.arrayContaining(['peopleId', 'verificationStatus', 'verificationResult', 'updateDate']),
-    );
-  });
-
-  // ── El contrato con KycSubChecks ──────────────────────────────────────────
-
-  /**
-   * El consumidor arma el progreso con `progreso[evento.step] = evento.status`. Si un valor del enum
-   * dejara de coincidir con su llave en `KycSubChecks`, escribiría un campo huérfano y esa estación
-   * nunca se marcaría — sin que nada truene. Este test es el único lugar donde eso se detecta.
-   */
-  it('cada valor del enum es una llave real de KycSubChecks', () => {
-    const llavesDeSubChecks = [
-      'documentReading', 'templateMatching', 'alterationDetection', 'facematch',
-      'liveness', 'ageCheck', 'watchlists', 'premiumAmlWatchlists',
-    ];
-
-    expect(Object.values(KycSubCheckNameEnum).sort()).toEqual(llavesDeSubChecks.sort());
-  });
-
-  it('las estaciones de lista son exactamente las dos que usan CLEAR/HIT', () => {
-    expect([...KYC_WATCHLIST_STEPS].sort()).toEqual(
-      [KycSubCheckNameEnum.PREMIUM_AML_WATCHLISTS, KycSubCheckNameEnum.WATCHLISTS].sort(),
-    );
-    expect(Object.values(KycWatchlistStatusEnum)).toEqual(['CLEAR', 'HIT']);
-  });
-});
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import {
+  KycStepCompletedV1,
+  KycVerificationChangedV1,
+  KycSubCheckNameEnum,
+  KycSubCheckStatusEnum,
+  KycWatchlistStatusEnum,
+  KYC_WATCHLIST_STEPS,
+} from '../../../src/kyc/index';
+
+/** Base válida de una estación binaria; cada caso pisa solo el campo que está probando. */
+const base = {
+  verificationId: 'ver-1',
+  directoryId: 'dir-1',
+  step: 'facematch',
+  status: 'PASS',
+  occurredAt: '2026-07-26T10:05:00.000Z',
+};
+
+const instancia = (raw: Record<string, unknown>): KycStepCompletedV1 =>
+  plainToInstance(KycStepCompletedV1, raw, { excludeExtraneousValues: true });
+
+describe('KycStepCompletedV1', () => {
+  it('valida el shape que publica el webhook desde un step_completed', async () => {
+    const dto = instancia({ ...base, metamapFlowId: 'flow-1' });
+
+    expect(await validate(dto as object)).toHaveLength(0);
+    expect(dto.step).toBe(KycSubCheckNameEnum.FACEMATCH);
+    expect(dto.status).toBe(KycSubCheckStatusEnum.PASS);
+  });
+
+  it('valida sin metamapFlowId (es opcional, solo diagnóstico)', async () => {
+    const dto = instancia(base);
+
+    expect(await validate(dto as object)).toHaveLength(0);
+    expect(dto.metamapFlowId).toBeUndefined();
+  });
+
+  // Sin directoryId el consumidor no puede encontrar la sesión: el evento no sirve para nada.
+  it('rechaza un evento sin directoryId (sin él no hay gate posible)', async () => {
+    const { directoryId: _omitido, ...sinDirectory } = base;
+    const errors = await validate(instancia(sinDirectory) as object);
+
+    expect(errors.map((e) => e.property)).toContain('directoryId');
+  });
+
+  // DEC-KYC-015: un '' pasa @IsString() en silencio y falla tres pasos río abajo.
+  it.each(['verificationId', 'directoryId'])('rechaza %s vacío', async (campo) => {
+    const errors = await validate(instancia({ ...base, [campo]: '' }) as object);
+
+    expect(errors.map((e) => e.property)).toContain(campo);
+  });
+
+  // Candado del contrato: solo viajan las 8 estaciones de KycSubChecks. Metamap emite 13 —
+  // 'selfie', 'voice', 'ipValidation' y compañía NO forman parte del contrato. Sin esto, el
+  // campo se podría degradar a @IsString() y una estación desconocida llegaría al progreso.
+  it('rechaza una estación que Metamap emite pero NO está en el contrato', async () => {
+    const errors = await validate(instancia({ ...base, step: 'selfie' }) as object);
+
+    expect(errors.map((e) => e.property)).toContain('step');
+  });
+
+  // ── El cruce step ↔ status: la razón de ser del validador custom ───────────
+
+  it.each(KYC_WATCHLIST_STEPS)('acepta CLEAR y HIT en la estación de lista %s', async (step) => {
+    const clear = await validate(instancia({ ...base, step, status: 'CLEAR' }) as object);
+    const hit = await validate(instancia({ ...base, step, status: 'HIT' }) as object);
+
+    expect(clear).toHaveLength(0);
+    expect(hit).toHaveLength(0);
+  });
+
+  /**
+   * El candado que justifica el validador. Un `@IsIn(['PASS','FAIL','CLEAR','HIT'])` dejaría pasar
+   * esto y el matiz se perdería: un HIT es "que lo mire cumplimiento", no una falla. Con este evento
+   * colado, la pantalla del vendedor marcaría como fallida una estación que solo pide revisión.
+   */
+  it.each(KYC_WATCHLIST_STEPS)('rechaza FAIL en la estación de lista %s (un HIT no es un fallo)', async (step) => {
+    const errors = await validate(instancia({ ...base, step, status: 'FAIL' }) as object);
+
+    expect(errors.map((e) => e.property)).toContain('status');
+  });
+
+  const BINARIOS = Object.values(KycSubCheckNameEnum).filter((s) => !KYC_WATCHLIST_STEPS.includes(s));
+
+  it.each(BINARIOS)('acepta PASS y FAIL en la estación binaria %s', async (step) => {
+    const pass = await validate(instancia({ ...base, step, status: 'PASS' }) as object);
+    const fail = await validate(instancia({ ...base, step, status: 'FAIL' }) as object);
+
+    expect(pass).toHaveLength(0);
+    expect(fail).toHaveLength(0);
+  });
+
+  it.each(BINARIOS)('rechaza HIT en la estación binaria %s', async (step) => {
+    const errors = await validate(instancia({ ...base, step, status: 'HIT' }) as object);
+
+    expect(errors.map((e) => e.property)).toContain('status');
+  });
+
+  it('rechaza un status inventado', async () => {
+    const errors = await validate(instancia({ ...base, status: 'MAS_O_MENOS' }) as object);
+
+    expect(errors.map((e) => e.property)).toContain('status');
+  });
+
+  // Con un step inválido no hay vocabulario contra el cual medir el status: fallan los dos.
+  it('rechaza el status cuando el step no es reconocido', async () => {
+    const errors = await validate(instancia({ ...base, step: 'inventado' }) as object);
+
+    expect(errors.map((e) => e.property)).toEqual(expect.arrayContaining(['step', 'status']));
+  });
+
+  // ── Orden ─────────────────────────────────────────────────────────────────
+
+  /**
+   * SQS estándar no garantiza orden. El consumidor descarta las estaciones que llegan más viejas
+   * que lo que ya escribió, y para eso `occurredAt` tiene que ser léxicamente ordenable.
+   */
+  it('rechaza occurredAt con formato no ISO-8601', async () => {
+    const errors = await validate(instancia({ ...base, occurredAt: '26/07/2026' }) as object);
+
+    expect(errors.map((e) => e.property)).toContain('occurredAt');
+  });
+
+  it('rechaza un evento sin occurredAt (sin marca de tiempo no hay cómo ordenar)', async () => {
+    const { occurredAt: _omitido, ...sinFecha } = base;
+    const errors = await validate(instancia(sinFecha) as object);
+
+    expect(errors.map((e) => e.property)).toContain('occurredAt');
+  });
+
+  /**
+   * `@IsISO8601()` a secas acepta TODOS estos, y cada uno rompe la comparación léxica de distinta
+   * forma. El offset es el peligroso: `T15:05:00+05:00` son las 10:05 UTC, pero léxicamente es
+   * "mayor" que un `T10:06:00Z` posterior — el consumidor lo lee como más nuevo, descarta la
+   * estación real y esa casilla nunca se pinta. Sin este candado el `@Matches` se puede quitar y
+   * la suite sigue verde.
+   */
+  it.each([
+    ['offset positivo en vez de Z', '2026-07-26T15:05:00+05:00'],
+    ['offset negativo en vez de Z', '2026-07-26T05:05:00-05:00'],
+    ['solo fecha, sin hora', '2026-07-26'],
+    ['formato básico sin guiones', '20260726T100500Z'],
+    ['fecha de semana ISO', '2026-W30-1'],
+    ['fecha imposible', '2026-02-30T10:05:00.000Z'],
+    ['sin zona horaria', '2026-07-26T10:05:00'],
+  ])('rechaza occurredAt %s', async (_etiqueta, valor) => {
+    const errors = await validate(instancia({ ...base, occurredAt: valor }) as object);
+
+    expect(errors.map((e) => e.property)).toContain('occurredAt');
+  });
+
+  it.each([
+    ['con milisegundos', '2026-07-26T10:05:00.000Z'],
+    ['sin milisegundos', '2026-07-26T10:05:00Z'],
+  ])('acepta occurredAt en UTC %s', async (_etiqueta, valor) => {
+    expect(await validate(instancia({ ...base, occurredAt: valor }) as object)).toHaveLength(0);
+  });
+
+  // ── eventType: el discriminador explícito ─────────────────────────────────
+
+  it('acepta el eventType explícito', async () => {
+    const dto = instancia({ ...base, eventType: 'KycStepCompletedV1' });
+
+    expect(await validate(dto as object)).toHaveLength(0);
+    expect(dto.eventType).toBe('KycStepCompletedV1');
+  });
+
+  // Opcional a propósito: agregarlo ahora es gratis, hacerlo obligatorio después del primer
+  // deploy sería breaking. Este candado prueba que hoy NO lo es.
+  it('valida sin eventType (es opcional para no romper al webhook antes de que lo mande)', async () => {
+    const dto = instancia(base);
+
+    expect(await validate(dto as object)).toHaveLength(0);
+    expect(dto.eventType).toBeUndefined();
+  });
+
+  // Si el día de mañana llega un `KycStepStartedV1`, tiene que caer como "no soportado" en el
+  // ruteo, no colarse por esta rama y morir en el DLQ como "corrupto".
+  it('rechaza un eventType de otro evento', async () => {
+    const errors = await validate(instancia({ ...base, eventType: 'KycStepStartedV1' }) as object);
+
+    expect(errors.map((e) => e.property)).toContain('eventType');
+  });
+
+  // ── Convivencia en la misma cola ──────────────────────────────────────────
+
+  /**
+   * Los dos eventos comparten `RetailKycInboundQueue` y el discriminador es la presencia de `step`.
+   * Estos dos candados prueban que un evento NO se puede hacer pasar por el otro: si alguien
+   * agregara campos que los volvieran mutuamente válidos, el consumidor tomaría la rama equivocada
+   * y el cierre de la verificación se procesaría como una estación suelta (o al revés).
+   */
+  it('un cierre de verificación NO valida como evento de estación', async () => {
+    const cierre = {
+      verificationId: 'ver-1', directoryId: 'dir-1', peopleId: 'ppl-1',
+      verificationStatus: 'COMPLETED', verificationResult: 'VERIFIED',
+      updateDate: '2026-07-26T10:05:00.000Z',
+    };
+
+    const errors = await validate(instancia(cierre) as object);
+
+    expect(errors.map((e) => e.property)).toEqual(expect.arrayContaining(['step', 'status', 'occurredAt']));
+  });
+
+  it('un evento de estación NO valida como cierre de verificación', async () => {
+    const dto = plainToInstance(KycVerificationChangedV1, base, { excludeExtraneousValues: true });
+    const errors = await validate(dto as object);
+
+    expect(errors.map((e) => e.property)).toEqual(
+      expect.arrayContaining(['peopleId', 'verificationStatus', 'verificationResult', 'updateDate']),
+    );
+  });
+
+  // ── El contrato con KycSubChecks ──────────────────────────────────────────
+
+  /**
+   * El consumidor arma el progreso con `progreso[evento.step] = evento.status`. Si un valor del enum
+   * dejara de coincidir con su llave en `KycSubChecks`, escribiría un campo huérfano y esa estación
+   * nunca se marcaría — sin que nada truene. Este test es el único lugar donde eso se detecta.
+   */
+  it('cada valor del enum es una llave real de KycSubChecks', () => {
+    const llavesDeSubChecks = [
+      'documentReading', 'templateMatching', 'alterationDetection', 'facematch',
+      'liveness', 'ageCheck', 'watchlists', 'premiumAmlWatchlists',
+    ];
+
+    expect(Object.values(KycSubCheckNameEnum).sort()).toEqual(llavesDeSubChecks.sort());
+  });
+
+  it('las estaciones de lista son exactamente las dos que usan CLEAR/HIT', () => {
+    expect([...KYC_WATCHLIST_STEPS].sort()).toEqual(
+      [KycSubCheckNameEnum.PREMIUM_AML_WATCHLISTS, KycSubCheckNameEnum.WATCHLISTS].sort(),
+    );
+    expect(Object.values(KycWatchlistStatusEnum)).toEqual(['CLEAR', 'HIT']);
+  });
+});