import { BadRequestException } from '@nestjs/common';
import { GastosService } from './gastos.service';
import * as ejecucion from 'src/requisiciones/ejecucion-requisicion';

/**
 * Alta y edición de gastos (plan 2026-10-19-gastos, Task 6): forma de pago
 * TRANSFERENCIA → CONTADO, vencimiento del crédito, editar pagados según la
 * empresa, edición financiera por valores (N5), gastos de viáticos e históricos.
 * Prisma falso en memoria, como gastos-multimoneda.spec.ts.
 */

const MONEDAS: Record<string, string> = { 'mon-pyg': 'PYG', 'mon-usd': 'USD' };
const EMISION = new Date('2026-10-05T00:00:00.000Z');

const gastoExistente = (extra: Record<string, unknown> = {}) => ({
  id: 'g1',
  empresa_id: 'emp',
  proveedor_id: 'prov-1',
  sucursal_id: null,
  requisicion_id: null,
  moneda_id: 'mon-pyg',
  cotizacion: '1.000000',
  forma_pago: 'CONTADO',
  estado: 'pagada',
  anulado: false,
  medio_pago_id: 'mp-1',
  cuenta_tesoreria_id: 'cta-1',
  total: '110000',
  fecha_emision: EMISION,
  fecha_vencimiento: null,
  pago_historico: false,
  rendicion_viatico_id: null,
  embarque_id: null,
  descripcion: null,
  ruc: null,
  timbrado: null,
  establecimiento: null,
  punto_expedicion: null,
  numero_factura: null,
  gasto_det: [
    {
      requisicion_det_id: null,
      producto_id: null,
      tipo_gasto_id: 'tg-1',
      descripcion: 'Combustible',
      cantidad: '1.0000',
      precio_unitario: '110000.0000',
      porcentaje_iva: '10.00',
      subtotal: '110000',
    },
  ],
  ...extra,
});

const item = (extra: Record<string, unknown> = {}) => ({
  tipo_gasto_id: 'tg-1',
  descripcion: 'Combustible',
  cantidad: 1,
  precio_unitario: 110000,
  porcentaje_iva: 10,
  ...extra,
});

/** Lo que manda la pantalla al guardar sin tocar nada: la cabecera completa y todos los ítems. */
const dtoPantalla = (cabecera: Record<string, unknown> = {}, items = [item()]) => ({
  cabecera: {
    proveedor_id: 'prov-1',
    forma_pago: 'CONTADO',
    moneda_id: 'mon-pyg',
    cotizacion: 1,
    medio_pago_id: 'mp-1',
    cuenta_tesoreria_id: 'cta-1',
    fecha_emision: '2026-10-05',
    ...cabecera,
  },
  items,
});

function armar(
  opts: {
    config?: Record<string, unknown>;
    existente?: Record<string, unknown> | null;
    pagos?: number;
    conciliado?: boolean;
  } = {},
) {
  const orden: string[] = [];
  const fueraDeTx: string[] = [];
  let dentro = false;
  const creados = {
    gastos: [] as any[],
    cxp: [] as any[],
    cxpRearmadas: [] as any[],
    cxpUpdateMany: [] as any[],
    gastoUpdates: [] as any[],
  };
  const prisma: any = {
    config_compras: {
      findUnique: jest.fn().mockResolvedValue({
        generar_cxp_automatico: true,
        modo_flujo_compra: 'directo',
        incluir_contado_en_orden_pago: false,
        permitir_editar_gasto_pagado: false,
        ...opts.config,
      }),
    },
    proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'prov-1', personas: { ruc: null, dv: null } }) },
    moneda: {
      findUnique: jest
        .fn()
        .mockImplementation(({ where }) => (MONEDAS[where.id] ? { id: where.id, codigo: MONEDAS[where.id] } : null)),
      findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }),
    },
    gasto_cab: {
      create: jest.fn().mockImplementation(({ data }) => (creados.gastos.push(data), { id: 'g1', ...data })),
      findFirst: jest.fn().mockResolvedValue(opts.existente === undefined ? gastoExistente() : opts.existente),
      update: jest.fn().mockImplementation(({ data }) => (creados.gastoUpdates.push(data), {})),
      updateMany: jest.fn().mockImplementation(({ data }) => (creados.gastoUpdates.push(data), { count: 1 })),
    },
    gasto_det: {
      createMany: jest.fn().mockResolvedValue({}),
      deleteMany: jest.fn().mockResolvedValue({}),
      findMany: jest.fn().mockResolvedValue([]),
    },
    cuentas_pagar: {
      create: jest.fn().mockImplementation(({ data }) => (creados.cxp.push(data), {})),
      findMany: jest.fn().mockResolvedValue([{ id: 'cxp-1' }]),
      update: jest.fn().mockImplementation(({ data }) => (creados.cxpRearmadas.push(data), {})),
      updateMany: jest.fn().mockImplementation((args) => (creados.cxpUpdateMany.push(args), {})),
    },
    pagos_proveedor: { count: jest.fn().mockResolvedValue(opts.pagos ?? 0) },
    orden_pago_proveedor_det: { findMany: jest.fn().mockResolvedValue([]) },
    rec_multi_gastos: { findMany: jest.fn().mockResolvedValue([]) },
    nota_credito_compra_cab: { findFirst: jest.fn().mockResolvedValue(null) },
    rendicion_viatico: { findUnique: jest.fn().mockResolvedValue({ numero_rendicion: 'RV-000007' }) },
    audit_logs: { findFirst: jest.fn().mockResolvedValue(null) },
    usuario: { findUnique: jest.fn().mockResolvedValue({ nombres: 'Ana', apellidos: 'Pérez' }) },
    empresas_sucursales: {
      findFirst: jest.fn().mockImplementation(({ where }) => (where.empresa_id === 'emp' && where.id === 'suc-1' ? { id: 'suc-1' } : null)),
    },
    tes_cuentas: {
      findFirst: jest.fn().mockImplementation(({ where }) => (where.empresa_id === 'emp' && String(where.id).startsWith('cta-') ? { id: where.id } : null)),
    },
    requisicion_cab: { findFirst: jest.fn().mockResolvedValue(null) },
    cont_documentos: { findFirst: jest.fn().mockResolvedValue(null) },
    tes_movimientos: { findFirst: jest.fn().mockResolvedValue(null) },
    // Medios que no mueven caja (medio-pago-sin-caja.util): acá ninguno.
    medio_pago: { findUnique: jest.fn().mockResolvedValue({ codigo: 1 }), findFirst: jest.fn().mockResolvedValue(null) },
    empresa_medio_pago: { findFirst: jest.fn().mockResolvedValue(null), findMany: jest.fn().mockResolvedValue([]) },
    $queryRaw: jest.fn().mockImplementation(async () => (orden.push('lock'), [])),
  };
  const leer = prisma.gasto_cab.findFirst;
  prisma.gasto_cab.findFirst = jest.fn().mockImplementation(async (...a: any[]) => (orden.push('leer'), leer(...a)));
  // Lo que decide la edición se lee dentro de la transacción, con la fila bloqueada (I5).
  for (const [k, m] of [
    ['cuentas_pagar', 'findMany'],
    ['pagos_proveedor', 'count'],
    ['config_compras', 'findUnique'],
  ] as const) {
    const f = prisma[k][m];
    prisma[k][m] = jest.fn().mockImplementation((...a: any[]) => {
      if (!dentro) fueraDeTx.push(`${k}.${m}`);
      return f(...a);
    });
  }
  prisma.$transaction = async (fn: any) => {
    dentro = true;
    try {
      return await fn(prisma);
    } finally {
      dentro = false;
    }
  };

  const contabilidad = {
    integrarGasto: jest.fn().mockResolvedValue(undefined),
    revertirDocumento: jest.fn().mockResolvedValue(undefined),
    cuentaPasivoParaCongelar: jest.fn().mockResolvedValue('pasivo-1'),
  };
  const tesoreria = {
    integrarGasto: jest.fn().mockResolvedValue({}),
    revertirGasto: jest.fn().mockResolvedValue(undefined),
    tieneMovimientoConciliado: jest.fn().mockResolvedValue(opts.conciliado ?? false),
    chequeNoRevertible: jest.fn().mockResolvedValue(null),
    actualizarReferencia: jest.fn().mockResolvedValue(undefined),
    // Devuelve la cuenta elegida (válida) o, sin ella, la de la regla.
    resolverCuentaPago: jest.fn().mockImplementation(async (_tx: unknown, _e: string, o: { cuentaTesoreriaId?: string | null }) => ({
      cuenta: { id: o.cuentaTesoreriaId || 'cta-1', nombre: 'Caja', moneda: 'PYG' },
    })),
  };
  const service = new GastosService(
    prisma,
    contabilidad as any,
    tesoreria as any,
    { recalcular: jest.fn().mockResolvedValue(undefined) } as any,
    { getCotizacionVigente: jest.fn().mockResolvedValue({ tasa: 7300 }) } as any,
  );
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'g1' } as any);
  const assertCuenta = jest.spyOn(service as any, 'assertCuentaAceptaMoneda');
  return { service, prisma, creados, contabilidad, tesoreria, assertCuenta, orden, fueraDeTx };
}

