import { BadRequestException } from '@nestjs/common';
import { LiquidacionesService } from './liquidaciones.service';

// Liquidaciones: una por moneda en una transacción, fecha del documento y estados terminales
// (spec 2026-10-17-comercial-finanzas, B5, B6, B9 y B10).

const PYG = { id: 'm-pyg', codigo: 'PYG', simbolo: '₲' };
const USD = { id: 'm-usd', codigo: 'USD', simbolo: 'US$' };
const VC = '3f6c1d2a-4b5e-4c7d-8e9f-0a1b2c3d4e5f';

const comision = (over: Record<string, any> = {}) => ({
  id: 'c-' + Math.random().toString(36).slice(2, 8),
  empresa_id: 'emp-1',
  vendedor_cobrador_id: VC,
  factura_id: 'f-1',
  recibo_id: null,
  tipo: 'venta',
  monto_base: '1000',
  monto_comision: '50',
  estado: 'pendiente',
  liquidacion_id: null,
  factura_cab: { moneda_id: PYG.id, moneda: PYG, dfeemide: new Date('2026-10-10T09:00:00Z') },
  recibos_cobro: null,
  ...over,
});

/**
 * Prisma falso con una "base" que solo guarda lo que confirma una transacción.
 * Lo que se escribe fuera de `$transaction` se confirma al instante.
 */
