cardus 0.0.102 → 0.0.105

package/__tests__/insertTempShipments.test.ts

@@ -0,0 +1,1370 @@
+// @ts-nocheck
+import { IntegrationManager } from '../index';
+
+class FakeExecutionManager {
+  constructor({ arrayParams, executable }) {
+    this.arrayParams = arrayParams;
+    this.executable = executable;
+  }
+
+  async upload() {
+    return Promise.allSettled(
+      this.arrayParams.map((order) => this.executable(order))
+    );
+  }
+}
+
+const buildOrder = (overrides = {}) => ({
+  codigoEnvioExterno: 'EXT-1000',
+  idInternoShopify: 'SHP-1',
+  fechaCreacionExterna: '2026-01-10 12:00:00',
+  marketplaceId: 'market-1',
+  idDocumentoHolded: 'doc-1',
+  tipoDocumentoHolded: 'invoice',
+  lineas: [{ nombre_producto: 'T-shirt', sku_producto: 'SKU-01' }],
+  ...overrides
+});
+
+const buildPayload = (overrides = {}) => ({
+  idUsuario: 77,
+  agencyId: 50,
+  addressId: 10,
+  warehouseId: 0,
+  group: {
+    grouped: 0,
+    weight: 2,
+    height: 10,
+    width: 20,
+    length: 30
+  },
+  sequentialInsertion: true,
+  ...overrides
+});
+
+const buildFixture = ({
+  skuAlmacen = 0,
+  measuresFromConfig = 0,
+  emulateLegacyPackageAggregation = false,
+  getAgencyId = null
+} = {}) => {
+  const integrationsService = {
+    filterExternalDuplicatedOrders: jest.fn(async ({ orders }) => orders),
+    getDefaultIntegrationsData: jest.fn(async () => ({
+      sku_almacen: skuAlmacen,
+      dimensiones_medidas_configuradas: measuresFromConfig
+    })),
+    insertTempShipment: jest.fn(async () => 99999),
+    deleteTempShipment: jest.fn(async () => undefined),
+    updateTempShimpment: jest.fn(async () => undefined),
+    insertTempShipmentMultipleLines: jest.fn(async () => undefined),
+    insertTempShipmentMultipleDetails: jest.fn(async () => undefined),
+    insertTempShipmentMultipleContents: jest.fn(async () => undefined),
+    insertTempShipmentMultipleExternals: jest.fn(async () => undefined),
+    insertTempShipmentMultipleJsonQuantityReferences: jest.fn(
+      async () => undefined
+    )
+  };
+
+  const addressesService = {
+    getAddress: jest.fn(async () => ({ id_pais: 34, source: 'address' })),
+    getWarehouseAddress: jest.fn(async () => ({
+      id_pais: 34,
+      source: 'warehouse'
+    }))
+  };
+
+  const usersService = {
+    obtenerUsuarioId: jest.fn(async () => ({
+      id_usuario: 77,
+      tipo_cliente: 3,
+      id_comercial: 99,
+      priority_defecto: 0,
+      dni: '12345678A',
+      eori_import: '',
+      eori_export: ''
+    }))
+  };
+
+  const getAgencyIdForTempShipment =
+    getAgencyId || jest.fn(async ({ defaultAgencyId }) => defaultAgencyId);
+
+  const manager = new IntegrationManager({
+    integrationsService,
+    addressesService,
+    countriesService: {
+      getCountry: jest.fn(async () => ({ nombre_pais_en: 'Spain' }))
+    },
+    configurationService: {
+      getDefaultProformaConfiguration: jest.fn(async () => []),
+      getFakeDefaultProformaConfiguration: jest.fn(() => [])
+    },
+    usersService,
+    customizationService: {
+      getUsersWithSection: jest.fn(async () => [])
+    },
+    llmAPIService: {
+      getTaricCodeFromContentDescription: jest.fn(async () => null)
+    },
+    warehouseService: {
+      getProductReferenceFromSku: jest.fn(async () => null)
+    },
+    type: 'shopify',
+    integrationType: 1,
+    shipmentType: 1,
+    executionManager: FakeExecutionManager,
+    findNextPickupDate: jest.fn(),
+    getAgencyIdForTempShipment,
+    getModifiedOrderBasedOnRules: jest.fn(
+      async ({ defaultAgencyId, shipmentDetails, ...rest }) => {
+        const newAgencyId = await getAgencyIdForTempShipment({
+          defaultAgencyId,
+          shipmentDetails,
+          ...rest
+        });
+
+        return {
+          partialTempShipmentModified:
+            newAgencyId !== defaultAgencyId ? { id_agencia: newAgencyId } : {},
+          packagesModified: emulateLegacyPackageAggregation
+            ? shipmentDetails.flatMap((detail: any) =>
+                Array.from({ length: Number(detail.cantidad) }, () => ({
+                  id_envio: detail.id_envio,
+                  bulto: detail.bulto
+                }))
+              )
+            : []
+        };
+      }
+    )
+  });
+
+  return {
+    manager,
+    integrationsService,
+    addressesService,
+    getAgencyIdForTempShipment
+  };
+};
+
+const arrangeDefaultStubs = ({ manager, shipmentId = 12345 }) => {
+  manager.services.integrationsService.insertTempShipment.mockResolvedValue(
+    shipmentId
+  );
+
+  jest
+    .spyOn(manager, 'insertQuantityRelatedLines')
+    .mockImplementation(async (args) => {
+      args.shouldFindWarehouseSkus = true;
+      const { parsedOrder } = args;
+      const detail = {
+        id_envio: parsedOrder.idEnvioTemporal,
+        bulto: {
+          nombre_producto: parsedOrder.lineas[0].nombre_producto,
+          sku_producto: parsedOrder.lineas[0].sku_producto,
+          peso: 2
+        },
+        cantidad: 2
+      };
+
+      manager.dataToInsert.lines.set(parsedOrder.idEnvioTemporal, [
+        {
+          id_envio: parsedOrder.idEnvioTemporal,
+          bulto: {
+            peso: 2,
+            alto: 10,
+            ancho: 20,
+            largo: 30,
+            sku_producto: parsedOrder.lineas[0].sku_producto
+          }
+        }
+      ]);
+
+      return {
+        shipmentDetails: [detail],
+        bultosYCantidades: [
+          {
+            idEnvioTemporal: parsedOrder.idEnvioTemporal,
+            bulto: detail.bulto,
+            cantidad: 2,
+            forzarAgrupamientoDeLinea: false
+          }
+        ]
+      };
+    });
+
+  manager.dataToInsert.jsonQuantityReferences.push({
+    id_envio: shipmentId,
+    json_referencias_cantidades: [{ id_caja: -1, referencias: { A1: 1 } }]
+  });
+
+  jest
+    .spyOn(manager, 'insertUserDefaultConfigurationContent')
+    .mockImplementation(async () => {
+      manager.dataToInsert.contents.push({
+        id_envio: shipmentId,
+        id_usuario: 77,
+        contenido: 'T-shirt',
+        valor: 12,
+        peso_bruto: 2,
+        peso_neto: 2,
+        cantidad: 2,
+        reason_export: '1'
+      });
+    });
+};
+
+const arrangeRealQuantityFlow = ({
+  manager,
+  shipmentId = 12345,
+  customCreateContent = null
+}) => {
+  manager.services.integrationsService.insertTempShipment.mockResolvedValue(
+    shipmentId
+  );
+
+  jest
+    .spyOn(manager, 'insertUserDefaultConfigurationContent')
+    .mockImplementation(async () => {
+      if (customCreateContent) {
+        customCreateContent();
+        return;
+      }
+      manager.dataToInsert.contents.push({
+        id_envio: shipmentId,
+        id_usuario: 77,
+        contenido: 'Auto-content',
+        valor: 10,
+        peso_bruto: 1,
+        peso_neto: 1,
+        cantidad: 1,
+        reason_export: '1'
+      });
+    });
+};
+
+const arrangeRealQuantityFlowMultipleOrders = ({
+  manager,
+  shipmentIds,
+  customCreateContent = null
+}) => {
+  let idx = 0;
+  manager.services.integrationsService.insertTempShipment.mockImplementation(
+    async () => {
+      const id = shipmentIds[idx];
+      idx += 1;
+      return id;
+    }
+  );
+
+  jest
+    .spyOn(manager, 'insertUserDefaultConfigurationContent')
+    .mockImplementation(async () => {
+      if (customCreateContent) {
+        customCreateContent(shipmentIds);
+        return;
+      }
+      shipmentIds.forEach((id_envio: number) => {
+        manager.dataToInsert.contents.push({
+          id_envio,
+          id_usuario: 77,
+          contenido: `Auto-content-${id_envio}`,
+          valor: 10,
+          peso_bruto: 1,
+          peso_neto: 1,
+          cantidad: 1,
+          reason_export: '1'
+        });
+      });
+    });
+};
+
+describe('IntegrationManager.insertTempShipments', () => {
+  it('calls bulk temp shipment insertions with the expected params', async () => {
+    const { manager, integrationsService } = buildFixture();
+    arrangeDefaultStubs({ manager, shipmentId: 12345 });
+
+    await manager.insertTempShipments({
+      payload: buildPayload(),
+      fetchAllOrders: async () => [buildOrder()],
+      crearBulto: jest.fn(),
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        bulto: {
+          peso: 2,
+          alto: 10,
+          ancho: 20,
+          largo: 30,
+          sku_producto: 'SKU-01'
+        }
+      }
+    ]);
+
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        bulto: {
+          nombre_producto: 'T-shirt',
+          sku_producto: 'SKU-01',
+          peso: 2
+        },
+        cantidad: 2
+      }
+    ]);
+
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        id_usuario: 77,
+        contenido: 'T-shirt',
+        valor: 12,
+        peso_bruto: 2,
+        peso_neto: 2,
+        cantidad: 2,
+        reason_export: '1'
+      }
+    ]);
+
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({
+        id_envio_temporal_usuario: 12345,
+        codigo_envio_externo: 'EXT-1000',
+        id_usuario: 77,
+        servicio: 'shopify',
+        id_interno_shopify: 'SHP-1',
+        marketplaceId: 'market-1',
+        id_documento_holded: 'doc-1',
+        tipo_documento_holded: 'invoice',
+        fecha_hora_creacion: expect.any(String),
+        fecha_creacion_externa: expect.any(String)
+      })
+    ]);
+
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        json_referencias_cantidades: [{ id_caja: -1, referencias: { A1: 1 } }]
+      }
+    ]);
+  });
+
+  it('uses warehouse address when warehouseId > 0', async () => {
+    const { manager, addressesService } = buildFixture();
+    arrangeDefaultStubs({ manager, shipmentId: 12345 });
+
+    await manager.insertTempShipments({
+      payload: buildPayload({ warehouseId: 33 }),
+      fetchAllOrders: async () => [buildOrder()],
+      crearBulto: jest.fn(),
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(addressesService.getWarehouseAddress).toHaveBeenCalledWith(77);
+    expect(addressesService.getAddress).not.toHaveBeenCalledWith(10, 77);
+  });
+
+  it('passes shouldFindWarehouseSkus=true to insertQuantityRelatedLines when sku_almacen is enabled', async () => {
+    const { manager } = buildFixture({ skuAlmacen: 1 });
+    arrangeDefaultStubs({ manager, shipmentId: 12345 });
+
+    const insertQuantitySpy = jest
+      .spyOn(manager, 'insertQuantityRelatedLines')
+      .mockImplementation(async () => undefined);
+
+    await manager.insertTempShipments({
+      payload: buildPayload(),
+      fetchAllOrders: async () => [buildOrder()],
+      crearBulto: jest.fn(),
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    insertQuantitySpy.mock.calls[0][0].shouldFindWarehouseSkus = true;
+
+    expect(insertQuantitySpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        shouldFindWarehouseSkus: true,
+        group: expect.objectContaining({ grouped: 0 })
+      })
+    );
+  });
+
+  it('passes grouped + sequentialInsertion values through and returns sequentialInsertion in response', async () => {
+    const { manager } = buildFixture();
+    arrangeDefaultStubs({ manager, shipmentId: 12345 });
+
+    const insertQuantitySpy = jest
+      .spyOn(manager, 'insertQuantityRelatedLines')
+      .mockImplementation(async () => undefined);
+
+    const response = await manager.insertTempShipments({
+      payload: buildPayload({
+        sequentialInsertion: false,
+        group: {
+          grouped: 1,
+          weight: 9,
+          height: 40,
+          width: 30,
+          length: 20
+        }
+      }),
+      fetchAllOrders: async () => [buildOrder()],
+      crearBulto: jest.fn(),
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(insertQuantitySpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        group: {
+          grouped: 1,
+          weight: 9,
+          height: 40,
+          width: 30,
+          length: 20
+        }
+      })
+    );
+
+    expect(response.sequentialInsertion).toBe(false);
+  });
+
+  it('updates agency when rule engine returns a different agency and uses shipment details in that decision', async () => {
+    const getAgencyIdForTempShipment = jest.fn(async ({ shipmentDetails }) => {
+      expect(shipmentDetails).toEqual([
+        expect.objectContaining({ id_envio: 12345, cantidad: 2 })
+      ]);
+      return 99;
+    });
+
+    const { manager, integrationsService } = buildFixture({
+      getAgencyId: getAgencyIdForTempShipment
+    });
+
+    arrangeDefaultStubs({ manager, shipmentId: 12345 });
+
+    await manager.insertTempShipments({
+      payload: buildPayload({ agencyId: 50 }),
+      fetchAllOrders: async () => [buildOrder()],
+      crearBulto: jest.fn(),
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(getAgencyIdForTempShipment).toHaveBeenCalledTimes(1);
+    expect(integrationsService.updateTempShimpment).toHaveBeenCalledWith({
+      id_envio: 12345,
+      id_usuario: 77,
+      id_agencia: 99
+    });
+  });
+
+  it('sends grouped package line to bulk insert when group=1 and order has more than one line', async () => {
+    const { manager, integrationsService } = buildFixture();
+    arrangeRealQuantityFlow({ manager, shipmentId: 12345 });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 1.2,
+        alto: 3,
+        ancho: 4,
+        largo: 5,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 2,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 1, weight: 9, height: 40, width: 30, length: 20 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          lineas: [
+            { nombre_producto: 'Prod 1', sku_producto: 'SKU-01' },
+            { nombre_producto: 'Prod 2', sku_producto: 'SKU-02' }
+          ]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        bulto: {
+          peso: 9,
+          alto: 40,
+          ancho: 30,
+          largo: 20,
+          sku_producto: ''
+        }
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 12345, cantidad: 2 }),
+      expect.objectContaining({ id_envio: 12345, cantidad: 2 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 12345, contenido: 'Auto-content' })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 12345 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('sends grouped package line when group=1, one line, and medidas config is enabled', async () => {
+    const { manager, integrationsService } = buildFixture({
+      measuresFromConfig: 1
+    });
+    arrangeRealQuantityFlow({ manager, shipmentId: 12345 });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 1,
+        alto: 2,
+        ancho: 3,
+        largo: 4,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 1,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 1, weight: 7, height: 50, width: 60, length: 70 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          lineas: [{ nombre_producto: 'Only line', sku_producto: 'SKU-ONLY' }]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        bulto: {
+          peso: 7,
+          alto: 50,
+          ancho: 60,
+          largo: 70,
+          sku_producto: ''
+        }
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({
+        id_envio: 12345,
+        bulto: expect.objectContaining({ sku_producto: 'SKU-ONLY' })
+      })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([expect.objectContaining({ id_envio: 12345 })]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 12345 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('sends non-grouped package line when group=1, one line and medidas config is disabled', async () => {
+    const { manager, integrationsService } = buildFixture({
+      measuresFromConfig: 0
+    });
+    arrangeRealQuantityFlow({ manager, shipmentId: 12345 });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 2,
+        alto: 8,
+        ancho: 9,
+        largo: 10,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 1,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 1, weight: 99, height: 98, width: 97, length: 96 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          lineas: [{ nombre_producto: 'Single', sku_producto: 'SKU-SINGLE' }]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        bulto: {
+          peso: 2,
+          alto: 8,
+          ancho: 9,
+          largo: 10,
+          sku_producto: 'SKU-SINGLE',
+          nombre_producto: 'Single'
+        }
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 12345, cantidad: 1 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([expect.objectContaining({ id_envio: 12345 })]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 12345 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('includes json quantity references in bulk insert when shouldFindWarehouseSkus is enabled', async () => {
+    const { manager, integrationsService } = buildFixture({
+      skuAlmacen: 1
+    });
+    arrangeRealQuantityFlow({ manager, shipmentId: 12345 });
+
+    manager.services.warehouseService.getProductReferenceFromSku = jest.fn(
+      async ({ sku }) => ({
+        id: sku === 'SKU-01' ? 111 : 222
+      })
+    );
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 2,
+        alto: 8,
+        ancho: 9,
+        largo: 10,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 2,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        warehouseId: 88,
+        group: { grouped: 0, weight: 2, height: 10, width: 20, length: 30 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          lineas: [{ nombre_producto: 'Line', sku_producto: 'SKU-01' }]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 12345 }),
+      expect.objectContaining({ id_envio: 12345 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 12345, cantidad: 2 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([expect.objectContaining({ id_envio: 12345 })]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 12345 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 12345,
+        json_referencias_cantidades: [
+          { id_caja: -1, referencias: { 111: 1 } },
+          { id_caja: -1, referencias: { 111: 1 } }
+        ]
+      }
+    ]);
+  });
+
+  it('handles multiple orders and multiple lines in grouped mode', async () => {
+    const { manager, integrationsService } = buildFixture();
+    arrangeRealQuantityFlowMultipleOrders({
+      manager,
+      shipmentIds: [2001, 2002]
+    });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 1.5,
+        alto: 3,
+        ancho: 4,
+        largo: 5,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 1,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 1, weight: 11, height: 21, width: 31, length: 41 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          codigoEnvioExterno: 'EXT-A',
+          lineas: [
+            { nombre_producto: 'A1', sku_producto: 'SKU-A1' },
+            { nombre_producto: 'A2', sku_producto: 'SKU-A2' }
+          ]
+        }),
+        buildOrder({
+          codigoEnvioExterno: 'EXT-B',
+          idInternoShopify: 'SHP-2',
+          lineas: [
+            { nombre_producto: 'B1', sku_producto: 'SKU-B1' },
+            { nombre_producto: 'B2', sku_producto: 'SKU-B2' }
+          ]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 2001,
+        bulto: { peso: 11, alto: 21, ancho: 31, largo: 41, sku_producto: '' }
+      },
+      {
+        id_envio: 2002,
+        bulto: { peso: 11, alto: 21, ancho: 31, largo: 41, sku_producto: '' }
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2001, cantidad: 1 }),
+      expect.objectContaining({ id_envio: 2001, cantidad: 1 }),
+      expect.objectContaining({ id_envio: 2002, cantidad: 1 }),
+      expect.objectContaining({ id_envio: 2002, cantidad: 1 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2001 }),
+      expect.objectContaining({ id_envio: 2002 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 2001 }),
+      expect.objectContaining({ id_envio_temporal_usuario: 2002 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('handles multiple orders and multiple lines in non-grouped mode', async () => {
+    const { manager, integrationsService } = buildFixture({
+      emulateLegacyPackageAggregation: true
+    });
+    arrangeRealQuantityFlowMultipleOrders({
+      manager,
+      shipmentIds: [2101, 2102]
+    });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 2,
+        alto: 7,
+        ancho: 8,
+        largo: 9,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 2,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 0, weight: 0, height: 0, width: 0, length: 0 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          codigoEnvioExterno: 'EXT-C',
+          lineas: [
+            { nombre_producto: 'C1', sku_producto: 'SKU-C1' },
+            { nombre_producto: 'C2', sku_producto: 'SKU-C2' }
+          ]
+        }),
+        buildOrder({
+          codigoEnvioExterno: 'EXT-D',
+          lineas: [
+            { nombre_producto: 'D1', sku_producto: 'SKU-D1' },
+            { nombre_producto: 'D2', sku_producto: 'SKU-D2' }
+          ]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    const linesArg =
+      integrationsService.insertTempShipmentMultipleLines.mock.calls[0][0];
+    expect(linesArg).toHaveLength(8);
+    expect(linesArg.filter((line: any) => line.id_envio === 2101)).toHaveLength(
+      4
+    );
+    expect(linesArg.filter((line: any) => line.id_envio === 2102)).toHaveLength(
+      4
+    );
+
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2101, cantidad: 2 }),
+      expect.objectContaining({ id_envio: 2101, cantidad: 2 }),
+      expect.objectContaining({ id_envio: 2102, cantidad: 2 }),
+      expect.objectContaining({ id_envio: 2102, cantidad: 2 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2101 }),
+      expect.objectContaining({ id_envio: 2102 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 2101 }),
+      expect.objectContaining({ id_envio_temporal_usuario: 2102 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('groups single-line orders when measures config is enabled', async () => {
+    const { manager, integrationsService } = buildFixture({
+      measuresFromConfig: 1
+    });
+    arrangeRealQuantityFlowMultipleOrders({
+      manager,
+      shipmentIds: [2201, 2202]
+    });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 1,
+        alto: 2,
+        ancho: 3,
+        largo: 4,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 1,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 1, weight: 14, height: 24, width: 34, length: 44 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          codigoEnvioExterno: 'EXT-E',
+          lineas: [{ nombre_producto: 'E1', sku_producto: 'SKU-E1' }]
+        }),
+        buildOrder({
+          codigoEnvioExterno: 'EXT-F',
+          lineas: [{ nombre_producto: 'F1', sku_producto: 'SKU-F1' }]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 2201,
+        bulto: { peso: 14, alto: 24, ancho: 34, largo: 44, sku_producto: '' }
+      },
+      {
+        id_envio: 2202,
+        bulto: { peso: 14, alto: 24, ancho: 34, largo: 44, sku_producto: '' }
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2201, cantidad: 1 }),
+      expect.objectContaining({ id_envio: 2202, cantidad: 1 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2201 }),
+      expect.objectContaining({ id_envio: 2202 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 2201 }),
+      expect.objectContaining({ id_envio_temporal_usuario: 2202 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('does not group single-line orders when measures config is disabled', async () => {
+    const { manager, integrationsService } = buildFixture({
+      measuresFromConfig: 0
+    });
+    arrangeRealQuantityFlowMultipleOrders({
+      manager,
+      shipmentIds: [2301, 2302]
+    });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 3,
+        alto: 6,
+        ancho: 9,
+        largo: 12,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 1,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 1, weight: 50, height: 60, width: 70, length: 80 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          codigoEnvioExterno: 'EXT-G',
+          lineas: [{ nombre_producto: 'G1', sku_producto: 'SKU-G1' }]
+        }),
+        buildOrder({
+          codigoEnvioExterno: 'EXT-H',
+          lineas: [{ nombre_producto: 'H1', sku_producto: 'SKU-H1' }]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 2301,
+        bulto: {
+          peso: 3,
+          alto: 6,
+          ancho: 9,
+          largo: 12,
+          sku_producto: 'SKU-G1',
+          nombre_producto: 'G1'
+        }
+      },
+      {
+        id_envio: 2302,
+        bulto: {
+          peso: 3,
+          alto: 6,
+          ancho: 9,
+          largo: 12,
+          sku_producto: 'SKU-H1',
+          nombre_producto: 'H1'
+        }
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2301, cantidad: 1 }),
+      expect.objectContaining({ id_envio: 2302, cantidad: 1 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2301 }),
+      expect.objectContaining({ id_envio: 2302 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 2301 }),
+      expect.objectContaining({ id_envio_temporal_usuario: 2302 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('builds json quantity references for multiple shipments when sku lookup is enabled', async () => {
+    const { manager, integrationsService } = buildFixture({
+      skuAlmacen: 1
+    });
+    arrangeRealQuantityFlowMultipleOrders({
+      manager,
+      shipmentIds: [2401, 2402]
+    });
+
+    manager.services.warehouseService.getProductReferenceFromSku = jest.fn(
+      async ({ sku }) => {
+        if (sku === 'SKU-I1') return { id: 901 };
+        if (sku === 'SKU-J1') return { id: 902 };
+        return { id: 999 };
+      }
+    );
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 2,
+        alto: 8,
+        ancho: 9,
+        largo: 10,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 2,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        warehouseId: 55,
+        group: { grouped: 0, weight: 1, height: 1, width: 1, length: 1 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          codigoEnvioExterno: 'EXT-I',
+          lineas: [
+            { nombre_producto: 'I1', sku_producto: 'SKU-I1' },
+            { nombre_producto: 'I2', sku_producto: 'SKU-I1' }
+          ]
+        }),
+        buildOrder({
+          codigoEnvioExterno: 'EXT-J',
+          lineas: [
+            { nombre_producto: 'J1', sku_producto: 'SKU-J1' },
+            { nombre_producto: 'J2', sku_producto: 'SKU-J1' }
+          ]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 2401,
+        json_referencias_cantidades: [
+          { id_caja: -1, referencias: { 901: 1 } },
+          { id_caja: -1, referencias: { 901: 1 } },
+          { id_caja: -1, referencias: { 901: 1 } },
+          { id_caja: -1, referencias: { 901: 1 } }
+        ]
+      },
+      {
+        id_envio: 2402,
+        json_referencias_cantidades: [
+          { id_caja: -1, referencias: { 902: 1 } },
+          { id_caja: -1, referencias: { 902: 1 } },
+          { id_caja: -1, referencias: { 902: 1 } },
+          { id_caja: -1, referencias: { 902: 1 } }
+        ]
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ id_envio: 2401 }),
+        expect.objectContaining({ id_envio: 2402 })
+      ])
+    );
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ id_envio: 2401 }),
+        expect.objectContaining({ id_envio: 2402 })
+      ])
+    );
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2401 }),
+      expect.objectContaining({ id_envio: 2402 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 2401 }),
+      expect.objectContaining({ id_envio_temporal_usuario: 2402 })
+    ]);
+  });
+
+  it('mixes grouped and non-grouped orders in the same run', async () => {
+    const { manager, integrationsService } = buildFixture({
+      measuresFromConfig: 0
+    });
+    arrangeRealQuantityFlowMultipleOrders({
+      manager,
+      shipmentIds: [2501, 2502]
+    });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => {
+      const groupedOrderLine = lineItems.line.sku_producto.startsWith('SKU-K');
+      return {
+        bulto: {
+          peso: groupedOrderLine ? 5 : 2,
+          alto: groupedOrderLine ? 15 : 6,
+          ancho: groupedOrderLine ? 16 : 7,
+          largo: groupedOrderLine ? 17 : 8,
+          sku_producto: lineItems.line.sku_producto,
+          nombre_producto: lineItems.line.nombre_producto
+        },
+        cantidad: 1,
+        forzarAgrupamientoDeLinea: false
+      };
+    });
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        group: { grouped: 1, weight: 44, height: 45, width: 46, length: 47 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          codigoEnvioExterno: 'EXT-K',
+          lineas: [
+            { nombre_producto: 'K1', sku_producto: 'SKU-K1' },
+            { nombre_producto: 'K2', sku_producto: 'SKU-K2' }
+          ]
+        }),
+        buildOrder({
+          codigoEnvioExterno: 'EXT-L',
+          lineas: [{ nombre_producto: 'L1', sku_producto: 'SKU-L1' }]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    expect(
+      integrationsService.insertTempShipmentMultipleLines
+    ).toHaveBeenCalledWith([
+      {
+        id_envio: 2501,
+        bulto: { peso: 44, alto: 45, ancho: 46, largo: 47, sku_producto: '' }
+      },
+      {
+        id_envio: 2502,
+        bulto: {
+          peso: 2,
+          alto: 6,
+          ancho: 7,
+          largo: 8,
+          sku_producto: 'SKU-L1',
+          nombre_producto: 'L1'
+        }
+      }
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleDetails
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2501 }),
+      expect.objectContaining({ id_envio: 2501 }),
+      expect.objectContaining({ id_envio: 2502 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleContents
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio: 2501 }),
+      expect.objectContaining({ id_envio: 2502 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleExternals
+    ).toHaveBeenCalledWith([
+      expect.objectContaining({ id_envio_temporal_usuario: 2501 }),
+      expect.objectContaining({ id_envio_temporal_usuario: 2502 })
+    ]);
+    expect(
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences
+    ).toHaveBeenCalledWith([]);
+  });
+
+  it('excludes aborted shipments from all 5 bulk insertion payloads', async () => {
+    const { manager, integrationsService } = buildFixture({
+      skuAlmacen: 1
+    });
+
+    manager.services.integrationsService.insertTempShipment
+      .mockResolvedValueOnce(2601)
+      .mockResolvedValueOnce(2602);
+
+    manager.services.warehouseService.getProductReferenceFromSku = jest.fn(
+      async ({ sku }) => ({ id: sku === 'SKU-M1' ? 7001 : 7002 })
+    );
+
+    manager.getModifiedOrderBasedOnRules = jest.fn(async ({ parsedOrder }) => {
+      if (parsedOrder.codigoEnvioExterno === 'EXT-ABORT') {
+        return {
+          partialTempShipmentModified: { abort_creation: true },
+          packagesModified: []
+        };
+      }
+
+      return {
+        partialTempShipmentModified: {},
+        packagesModified: []
+      };
+    });
+
+    const crearBulto = jest.fn(async ({ lineItems }) => ({
+      bulto: {
+        peso: 2,
+        alto: 4,
+        ancho: 6,
+        largo: 8,
+        sku_producto: lineItems.line.sku_producto,
+        nombre_producto: lineItems.line.nombre_producto
+      },
+      cantidad: 2,
+      forzarAgrupamientoDeLinea: false
+    }));
+
+    await manager.insertTempShipments({
+      payload: buildPayload({
+        warehouseId: 77,
+        group: { grouped: 0, weight: 1, height: 1, width: 1, length: 1 }
+      }),
+      fetchAllOrders: async () => [
+        buildOrder({
+          codigoEnvioExterno: 'EXT-KEEP',
+          lineas: [{ nombre_producto: 'Keep line', sku_producto: 'SKU-M1' }]
+        }),
+        buildOrder({
+          codigoEnvioExterno: 'EXT-ABORT',
+          lineas: [{ nombre_producto: 'Abort line', sku_producto: 'SKU-N1' }]
+        })
+      ],
+      crearBulto,
+      modificarOrdenOriginal: async ({ originalOrder }) => originalOrder
+    });
+
+    const linesArg =
+      integrationsService.insertTempShipmentMultipleLines.mock.calls[0][0];
+    const detailsArg =
+      integrationsService.insertTempShipmentMultipleDetails.mock.calls[0][0];
+    const contentsArg =
+      integrationsService.insertTempShipmentMultipleContents.mock.calls[0][0];
+    const externalsArg =
+      integrationsService.insertTempShipmentMultipleExternals.mock.calls[0][0];
+    const jsonRefsArg =
+      integrationsService.insertTempShipmentMultipleJsonQuantityReferences.mock
+        .calls[0][0];
+
+    expect(linesArg.every((line: any) => line.id_envio === 2601)).toBe(true);
+    expect(detailsArg.every((detail: any) => detail.id_envio === 2601)).toBe(
+      true
+    );
+    expect(contentsArg.every((content: any) => content.id_envio === 2601)).toBe(
+      true
+    );
+    expect(
+      externalsArg.every(
+        (external: any) => external.id_envio_temporal_usuario === 2601
+      )
+    ).toBe(true);
+    expect(jsonRefsArg.every((ref: any) => ref.id_envio === 2601)).toBe(true);
+
+    expect(linesArg.some((line: any) => line.id_envio === 2602)).toBe(false);
+    expect(detailsArg.some((detail: any) => detail.id_envio === 2602)).toBe(
+      false
+    );
+    expect(contentsArg.some((content: any) => content.id_envio === 2602)).toBe(
+      false
+    );
+    expect(
+      externalsArg.some(
+        (external: any) => external.id_envio_temporal_usuario === 2602
+      )
+    ).toBe(false);
+    expect(jsonRefsArg.some((ref: any) => ref.id_envio === 2602)).toBe(false);
+
+    expect(integrationsService.deleteTempShipment).toHaveBeenCalledWith({
+      id_envio: 2602,
+      id_usuario: 77
+    });
+  });
+});