const crear = (cabecera: Record<string, unknown>) => ({
  cabecera: { proveedor_id: 'prov-1', fecha_emision: '2026-10-05', ...cabecera },
  items: [item()],
});

describe('GastosService.create — forma de pago y vencimiento', () => {
  it('TRANSFERENCIA se graba CONTADO', async () => {
    const { service, creados } = armar();
    await service.create(crear({ forma_pago: 'TRANSFERENCIA', medio_pago_id: 'mp-1' }) as any, 'emp', 'u1');
    expect(creados.gastos[0]).toMatchObject({ forma_pago: 'CONTADO', estado: 'pagada', pago_historico: false });
  });

  it('fecha_vencimiento: con CREDITO se graba en gasto_cab y en cuentas_pagar.fecha_vencimiento', async () => {
    const { service, creados } = armar();
    await service.create(crear({ forma_pago: 'CREDITO', fecha_vencimiento: '2026-11-05' }) as any, 'emp', 'u1');
    const venc = new Date('2026-11-05T00:00:00.000Z');
    expect(creados.gastos[0]).toMatchObject({ forma_pago: 'CREDITO', estado: 'registrado', fecha_vencimiento: venc });
    expect(creados.cxp[0].fecha_vencimiento).toEqual(venc);
  });

  it('fecha_vencimiento: con CREDITO sin ella, la CxP vence el día de emisión', async () => {
    const { service, creados } = armar();
    await service.create(crear({ forma_pago: 'CREDITO' }) as any, 'emp', 'u1');
    expect(creados.gastos[0].fecha_vencimiento).toBeNull();
    expect(creados.cxp[0].fecha_vencimiento).toEqual(EMISION);
  });

  it('vencimiento anterior a la emisión → 400', async () => {
    const { service, creados } = armar();
    const p = service.create(crear({ forma_pago: 'CREDITO', fecha_vencimiento: '2026-10-04' }) as any, 'emp', 'u1');
    await expect(p).rejects.toThrow(BadRequestException);
    await expect(p).rejects.toThrow('El vencimiento no puede ser anterior a la fecha del comprobante');
    expect(creados.gastos).toHaveLength(0);
  });

  it('con CONTADO el vencimiento se ignora', async () => {
    const { service, creados } = armar();
    await service.create(
      crear({ forma_pago: 'CONTADO', medio_pago_id: 'mp-1', fecha_vencimiento: '2026-10-01' }) as any,
      'emp',
      'u1',
    );
    expect(creados.gastos[0].fecha_vencimiento).toBeNull();
    expect(creados.cxp[0].fecha_vencimiento).toEqual(EMISION);
  });
});