const crearService = (comisiones: any[], opts: { fallarCreate?: number; marcadas?: number; recibos?: any[] } = {}) => {
  const confirmadas: any[] = [];
  const escritas: Record<string, any> = {};
  let creates = 0;
  const hacerTx = (destino: any[]) => ({
    liquidaciones_comisiones: {
      create: jest.fn().mockImplementation(({ data }: any) => {
        creates++;
        if (opts.fallarCreate === creates) return Promise.reject(new Error('falla de base'));
        const fila = {
          id: `l-${creates}`,
          created_at: new Date('2026-11-02T12:00:00Z'),
          fecha_pago: null,
          ...data,
          moneda: [PYG, USD].find((m) => m.id === data.moneda_id) ?? null,
        };
        destino.push(fila);
        return Promise.resolve(fila);
      }),
    },
    comisiones: {
      updateMany: jest
        .fn()
        .mockImplementation(({ where }: any) => Promise.resolve({ count: opts.marcadas ?? where.id?.in?.length ?? 1 })),
    },
  });
  const directo = hacerTx(confirmadas);
  const prisma: any = {
    comisiones: { findMany: jest.fn().mockResolvedValue(comisiones), updateMany: directo.comisiones.updateMany },
    liquidaciones_comisiones: {
      create: directo.liquidaciones_comisiones.create,
      findFirst: jest.fn(),
      update: jest.fn().mockImplementation(({ where, data }: any) => Promise.resolve({ id: where.id, ...data })),
      // Escritura condicionada (I5): responde count 1 salvo que el test diga otra cosa.
      updateMany: jest.fn().mockImplementation(({ where, data }: any) => {
        escritas[where.id] = { id: where.id, ...data };
        return Promise.resolve({ count: 1 });
      }),
      findUnique: jest.fn().mockImplementation(({ where }: any) => Promise.resolve(escritas[where.id] ?? null)),
    },
    comisiones_supervisores: { update: jest.fn().mockResolvedValue({}) },
    recibos_cobro: { findMany: jest.fn().mockResolvedValue(opts.recibos ?? []) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda: PYG }) },
    moneda: { findFirst: jest.fn().mockResolvedValue(PYG), findUnique: jest.fn() },
    vendedores_cobradores: {
      findFirst: jest.fn().mockImplementation(({ where }: any) => Promise.resolve({ id: where.id })),
      findMany: jest
        .fn()
        .mockResolvedValue([{ id: VC, nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', codigo: 'V1' }]),
    },
  };
  prisma.$transaction = jest.fn().mockImplementation(async (cb: any) => {
    const pendientes: any[] = [];
    const tx: any = hacerTx(pendientes);
    tx.liquidaciones_comisiones.updateMany = prisma.liquidaciones_comisiones.updateMany;
    tx.comisiones_supervisores = prisma.comisiones_supervisores;
    tx.comisiones.updateMany = prisma.comisiones.updateMany;
    const r = await cb(tx);
    confirmadas.push(...pendientes);
    return r;
  });
  const contabilidad: any = {
    integrarDevengamientoComisiones: jest.fn().mockResolvedValue(undefined),
    integrarPagoComisiones: jest.fn().mockResolvedValue(undefined),
    revertirDocumento: jest.fn().mockResolvedValue(undefined),
  };
  return { service: new LiquidacionesService(prisma, contabilidad), prisma, contabilidad, confirmadas };
};

describe('LiquidacionesService', () => {
  it('crear: PYG y USD dan dos liquidaciones con su moneda', async () => {
    const { service, prisma, confirmadas, contabilidad } = crearService([
      comision({ monto_comision: '100' }),
      comision({ monto_comision: '20' }),
      comision({
        monto_comision: '7.5',
        factura_cab: { moneda_id: USD.id, moneda: USD, dfeemide: new Date('2026-10-12T09:00:00Z') },
      }),
      comision({
        tipo: 'cobranza',
        factura_id: null,
        factura_cab: null,
        recibo_id: 'r-1',
        monto_comision: '2.5',
        recibos_cobro: { moneda_id: USD.id, moneda: USD, fecha_emision: new Date('2026-10-20T15:00:00Z') },
      }),
    ]);

    const r = await service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31');

    const where = prisma.comisiones.findMany.mock.calls[0][0].where;
    expect(JSON.stringify(where)).not.toContain('created_at');
    expect(JSON.stringify(where)).toContain('dfeemide');

    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(confirmadas).toHaveLength(2);
    expect(r.advertencias).toEqual([]);
    expect(r.liquidaciones).toHaveLength(2);
    const porCodigo = Object.fromEntries(r.liquidaciones.map((l: any) => [l.moneda.codigo, l]));
    expect(porCodigo.PYG).toMatchObject({
      total_comisiones: 120,
      cantidad_facturas: 2,
      moneda: PYG,
      tipo: 'vendedor',
      estado: 'pendiente',
    });
    expect(porCodigo.USD).toMatchObject({ total_comisiones: 10, cantidad_facturas: 2, moneda: USD });
    expect(porCodigo.PYG.vendedor_cobrador).toMatchObject({ id: VC, nombre: 'Ana Gómez' });
    expect(confirmadas.map((l) => l.moneda_id).sort()).toEqual([PYG.id, USD.id].sort());
    expect(contabilidad.integrarDevengamientoComisiones).toHaveBeenCalledTimes(2);
  });

  it('crear: si falla la segunda no queda ninguna', async () => {
    const { service, confirmadas, contabilidad } = crearService(
      [
        comision(),
        comision({ factura_cab: { moneda_id: USD.id, moneda: USD, dfeemide: new Date('2026-10-12T09:00:00Z') } }),
      ],
      { fallarCreate: 2 },
    );

    await expect(service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31')).rejects.toThrow(
      'falla de base',
    );
    expect(confirmadas).toHaveLength(0);
    expect(contabilidad.integrarDevengamientoComisiones).not.toHaveBeenCalled();
  });

  it('crear: sin pendientes en el período responde 400', async () => {
    const { service } = crearService([]);
    await expect(service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31')).rejects.toThrow(
      new BadRequestException('No hay comisiones pendientes en el período'),
    );
  });

  it("pagar una anulada → 400 'La liquidación está anulada'", async () => {
    const { service, prisma } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({ id: 'l-1', tipo: 'vendedor', estado: 'anulada' });

    await expect(service.marcarComoPagada('emp-1', 'l-1')).rejects.toThrow(
      new BadRequestException('La liquidación está anulada'),
    );
    expect(prisma.liquidaciones_comisiones.update).not.toHaveBeenCalled();
  });

  it('pagar responde la fila con advertencias', async () => {
    const { service, prisma } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({ id: 'l-1', tipo: 'vendedor', estado: 'pendiente' });
    const r = await service.marcarComoPagada('emp-1', 'l-1');
    expect(r).toMatchObject({ id: 'l-1', estado: 'pagada', advertencias: [] });
  });

  it('crear: la falta de cotización vuelve en advertencias y la liquidación se crea igual', async () => {
    const { service, confirmadas, contabilidad } = crearService([
      comision(),
      comision({ factura_cab: { moneda_id: USD.id, moneda: USD, dfeemide: new Date('2026-10-12T09:00:00Z') } }),
    ]);
    contabilidad.integrarDevengamientoComisiones
      .mockResolvedValueOnce({})
      .mockResolvedValueOnce({ advertencia: 'Sin asiento: falta la cotización USD del 05/10/2026' });

    const r = await service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31');

    expect(confirmadas).toHaveLength(2);
    expect(r.liquidaciones).toHaveLength(2);
    expect(r.advertencias).toEqual(['Sin asiento: falta la cotización USD del 05/10/2026']);
  });

  it('pagar: la falta de cotización vuelve en advertencias y queda pagada', async () => {
    const { service, prisma, contabilidad } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({ id: 'l-1', tipo: 'vendedor', estado: 'pendiente' });
    contabilidad.integrarPagoComisiones.mockResolvedValue({ advertencia: 'Sin asiento: falta la cotización USD del 20/10/2026' });
    const r = await service.marcarComoPagada('emp-1', 'l-1');
    expect(r).toMatchObject({ id: 'l-1', estado: 'pagada', advertencias: ['Sin asiento: falta la cotización USD del 20/10/2026'] });
  });

  it('anular una anulada → 400', async () => {
    const { service, prisma } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({
      id: 'l-1',
      tipo: 'supervisor',
      estado: 'anulada',
      comision_supervisor_id: 'cs-1',
    });

    await expect(service.anularLiquidacion('emp-1', 'l-1')).rejects.toThrow(
      new BadRequestException('La liquidación ya está anulada'),
    );
    expect(prisma.liquidaciones_comisiones.update).not.toHaveBeenCalled();
    expect(prisma.comisiones_supervisores.update).not.toHaveBeenCalled();
  });

  it('anular responde la fila con advertencias', async () => {
    const { service, prisma } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({ id: 'l-1', tipo: 'vendedor', estado: 'pendiente' });
    const r = await service.anularLiquidacion('emp-1', 'l-1');
    expect(r).toMatchObject({ id: 'l-1', estado: 'anulada', advertencias: [] });
  });

  it('resumen: la moneda incluye las comisiones de recibo', async () => {
    const { service, prisma } = crearService([]);
    prisma.comisiones.findMany.mockResolvedValue([
      comision({
        estado: 'pendiente',
        monto_comision: '5',
        factura_cab: { moneda_id: USD.id, moneda: USD },
        vendedor_cobrador: { id: 'vc-1', nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', codigo: 'V1' },
      }),
      comision({
        tipo: 'cobranza',
        factura_id: null,
        factura_cab: null,
        estado: 'liquidada',
        monto_comision: '3',
        recibos_cobro: { moneda_id: USD.id, moneda: USD },
        vendedor_cobrador: { id: 'vc-1', nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', codigo: 'V1' },
      }),
      comision({
        estado: 'pendiente',
        monto_comision: '1000',
        vendedor_cobrador: { id: 'vc-1', nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', codigo: 'V1' },
      }),
    ]);
    prisma.moneda.findUnique.mockResolvedValue(USD);

    const r = await service.getResumenComisiones('emp-1', USD.id);
    expect(r).toEqual([
      {
        id: 'vc-1',
        nombre: 'Ana Gómez',
        tipo: 'vendedor',
        codigo: 'V1',
        comisiones_pendientes: { cantidad: 1, monto: 5 },
        comisiones_liquidadas: { cantidad: 1, monto: 3 },
        moneda: USD,
      },
    ]);
  });

  it("crear incluye comisiones 'aprobada'", async () => {
    const { service, prisma } = crearService([
      comision({ monto_comision: '100', estado: 'pendiente' }),
      comision({ monto_comision: '30', estado: 'aprobada', tipo: 'cobranza' }),
    ]);
    const r = await service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31');

    const where = prisma.comisiones.findMany.mock.calls[0][0].where;
    expect(where.estado).toEqual({ in: ['pendiente', 'aprobada'] });
    expect(r.liquidaciones).toHaveLength(1);
    expect(r.liquidaciones[0]).toMatchObject({ total_comisiones: 130, cantidad_facturas: 2 });
    const marcar = prisma.$transaction.mock.calls.length;
    expect(marcar).toBe(1);
  });

  it('crear: el updateMany también acepta aprobada y, si otro pedido tomó alguna, revierte todo (B10)', async () => {
    const { service, confirmadas, contabilidad } = crearService([comision(), comision({ estado: 'aprobada' })], {
      marcadas: 1,
    });
    await expect(service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31')).rejects.toThrow(
      'Otra liquidación tomó algunas de estas comisiones. Volvé a intentar.',
    );
    expect(confirmadas).toHaveLength(0);
    expect(contabilidad.integrarDevengamientoComisiones).not.toHaveBeenCalled();
  });

  it('crear: valida el período', async () => {
    const { service } = crearService([comision()]);
    await expect(service.crearLiquidacion('emp-1', VC, '', '2026-10-31')).rejects.toThrow(
      'El período necesita fecha desde y fecha hasta',
    );
    await expect(service.crearLiquidacion('emp-1', VC, '2026-11-01', '2026-10-31')).rejects.toThrow(
      'La fecha desde no puede ser posterior a la fecha hasta',
    );
    await expect(service.crearLiquidacion('emp-1', VC, '2026-13-45', '2026-10-31')).rejects.toThrow(
      BadRequestException,
    );
  });

  describe('RECIBO_MULTI', () => {
    const RECIBO_ID = '7b0f3c2e-1a2b-4c3d-9e8f-0123456789ab';
    const multi = (over: Record<string, any> = {}) =>
      comision({
        tipo: 'cobranza',
        factura_id: null,
        recibo_id: null,
        factura_cab: null,
        recibos_cobro: null,
        observaciones: `RECIBO_MULTI:${RECIBO_ID}`,
        monto_comision: '4',
        created_at: new Date('2026-12-15T12:00:00Z'),
        ...over,
      });

    it('crear la liquida en la moneda de su recibo', async () => {
      const { service, prisma } = crearService([comision({ monto_comision: '100' }), multi()], {
        recibos: [
          {
            id: RECIBO_ID,
            fecha_emision: new Date('2026-10-20T15:00:00Z'),
            estado: 'emitido',
            moneda_id: USD.id,
            moneda: USD,
            numero_recibo: 'R-1',
            clientes: null,
          },
        ],
      });
      const r = await service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31');

      expect(JSON.stringify(prisma.comisiones.findMany.mock.calls[0][0].where)).toContain(
        '"startsWith":"RECIBO_MULTI:"',
      );
      const porCodigo = Object.fromEntries(r.liquidaciones.map((l: any) => [l.moneda.codigo, l]));
      expect(porCodigo.USD).toMatchObject({ total_comisiones: 4, cantidad_facturas: 1 });
      expect(porCodigo.PYG).toMatchObject({ total_comisiones: 100 });
    });

    it('crear: sin recibo usa created_at y la base', async () => {
      const { service } = crearService([multi({ created_at: new Date('2026-10-15T12:00:00Z') })]);
      const r = await service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31');
      expect(r.liquidaciones).toHaveLength(1);
      expect(r.liquidaciones[0]).toMatchObject({ total_comisiones: 4, moneda: PYG });

      const { service: s2 } = crearService([multi({ created_at: new Date('2026-10-15T12:00:00Z') })]);
      await expect(s2.crearLiquidacion('emp-1', VC, '2026-11-01', '2026-11-30')).rejects.toThrow(
        'No hay comisiones pendientes en el período',
      );
    });
  });

  it('resumen: las aprobada cuentan como pendientes, igual que el resumen de Comisiones', async () => {
    const { service, prisma } = crearService([]);
    const vc = { id: 'vc-1', nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', codigo: 'V1' };
    prisma.comisiones.findMany.mockResolvedValue([
      comision({ estado: 'pendiente', monto_comision: '5', vendedor_cobrador: vc }),
      comision({ estado: 'aprobada', monto_comision: '3', vendedor_cobrador: vc }),
      comision({ estado: 'liquidada', monto_comision: '2', vendedor_cobrador: vc }),
    ]);
    const r = await service.getResumenComisiones('emp-1');

    expect(prisma.comisiones.findMany.mock.calls[0][0].where.estado).toEqual({
      in: ['pendiente', 'aprobada', 'liquidada'],
    });
    expect(r[0]).toMatchObject({
      comisiones_pendientes: { cantidad: 2, monto: 8 },
      comisiones_liquidadas: { cantidad: 1, monto: 2 },
      moneda: PYG,
    });
  });
  // I2 de la revisión final: sin la persona, crear tomaría las comisiones de toda la empresa.
  it('crear: sin vendedor/cobrador o con un id que no es uuid → 400, sin leer comisiones', async () => {
    const { service, prisma } = crearService([comision()]);
    for (const id of [undefined, '', 'vc-1']) {
      await expect(service.crearLiquidacion('emp-1', id as any, '2026-10-01', '2026-10-31')).rejects.toThrow(
        new BadRequestException('Seleccioná un vendedor/cobrador'),
      );
    }
    expect(prisma.comisiones.findMany).not.toHaveBeenCalled();
  });

  it('crear: un vendedor/cobrador de otra empresa → 404', async () => {
    const { service, prisma } = crearService([comision()]);
    prisma.vendedores_cobradores.findFirst.mockResolvedValue(null);
    await expect(service.crearLiquidacion('emp-1', VC, '2026-10-01', '2026-10-31')).rejects.toThrow(
      'Vendedor/cobrador no encontrado',
    );
    expect(prisma.vendedores_cobradores.findFirst.mock.calls[0][0].where).toEqual({ id: VC, empresa_id: 'emp-1' });
    expect(prisma.comisiones.findMany).not.toHaveBeenCalled();
  });

  // I5: pagar y anular condicionados al estado, contra el pedido simultáneo.
  it('pagar: la escritura va condicionada a pendiente y, si otro pedido la cambió, 400 sin asiento', async () => {
    const { service, prisma, contabilidad } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({ id: 'l-1', tipo: 'vendedor', estado: 'pendiente' });
    prisma.liquidaciones_comisiones.updateMany.mockResolvedValueOnce({ count: 0 });

    await expect(service.marcarComoPagada('emp-1', 'l-1')).rejects.toThrow(BadRequestException);
    expect(prisma.liquidaciones_comisiones.updateMany.mock.calls[0][0].where).toEqual({
      id: 'l-1',
      empresa_id: 'emp-1',
      tipo: 'vendedor',
      estado: 'pendiente',
    });
    expect(contabilidad.integrarPagoComisiones).not.toHaveBeenCalled();
  });

  it('anular de vendedor: si otro pedido la pagó, 400 y las comisiones no vuelven a pendiente', async () => {
    const { service, prisma, contabilidad } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({ id: 'l-1', tipo: 'vendedor', estado: 'pendiente' });
    prisma.liquidaciones_comisiones.updateMany.mockResolvedValueOnce({ count: 0 });

    await expect(service.anularLiquidacion('emp-1', 'l-1')).rejects.toThrow(BadRequestException);
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(prisma.liquidaciones_comisiones.updateMany.mock.calls[0][0].where).toMatchObject({ estado: 'pendiente' });
    expect(prisma.comisiones.updateMany).not.toHaveBeenCalled();
    expect(contabilidad.revertirDocumento).not.toHaveBeenCalled();
  });

  it('anular de vendedor: marca la liquidación y libera sus comisiones en la misma transacción', async () => {
    const { service, prisma, contabilidad } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({ id: 'l-1', tipo: 'vendedor', estado: 'pendiente' });

    const r = await service.anularLiquidacion('emp-1', 'l-1');

    expect(r).toMatchObject({ id: 'l-1', estado: 'anulada' });
    expect(prisma.comisiones.updateMany.mock.calls[0][0]).toMatchObject({
      where: { liquidacion_id: 'l-1' },
      data: { liquidacion_id: null, estado: 'pendiente' },
    });
    expect(contabilidad.revertirDocumento).toHaveBeenCalledTimes(2);
  });

  it('anular de supervisor: si otro pedido ya la anuló, 400 y la comisión no se toca', async () => {
    const { service, prisma } = crearService([]);
    prisma.liquidaciones_comisiones.findFirst.mockResolvedValue({
      id: 'l-1',
      tipo: 'supervisor',
      estado: 'pagada',
      comision_supervisor_id: 'cs-1',
    });
    prisma.liquidaciones_comisiones.updateMany.mockResolvedValueOnce({ count: 0 });

    await expect(service.anularLiquidacion('emp-1', 'l-1')).rejects.toThrow(BadRequestException);
    expect(prisma.liquidaciones_comisiones.updateMany.mock.calls[0][0].where).toEqual({
      id: 'l-1',
      empresa_id: 'emp-1',
      estado: { not: 'anulada' },
    });
    expect(prisma.comisiones_supervisores.update).not.toHaveBeenCalled();
  });

  // I1: el resumen excluye las de documentos anulados y las huérfanas, como Comisiones y Nueva liquidación.
  it('resumen: aplica el criterio de documento (sin rango) que excluye anuladas y huérfanas', async () => {
    const { service, prisma } = crearService([]);
    prisma.comisiones.findMany.mockResolvedValue([]);
    await service.getResumenComisiones('emp-1');

    const where = prisma.comisiones.findMany.mock.calls[0][0].where;
    expect(where.vendedor_cobrador).toEqual({ active: true });
    const [rFactura, rRecibo, rMulti] = where.OR;
    expect(rFactura.factura_cab.estado).toEqual({ notIn: ['Anulado', 'Anulada'] });
    expect(rFactura.factura_cab.OR).toEqual([{ estado_sifen: null }, { estado_sifen: { not: 'Cancelado' } }]);
    expect(rFactura.factura_cab.dfeemide).toBeUndefined();
    expect(rRecibo).toEqual({ factura_id: null, recibos_cobro: { estado: { not: 'anulado' } } });
    expect(rMulti).toMatchObject({ factura_id: null, recibo_id: null, observaciones: { startsWith: 'RECIBO_MULTI:' } });
  });

  // M1: una pendiente con liquidación no la toma Nueva liquidación, así que no cuenta como pendiente.
  it('resumen: una pendiente con liquidacion_id no cuenta como pendiente', async () => {
    const { service, prisma } = crearService([]);
    const vc = { id: 'vc-1', nombre: 'Ana', apellido: 'Gómez', tipo: 'vendedor', codigo: 'V1' };
    prisma.comisiones.findMany.mockResolvedValue([
      comision({ estado: 'pendiente', monto_comision: '5', vendedor_cobrador: vc }),
      comision({ estado: 'pendiente', monto_comision: '7', liquidacion_id: 'l-9', vendedor_cobrador: vc }),
      comision({ estado: 'liquidada', monto_comision: '2', liquidacion_id: 'l-1', vendedor_cobrador: vc }),
    ]);
    const r = await service.getResumenComisiones('emp-1');
    expect(r[0]).toMatchObject({
      comisiones_pendientes: { cantidad: 1, monto: 5 },
      comisiones_liquidadas: { cantidad: 1, monto: 2 },
    });
  });
});