describe('GastosService — pago histórico solo desde el importador (I2)', () => {
  const fila = (extra: Record<string, unknown> = {}, job: Record<string, unknown> = {}) => ({
    id: 'fila-1',
    empresa_id: 'emp',
    estado: 'valida',
    gasto_id: null,
    job: { id: 'job-1', empresa_id: 'emp', usuario_id: 'u-importa', estado: 'procesando', config_defaults: { pago: 'HISTORICO' }, ...job },
    ...extra,
  });
  const conFila = (f: any) => {
    const ctx = armar();
    // La fila se toma una sola vez: el primer updateMany condicional la consume.
    let tomada = false;
    ctx.prisma.gasto_importacion_filas = {
      findFirst: jest.fn().mockResolvedValue(f),
      updateMany: jest.fn().mockImplementation(async ({ where }: any) => {
        if (where.estado === 'valida' && where.gasto_id === null) {
          const count = tomada ? 0 : 1;
          tomada = true;
          return { count };
        }
        return { count: 1 };
      }),
    };
    return ctx;
  };

  // N2: la fila se consume en la misma transacción del alta.
  it('reintento con la misma fila: un solo gasto; el segundo da 400 sin crear nada', async () => {
    const { service, creados, prisma } = conFila(fila());
    await service.crearHistoricoImportado(crear({ forma_pago: 'CONTADO' }) as any, 'fila-1');
    await expect(service.crearHistoricoImportado(crear({ forma_pago: 'CONTADO' }) as any, 'fila-1')).rejects.toThrow(
      'La fila de importación ya generó un gasto',
    );
    expect(creados.gastos).toHaveLength(1);
    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenCalledWith({
      where: { id: 'fila-1', estado: 'valida', gasto_id: null },
      data: { estado: 'importada' },
    });
    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenCalledWith({ where: { id: 'fila-1' }, data: { gasto_id: 'g1' } });
  });

  it('create no tiene una bandera de histórico: no recibe opciones', () => {
    expect(GastosService.prototype.create.length).toBe(3);
  });

  it('con la fila del job que eligió "histórico": no exige medio, graba pago_historico y pagada, sin egreso; empresa y usuario del job', async () => {
    const { service, creados, tesoreria, assertCuenta, prisma } = conFila(fila());
    await service.crearHistoricoImportado(crear({ forma_pago: 'CONTADO' }) as any, 'fila-1');
    expect(prisma.gasto_importacion_filas.findFirst).toHaveBeenCalledWith(expect.objectContaining({ where: { id: 'fila-1' } }));
    expect(creados.gastos[0]).toMatchObject({
      empresa_id: 'emp',
      usuario_id: 'u-importa',
      pago_historico: true,
      estado: 'pagada',
      forma_pago: 'CONTADO',
      medio_pago_id: null,
    });
    expect(assertCuenta).not.toHaveBeenCalled();
    expect(tesoreria.integrarGasto).not.toHaveBeenCalled();
  });

  it.each([
    ['la fila no existe', null, 'La fila de importación no existe'],
    ['la fila ya generó un gasto', fila({ gasto_id: 'g-0' }), 'La fila de importación ya generó un gasto o no es válida'],
    ['la fila no es válida', fila({ estado: 'invalida' }), 'La fila de importación ya generó un gasto o no es válida'],
    ['el job no está procesando', fila({}, { estado: 'mapeado' }), 'La importación no está en proceso'],
    ['el job eligió pagar ahora', fila({}, { config_defaults: { pago: 'AHORA' } }), 'La importación no eligió registrar los pagos como históricos'],
    ['el job no eligió nada', fila({}, { config_defaults: null }), 'La importación no eligió registrar los pagos como históricos'],
    ['la fila es de otra empresa que el job', fila({ empresa_id: 'otra' }), 'La fila de importación no es de la empresa de la importación'],
  ])('%s → 400 y no crea nada', async (_caso, f, mensaje) => {
    const { service, creados } = conFila(f);
    await expect(service.crearHistoricoImportado(crear({ forma_pago: 'CONTADO' }) as any, 'fila-1')).rejects.toThrow(mensaje);
    expect(creados.gastos).toHaveLength(0);
  });

  // Ronda 1 de la Task 11: pagar ahora y crédito también toman la fila en la tx del alta.
  it('crearImportado (pagar ahora): toma la fila en la tx, graba gasto_id; un reintento da 400 sin otro gasto', async () => {
    const { service, creados, prisma, tesoreria } = conFila(fila({}, { config_defaults: { pago: 'AHORA' } }));
    await service.crearImportado(crear({ forma_pago: 'CONTADO', medio_pago_id: 'mp-1' }) as any, 'fila-1');
    await expect(service.crearImportado(crear({ forma_pago: 'CONTADO', medio_pago_id: 'mp-1' }) as any, 'fila-1')).rejects.toThrow(
      'La fila de importación ya generó un gasto',
    );
    expect(creados.gastos).toHaveLength(1);
    expect(creados.gastos[0]).toMatchObject({ empresa_id: 'emp', usuario_id: 'u-importa', pago_historico: false, medio_pago_id: 'mp-1' });
    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenCalledWith({ where: { id: 'fila-1' }, data: { gasto_id: 'g1' } });
    expect(tesoreria.integrarGasto).toHaveBeenCalled();
  });

  it('crearImportado con CREDITO en un job histórico: toma la fila y queda registrado', async () => {
    const { service, creados, prisma } = conFila(fila());
    await service.crearImportado(crear({ forma_pago: 'CREDITO' }) as any, 'fila-1');
    expect(creados.gastos[0]).toMatchObject({ forma_pago: 'CREDITO', estado: 'registrado', pago_historico: false });
    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenCalledWith({
      where: { id: 'fila-1', estado: 'valida', gasto_id: null },
      data: { estado: 'importada' },
    });
  });

  it('crearImportado sigue exigiendo el medio en contado (mismas validaciones del alta)', async () => {
    const { service, creados } = conFila(fila({}, { config_defaults: { pago: 'AHORA' } }));
    await expect(service.crearImportado(crear({ forma_pago: 'CONTADO' }) as any, 'fila-1')).rejects.toThrow(/Medio de pago requerido/);
    expect(creados.gastos).toHaveLength(0);
  });

  it('crearImportado de contado en un job que eligió histórico → 400', async () => {
    const { service, creados } = conFila(fila());
    await expect(service.crearImportado(crear({ forma_pago: 'CONTADO', medio_pago_id: 'mp-1' }) as any, 'fila-1')).rejects.toThrow(
      'La importación eligió registrar los pagos de contado como históricos',
    );
    expect(creados.gastos).toHaveLength(0);
  });

  it.each([
    ['la fila no existe', null, 'La fila de importación no existe'],
    ['la fila ya generó un gasto', fila({ gasto_id: 'g-0' }, { config_defaults: { pago: 'AHORA' } }), 'La fila de importación ya generó un gasto o no es válida'],
    ['el job no está procesando', fila({}, { estado: 'mapeado', config_defaults: { pago: 'AHORA' } }), 'La importación no está en proceso'],
    ['la fila es de otra empresa que el job', fila({ empresa_id: 'otra' }, { config_defaults: { pago: 'AHORA' } }), 'La fila de importación no es de la empresa de la importación'],
  ])('crearImportado: %s → 400 y no crea nada', async (_caso, f, mensaje) => {
    const { service, creados } = conFila(f);
    await expect(service.crearImportado(crear({ forma_pago: 'CREDITO' }) as any, 'fila-1')).rejects.toThrow(mensaje);
    expect(creados.gastos).toHaveLength(0);
  });

  it('sin la vía del importador, CONTADO sin medio sigue pidiendo el medio de pago', async () => {
    const { service } = armar();
    await expect(service.create(crear({ forma_pago: 'CONTADO' }) as any, 'emp', 'u1')).rejects.toThrow(
      /Medio de pago requerido/,
    );
  });
});

describe('GastosService.create — CxP sin cuenta pasivo (M4)', () => {
  it('si no se resuelve la cuenta pasivo, el gasto se guarda y el aviso llega en avisos.contabilidad', async () => {
    const { service, contabilidad } = armar();
    contabilidad.cuentaPasivoParaCongelar.mockRejectedValue(new Error('Falta mapear PROVEEDORES'));
    const r: any = await service.create(crear({ forma_pago: 'CREDITO' }) as any, 'emp', 'u1');
    expect(r.avisos.contabilidad).toContain('La cuenta por pagar quedó sin cuenta contable de pasivo');
    expect(r.avisos.contabilidad).toContain('Falta mapear PROVEEDORES');
  });
});

describe('GastosService.update — edición por valores', () => {
  const permitido = { permitir_editar_gasto_pagado: true };

  it('TRANSFERENCIA se graba CONTADO y no rehace nada', async () => {
    const { service, creados, tesoreria, contabilidad } = armar({
      config: permitido,
      existente: gastoExistente({ forma_pago: 'TRANSFERENCIA' }),
    });
    await service.update('g1', dtoPantalla({ forma_pago: 'TRANSFERENCIA' }) as any, 'emp', 'u1');
    expect(creados.gastoUpdates[0].forma_pago).toBe('CONTADO');
    expect(creados.cxpRearmadas).toHaveLength(0);
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
    expect(contabilidad.revertirDocumento).not.toHaveBeenCalled();
  });

  it('guardar sin cambios un gasto viejo con moneda NULL no es financiero', async () => {
    const { service, creados, tesoreria, prisma } = armar({
      config: permitido,
      existente: gastoExistente({ moneda_id: null }),
    });
    await service.update('g1', dtoPantalla() as any, 'emp', 'u1');
    expect(prisma.pagos_proveedor.count).not.toHaveBeenCalled();
    expect(creados.gastoUpdates[0].cotizacion).toBeUndefined();
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
    // Ítems iguales: gasto_det no se borra ni se recrea.
    expect(prisma.gasto_det.deleteMany).not.toHaveBeenCalled();
    expect(prisma.gasto_det.createMany).not.toHaveBeenCalled();
    expect(creados.gastoUpdates[0].total).toBeUndefined();
  });

  const credito = (extra: Record<string, unknown> = {}) =>
    gastoExistente({
      forma_pago: 'CREDITO',
      estado: 'registrado',
      medio_pago_id: null,
      cuenta_tesoreria_id: null,
      ...extra,
    });
  const dtoCredito = (extra: Record<string, unknown> = {}) =>
    dtoPantalla({ forma_pago: 'CREDITO', medio_pago_id: undefined, cuenta_tesoreria_id: undefined, ...extra }) as any;

  it('solo el vencimiento, CxP sin pagos: actualiza la CxP y no es financiera', async () => {
    const { service, creados, tesoreria, prisma } = armar({ existente: credito() });
    await service.update('g1', dtoCredito({ fecha_vencimiento: '2026-11-20' }), 'emp', 'u1');
    const venc = new Date('2026-11-20T00:00:00.000Z');
    expect(creados.gastoUpdates[0].fecha_vencimiento).toEqual(venc);
    expect(creados.cxpUpdateMany[0]).toMatchObject({
      where: { origen_tipo: 'gasto', origen_id: 'g1', activo: true },
      data: { fecha_vencimiento: venc },
    });
    expect(creados.cxpUpdateMany[0].data).not.toHaveProperty('fecha_emision');
    expect(creados.cxpRearmadas).toHaveLength(0);
    expect(prisma.gasto_det.deleteMany).not.toHaveBeenCalled();
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
  });

  it('solo el vencimiento, CxP con pagos (pagos: 1): 400 y no toca nada', async () => {
    const { service, creados } = armar({ existente: credito(), pagos: 1 });
    await expect(service.update('g1', dtoCredito({ fecha_vencimiento: '2026-11-20' }), 'emp', 'u1')).rejects.toThrow(
      'No se puede cambiar el vencimiento: la cuenta por pagar del gasto ya tiene pagos, órdenes de pago o recibos aplicados.',
    );
    expect(creados.cxpUpdateMany).toHaveLength(0);
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  it('solo la fecha de emisión: la CxP toma la emisión nueva (y el vencimiento que la sigue)', async () => {
    const { service, creados } = armar({ existente: credito() });
    await service.update('g1', dtoCredito({ fecha_emision: '2026-10-08' }), 'emp', 'u1');
    const emision = new Date('2026-10-08');
    expect(creados.cxpUpdateMany[0].data).toMatchObject({ fecha_emision: emision, fecha_vencimiento: emision });
    expect(creados.cxpRearmadas).toHaveLength(0);
  });

  it('solo la emisión con vencimiento propio y CxP con pagos: actualiza la emisión de la CxP', async () => {
    const existente = credito({ fecha_vencimiento: new Date('2026-11-20T00:00:00.000Z') });
    const { service, creados } = armar({ existente, pagos: 1 });
    await service.update(
      'g1',
      dtoCredito({ fecha_emision: '2026-10-08', fecha_vencimiento: '2026-11-20' }),
      'emp',
      'u1',
    );
    expect(creados.cxpUpdateMany[0].data).toMatchObject({ fecha_emision: new Date('2026-10-08') });
    expect(creados.cxpUpdateMany[0].data).not.toHaveProperty('fecha_vencimiento');
  });

  it('vencimiento anterior a la emisión al editar → 400', async () => {
    const existente = gastoExistente({ forma_pago: 'CREDITO', estado: 'registrado' });
    const { service } = armar({ existente });
    await expect(
      service.update('g1', dtoPantalla({ forma_pago: 'CREDITO', fecha_vencimiento: '2026-10-01' }) as any, 'emp', 'u1'),
    ).rejects.toThrow('El vencimiento no puede ser anterior a la fecha del comprobante');
  });

  it('cambiar el precio sí es financiero: pide sin pagos, rearma la CxP y rehace tesorería', async () => {
    const { service, creados, tesoreria, prisma } = armar({ config: permitido });
    await service.update('g1', dtoPantalla({}, [item({ precio_unitario: 120000 })]) as any, 'emp', 'u1');
    expect(prisma.pagos_proveedor.count).toHaveBeenCalled();
    expect(creados.cxpRearmadas[0]).toMatchObject({ monto_original: 120000, estado: 'pagada' });
    // I3: la reversa del egreso viejo va en la transacción de la edición; el alta, después.
    expect(tesoreria.revertirGasto).toHaveBeenCalledWith(prisma, 'g1', 'emp', 'Edición del gasto GASTO 05/10/2026 por Ana Pérez');
    expect(tesoreria.integrarGasto).toHaveBeenCalledWith('g1', 'GASTO 05/10/2026');
  });
});

describe('GastosService.update — gastos pagados según la empresa (S1)', () => {
  it.each(['pagada', 'parcial'])('editar %s con permitir_editar_gasto_pagado=false → 400', async (estado) => {
    const { service, creados } = armar({ existente: gastoExistente({ estado }) });
    await expect(service.update('g1', dtoPantalla() as any, 'emp', 'u1')).rejects.toThrow(
      'La empresa no permite editar gastos pagados (Compras › Configuración)',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  it('con true pasa', async () => {
    const { service, creados } = armar({ config: { permitir_editar_gasto_pagado: true } });
    await expect(service.update('g1', dtoPantalla({ descripcion: 'Nafta' }) as any, 'emp', 'u1')).resolves.toEqual({
      id: 'g1',
      avisos: {},
    });
    expect(creados.gastoUpdates[0].descripcion).toBe('Nafta');
  });

  it('un gasto registrado no mira la opción', async () => {
    const existente = gastoExistente({ forma_pago: 'CREDITO', estado: 'registrado' });
    const { service } = armar({ existente });
    await expect(service.update('g1', dtoPantalla({ forma_pago: 'CREDITO' }) as any, 'emp', 'u1')).resolves.toEqual({
      id: 'g1',
      avisos: {},
    });
  });
});

describe('GastosService.update — validar la cuenta solo si cambia el pago (N5)', () => {
  const permitido = { permitir_editar_gasto_pagado: true };

  it('pagado sin cambios del pago: no valida la cuenta', async () => {
    const { service, assertCuenta } = armar({ config: permitido });
    await service.update('g1', dtoPantalla({ descripcion: 'otra' }) as any, 'emp', 'u1');
    expect(assertCuenta).not.toHaveBeenCalled();
  });

  it('cambia la cuenta: valida', async () => {
    const { service, assertCuenta } = armar({ config: permitido });
    await service.update('g1', dtoPantalla({ cuenta_tesoreria_id: 'cta-2' }) as any, 'emp', 'u1');
    expect(assertCuenta).toHaveBeenCalledTimes(1);
  });

  it('el gasto pasa a pagada (crédito → contado): valida', async () => {
    const existente = gastoExistente({ forma_pago: 'CREDITO', estado: 'registrado' });
    const { service, assertCuenta } = armar({ existente });
    await service.update('g1', dtoPantalla() as any, 'emp', 'u1');
    expect(assertCuenta).toHaveBeenCalledTimes(1);
  });
});

describe('GastosService — gastos de viáticos se tocan desde la rendición', () => {
  const deRendicion = () =>
    gastoExistente({ rendicion_viatico_id: 'rv-1', forma_pago: 'ANTICIPO', medio_pago_id: null, proveedor_id: null });

  it('update → 400 y anular → 400', async () => {
    const { service, creados } = armar({ existente: deRendicion() });
    await expect(service.update('g1', dtoPantalla() as any, 'emp', 'u1')).rejects.toThrow(
      'Este gasto es de la rendición RV-000007 y se edita desde ahí.',
    );
    await expect(service.anular('g1', 'emp', 'u1', 'motivo')).rejects.toThrow(
      'Este gasto es de la rendición RV-000007 y se anula desde ahí.',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  it('anular con el rendicionId de su rendición pasa', async () => {
    const { service, creados } = armar({ existente: deRendicion() });
    await expect(service.anular('g1', 'emp', 'u1', 'Rendición RV-000007 anulada: viaje cancelado', { rendicionId: 'rv-1' })).resolves.toEqual({
      id: 'g1',
    });
    expect(creados.gastoUpdates.at(-1)).toMatchObject({ anulado: true, estado: 'anulado' });
  });

  it('con el id de otra rendición → 400', async () => {
    const { service, creados } = armar({ existente: deRendicion() });
    await expect(service.anular('g1', 'emp', 'u1', 'motivo', { rendicionId: 'rv-2' })).rejects.toThrow(
      'Este gasto es de la rendición RV-000007 y se anula desde ahí.',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  it('sin id (opciones vacías) → 400', async () => {
    const { service } = armar({ existente: deRendicion() });
    await expect(service.update('g1', dtoPantalla() as any, 'emp', 'u1')).rejects.toThrow('se edita desde ahí.');
    await expect(service.anular('g1', 'emp', 'u1', 'motivo', {})).rejects.toThrow('se anula desde ahí.');
  });

  it('un gasto sin rendición con rendicionId → 400 (no sirve de llave)', async () => {
    const { service, creados } = armar({ config: { permitir_editar_gasto_pagado: false } });
    await expect(service.anular('g1', 'emp', 'u1', 'motivo', { rendicionId: 'rv-1' })).rejects.toThrow(
      'El gasto no pertenece a esta rendición.',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  it('verificarAnulable aplica la misma llave sin escribir nada', async () => {
    const { service, creados } = armar({ existente: deRendicion() });
    await expect(service.verificarAnulable('g1', 'emp', { rendicionId: 'rv-2' })).rejects.toThrow('se anula desde ahí.');
    await expect(service.verificarAnulable('g1', 'emp', { rendicionId: 'rv-1' })).resolves.toBeUndefined();
    expect(creados.gastoUpdates).toHaveLength(0);
    expect(creados.cxpUpdateMany).toHaveLength(0);
  });
});

describe('GastosService.update — gasto histórico', () => {
  const historico = () => gastoExistente({ pago_historico: true, medio_pago_id: null, cuenta_tesoreria_id: null });

  it('conserva pago_historico (el DTO no lo acepta) y no revierte ni rehace el egreso', async () => {
    const { service, creados, tesoreria, assertCuenta } = armar({
      config: { permitir_editar_gasto_pagado: true },
      existente: historico(),
    });
    await service.update(
      'g1',
      dtoPantalla({ medio_pago_id: undefined, cuenta_tesoreria_id: undefined, pago_historico: false }, [
        item({ precio_unitario: 120000 }),
      ]) as any,
      'emp',
      'u1',
    );
    const patch = creados.gastoUpdates[0];
    expect(patch).not.toHaveProperty('pago_historico');
    expect(patch.estado).toBe('pagada');
    expect(assertCuenta).not.toHaveBeenCalled();
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
  });

  it('no puede pasar a crédito', async () => {
    const { service } = armar({ config: { permitir_editar_gasto_pagado: true }, existente: historico() });
    await expect(service.update('g1', dtoPantalla({ forma_pago: 'CREDITO' }) as any, 'emp', 'u1')).rejects.toThrow(
      /histórico/,
    );
  });
});

describe('GastosService.update — revisión de buenas prácticas', () => {
  const permitido = { permitir_editar_gasto_pagado: true };

  // I3
  it('update no tiene excepción para la rendición: no recibe opciones', () => {
    expect(GastosService.prototype.update.length).toBe(4);
  });

  // I4
  it('sin usuario → 400 claro y no escribe nada', async () => {
    const { service, creados } = armar({ config: permitido });
    await expect(service.update('g1', dtoPantalla({ descripcion: 'x' }) as any, 'emp', '')).rejects.toThrow(
      'Falta el usuario que edita el gasto',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  it('el asiento rehecho lo firma quien edita (revertir e integrar), no el autor ni la empresa', async () => {
    const { service, contabilidad } = armar({ config: permitido });
    await service.update('g1', dtoPantalla({ descripcion: 'Nafta' }) as any, 'emp', 'u-edita');
    expect(contabilidad.revertirDocumento).toHaveBeenCalledWith('gasto_cab', 'g1', 'u-edita', expect.anything());
    expect(contabilidad.integrarGasto).toHaveBeenCalledWith('g1', expect.objectContaining({ usuarioId: 'u-edita' }));
  });

  // I5
  it('bloquea la fila (FOR UPDATE) y lee el gasto y sus pagos dentro de la transacción', async () => {
    const { service, prisma, orden, fueraDeTx } = armar({ config: permitido });
    await service.update('g1', dtoPantalla({}, [item({ precio_unitario: 120000 })]) as any, 'emp', 'u1');
    expect(String(prisma.$queryRaw.mock.calls[0][0].join('?'))).toContain('FOR UPDATE');
    expect(orden[0]).toBe('lock');
    expect(orden.indexOf('lock')).toBeLessThan(orden.indexOf('leer'));
    expect(fueraDeTx).toEqual([]);
  });

  it('si otra pestaña lo anuló mientras tanto, la relectura con la fila bloqueada da 400 y no rearma la CxP', async () => {
    const { service, creados } = armar({ config: permitido, existente: gastoExistente({ anulado: true }) });
    await expect(service.update('g1', dtoPantalla({}, [item({ precio_unitario: 120000 })]) as any, 'emp', 'u1')).rejects.toThrow(
      'No se puede editar un gasto anulado',
    );
    expect(creados.cxpRearmadas).toHaveLength(0);
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  // I14
  it('sucursal de otra empresa → 404 y no escribe', async () => {
    const { service, creados } = armar({ config: permitido });
    await expect(service.update('g1', dtoPantalla({ sucursal_id: 'suc-ajena' }) as any, 'emp', 'u1')).rejects.toThrow(
      'La sucursal seleccionada no existe',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  it('cuenta de tesorería de otra empresa en un crédito (no pasa por assertCuentaAceptaMoneda) → 400', async () => {
    const existente = gastoExistente({ forma_pago: 'CREDITO', estado: 'registrado', medio_pago_id: null, cuenta_tesoreria_id: null });
    const { service, creados } = armar({ existente });
    await expect(
      service.update('g1', dtoPantalla({ forma_pago: 'CREDITO', medio_pago_id: undefined, cuenta_tesoreria_id: 'ajena' }) as any, 'emp', 'u1'),
    ).rejects.toThrow('La cuenta elegida en el gasto no está activa o no es de la empresa');
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  // M9
  it('con el egreso conciliado, cambiar solo la descripción pasa (no toca Tesorería)', async () => {
    const { service, creados, tesoreria } = armar({ config: permitido, conciliado: true });
    await service.update('g1', dtoPantalla({ descripcion: 'Nafta' }) as any, 'emp', 'u1');
    expect(creados.gastoUpdates[0].descripcion).toBe('Nafta');
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
  });

  it('con el egreso conciliado, cambiar el precio (rehace Tesorería) → 400', async () => {
    const { service, creados } = armar({ config: permitido, conciliado: true });
    await expect(service.update('g1', dtoPantalla({}, [item({ precio_unitario: 120000 })]) as any, 'emp', 'u1')).rejects.toThrow(
      'Deshacé la conciliación de ese movimiento antes de editar el gasto.',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
  });

  // M10
  it('la referencia se decide una vez: el asiento y Tesorería reciben la misma', async () => {
    const { service, contabilidad, tesoreria } = armar({ config: permitido });
    await service.update('g1', dtoPantalla({}, [item({ precio_unitario: 120000 })]) as any, 'emp', 'u1');
    const ref = contabilidad.integrarGasto.mock.calls[0][1].referencia;
    expect(ref).toBe('GASTO 05/10/2026');
    expect(tesoreria.integrarGasto.mock.calls[0][1]).toBe(ref);
    expect(tesoreria.revertirGasto.mock.calls[0][3]).toContain(ref);
  });

  it('si solo se rehace el asiento y cambia la referencia, el egreso vigente toma la misma referencia', async () => {
    const { service, contabilidad, tesoreria } = armar({ config: permitido });
    await service.update('g1', dtoPantalla({ descripcion: 'Nafta' }) as any, 'emp', 'u1');
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
    const ref = contabilidad.integrarGasto.mock.calls[0][1].referencia;
    expect(tesoreria.actualizarReferencia).toHaveBeenCalledWith('g1', 'emp', ref);
  });

  // N1: sin pasos que la usen, la referencia no se calcula (ni queda una promesa sin esperar).
  it('guardar sin cambios que rehagan algo no calcula la referencia', async () => {
    const { service } = armar({ config: permitido });
    const referencia = jest.spyOn(service as any, 'referenciaDelGasto');
    await service.update('g1', dtoPantalla() as any, 'emp', 'u1');
    expect(referencia).not.toHaveBeenCalled();
  });

  // M3: el mensaje nombra la rendición con su dato real; si no se encuentra, con su id (nunca un texto inventado).
  it('un gasto de una rendición que no se encuentra: el 400 nombra el id real de la rendición', async () => {
    const { service, prisma } = armar({ existente: gastoExistente({ rendicion_viatico_id: 'rv-perdida' }) });
    prisma.rendicion_viatico.findUnique.mockResolvedValue(null);
    await expect(service.update('g1', dtoPantalla() as any, 'emp', 'u1')).rejects.toThrow(
      'Este gasto es de la rendición rv-perdida y se edita desde ahí.',
    );
  });
});


describe('GastosService.update — reversas dentro de la edición (I2, I3)', () => {
  const permitido = { permitir_editar_gasto_pagado: true };
  const cambiaPrecio = () => dtoPantalla({}, [item({ precio_unitario: 120000 })]) as any;

  it('I2: pagado con un cheque ya DEPOSITADO, cambiar el precio → 400 con el texto de anular y no escribe nada', async () => {
    const { service, creados, tesoreria, contabilidad } = armar({ config: permitido });
    tesoreria.chequeNoRevertible.mockResolvedValue({ numero_cheque: '000123', estado: 'DEPOSITADO' });
    await expect(service.update('g1', cambiaPrecio(), 'emp', 'u1')).rejects.toThrow(
      'El gasto se pagó con el cheque 000123, que ya está DEPOSITADO. Revertí primero el cheque en Tesorería.',
    );
    expect(creados.gastoUpdates).toHaveLength(0);
    expect(creados.cxpRearmadas).toHaveLength(0);
    expect(contabilidad.revertirDocumento).not.toHaveBeenCalled();
    expect(tesoreria.integrarGasto).not.toHaveBeenCalled();
  });

  it('I2: con el cheque depositado, cambiar solo la descripción pasa (no rehace Tesorería)', async () => {
    const { service, creados, tesoreria } = armar({ config: permitido });
    tesoreria.chequeNoRevertible.mockResolvedValue({ numero_cheque: '000123', estado: 'DEPOSITADO' });
    await service.update('g1', dtoPantalla({ descripcion: 'Nafta' }) as any, 'emp', 'u1');
    expect(creados.gastoUpdates[0].descripcion).toBe('Nafta');
    expect(tesoreria.chequeNoRevertible).not.toHaveBeenCalled();
  });

  it('I3: período cerrado al revertir el asiento → la edición se aborta con el motivo y no se rehace nada', async () => {
    const { service, contabilidad, tesoreria } = armar({ config: permitido });
    contabilidad.revertirDocumento.mockRejectedValue(new BadRequestException('No se puede revertir: el período 09/2026 está cerrado'));
    await expect(service.update('g1', cambiaPrecio(), 'emp', 'u1')).rejects.toThrow('el período 09/2026 está cerrado');
    expect(contabilidad.integrarGasto).not.toHaveBeenCalled();
    expect(tesoreria.integrarGasto).not.toHaveBeenCalled();
  });

  it('I3: si la reversa del egreso falla, la edición se aborta (el egreso viejo no queda debajo del gasto nuevo)', async () => {
    const { service, contabilidad, tesoreria } = armar({ config: permitido });
    tesoreria.revertirGasto.mockRejectedValue(new Error('could not serialize access'));
    await expect(service.update('g1', cambiaPrecio(), 'emp', 'u1')).rejects.toThrow('could not serialize access');
    expect(contabilidad.integrarGasto).not.toHaveBeenCalled();
    expect(tesoreria.integrarGasto).not.toHaveBeenCalled();
  });

  it('I3: las dos reversas reciben la transacción de la edición; el alta del egreso que falla queda en el aviso', async () => {
    const { service, contabilidad, tesoreria } = armar({ config: permitido });
    tesoreria.integrarGasto.mockRejectedValue(new Error('choque'));
    const r: any = await service.update('g1', cambiaPrecio(), 'emp', 'u1');
    expect(contabilidad.revertirDocumento.mock.calls[0][3]).toBeDefined();
    expect(tesoreria.revertirGasto.mock.calls[0][0]).toBeDefined();
    expect(r.avisos.tesoreria).toContain('choque');
  });
});

describe('GastosService.update — «Según la regla» al editar (I4)', () => {
  it('cuenta_tesoreria_id null: desconecta la cuenta elegida y rehace el egreso (sale de la regla)', async () => {
    const { service, creados, tesoreria } = armar({ config: { permitir_editar_gasto_pagado: true } });
    await service.update('g1', dtoPantalla({ cuenta_tesoreria_id: null }) as any, 'emp', 'u1');
    expect(creados.gastoUpdates[0].cuenta_tesoreria).toEqual({ disconnect: true });
    expect(tesoreria.revertirGasto).toHaveBeenCalled();
    expect(tesoreria.integrarGasto).toHaveBeenCalledWith('g1', expect.any(String));
  });
});

describe('GastosService.update — gasto USD con requisición', () => {
  const existenteUsd = () =>
    gastoExistente({
      forma_pago: 'CREDITO',
      estado: 'registrado',
      medio_pago_id: null,
      cuenta_tesoreria_id: null,
      requisicion_id: 'req-1',
      moneda_id: 'mon-usd',
      cotizacion: '7000.000000',
      total: '110',
      gasto_det: [
        {
          requisicion_det_id: 'rd-1',
          producto_id: null,
          tipo_gasto_id: 'tg-1',
          descripcion: 'Combustible',
          cantidad: '1.0000',
          precio_unitario: '110.0000',
          porcentaje_iva: '10.00',
          subtotal: '100',
        },
      ],
    });
  const dtoUsd = (cotizacion: number, items = [item({ requisicion_det_id: 'rd-1', precio_unitario: 110 })]) =>
    dtoPantalla(
      { forma_pago: 'CREDITO', medio_pago_id: undefined, cuenta_tesoreria_id: undefined, moneda_id: 'mon-usd', cotizacion },
      items,
    ) as any;

  const espiar = () => ({
    aplicar: jest.spyOn(ejecucion, 'aplicarEjecucionRequisicion').mockResolvedValue(undefined),
    revertir: jest.spyOn(ejecucion, 'revertirEjecucionRequisicion').mockResolvedValue(undefined),
  });
  afterEach(() => jest.restoreAllMocks());

  it('editar solo la cotización revalúa con la vieja y la nueva (no revierte ni aplica)', async () => {
    const { service, prisma } = armar({ existente: existenteUsd() });
    prisma.$executeRaw = jest.fn().mockResolvedValue(1);
    const { aplicar, revertir } = espiar();
    const revaluar = jest.spyOn(ejecucion, 'revaluarEjecucionRequisicion').mockResolvedValue(undefined);

    await service.update('g1', dtoUsd(7300), 'emp', 'u1');

    expect(revaluar).toHaveBeenCalledWith(prisma, {
      empresaId: 'emp',
      requisicionId: 'req-1',
      items: [{ requisicion_det_id: 'rd-1', cantidad: 1, subtotal: 100 }],
      antes: { monedaCodigo: 'USD', cotizacion: 7000 },
      despues: { monedaCodigo: 'USD', cotizacion: 7300 },
      fechaOperacion: EMISION,
    });
    expect(revertir).not.toHaveBeenCalled();
    expect(aplicar).not.toHaveBeenCalled();
    // Ítems iguales: gasto_det no se recrea.
    expect(prisma.gasto_det.deleteMany).not.toHaveBeenCalled();
    // El req: de la edición se toma antes de revaluar.
    expect(prisma.$executeRaw.mock.calls.map((c: unknown[]) => c[1])).toEqual(['req:req-1']);
    expect(prisma.$executeRaw.mock.invocationCallOrder[0]).toBeLessThan(revaluar.mock.invocationCallOrder[0]);
  });

  it.each([
    ['cancelada', 'cancelada', false],
    ['aprobada (ejecutada parcial)', 'ejecutada_parcial', true],
  ])('editar la cotización de un gasto de una requisición %s pasa y ajusta el monto', async (_n, estado, recalculaCabecera) => {
    const { service, prisma } = armar({ existente: existenteUsd() });
    prisma.$executeRaw = jest.fn().mockResolvedValue(1);
    const linea = { id: 'rd-1', cantidad_solicitada: '5.0000', cantidad_ejecutada: '1.0000', monto_ejecutado: '700000.00', estado: 'ejecutada_parcial', centro_costo_id: null };
    prisma.requisicion_cab = {
      findFirst: jest.fn().mockResolvedValue({ id: 'req-1', empresa_id: 'emp', origen_tipo: 'gasto', estado, requisicion_det: [linea] }),
      update: jest.fn().mockResolvedValue({}),
    };
    prisma.requisicion_det = { update: jest.fn().mockResolvedValue({}) };

    await service.update('g1', dtoUsd(7300), 'emp', 'u1');

    // 100 USD: de 700.000 (a 7000) a 730.000 (a 7300); la cantidad y el estado de la línea no se tocan.
    expect(prisma.requisicion_det.update).toHaveBeenCalledTimes(1);
    expect(prisma.requisicion_det.update.mock.calls[0][0]).toMatchObject({ where: { id: 'rd-1' }, data: { monto_ejecutado: 730000 } });
    expect(Object.keys(prisma.requisicion_det.update.mock.calls[0][0].data).sort()).toEqual(['monto_ejecutado', 'updated_at']);
    // total_ejecutado acompaña siempre a las líneas; el estado de la cabecera solo cambia en aprobada / ejecutada.
    expect(prisma.requisicion_cab.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ total_ejecutado: 730000 }) }),
    );
    const data = prisma.requisicion_cab.update.mock.calls[0][0].data;
    if (!recalculaCabecera) expect(data).not.toHaveProperty('estado');
    else expect(data.estado).toBe('ejecutada_parcial');
  });

  it('cambiar ítems y cotización: revierte los ítems viejos a la vieja y aplica los nuevos a la nueva', async () => {
    const { service, prisma } = armar({ existente: existenteUsd() });
    prisma.$executeRaw = jest.fn().mockResolvedValue(1);
    jest.spyOn(service as any, 'assertRequisicionGastoValida').mockResolvedValue(undefined);
    const { aplicar, revertir } = espiar();

    await service.update('g1', dtoUsd(7300, [item({ requisicion_det_id: 'rd-1', cantidad: 2, precio_unitario: 110 })]), 'emp', 'u1');

    expect(revertir).toHaveBeenCalledWith(
      prisma,
      expect.objectContaining({ items: [{ requisicion_det_id: 'rd-1', cantidad: 1, subtotal: 100 }], monedaCodigo: 'USD', cotizacion: 7000 }),
    );
    expect(aplicar).toHaveBeenCalledWith(
      prisma,
      expect.objectContaining({
        items: [expect.objectContaining({ requisicion_det_id: 'rd-1', cantidad: 2 })],
        monedaCodigo: 'USD',
        cotizacion: 7300,
      }),
    );
  });

  it('sin cambios de ítems ni de cotización no toca la ejecución', async () => {
    const { service, prisma } = armar({ existente: existenteUsd() });
    prisma.$executeRaw = jest.fn().mockResolvedValue(1);
    const { aplicar, revertir } = espiar();
    const revaluar = jest.spyOn(ejecucion, 'revaluarEjecucionRequisicion').mockResolvedValue(undefined);

    await service.update('g1', dtoUsd(7000), 'emp', 'u1');

    expect(revertir).not.toHaveBeenCalled();
    expect(aplicar).not.toHaveBeenCalled();
    expect(revaluar).not.toHaveBeenCalled();
  });
});
