tilbudgivern/backend/__tests__/smartPackageChildVersioning.test.js

const Service = require('../src/services/smartPackageManagementService');

jest.mock('../src/utils/logger', () => ({ info: jest.fn(), error: jest.fn() }));

const PACKAGE_ID = 7;
const VERSION = 3;

function fixture({ stale = false, failOn = null } = {}) {
  const calls = [];
  const connection = {
    beginTransaction: jest.fn(),
    commit: jest.fn(),
    rollback: jest.fn(),
    release: jest.fn(),
    execute: jest.fn(async (sql, params = []) => {
      calls.push({ sql, params });
      if (failOn && sql.includes(failOn)) throw new Error('child write failed');
      if (sql.includes('FROM smart_package_steps') && sql.includes('JOIN smart_package_tasks')) {
        return [[{ step_id: 31, task_id: 21, package_id: PACKAGE_ID, version: stale ? VERSION + 1 : VERSION }]];
      }
      if (sql.includes('FROM smart_package_tasks') && sql.includes('JOIN material_packages')) {
        return [[{
          task_id: 21,
          package_id: PACKAGE_ID,
          hours: 2,
          version: stale ? VERSION + 1 : VERSION
        }]];
      }
      if (sql.includes('FROM material_packages') && sql.includes('FOR UPDATE')) {
        return [[{ id: PACKAGE_ID, version: stale ? VERSION + 1 : VERSION, is_active: 1 }]];
      }
      if (sql.includes('MAX(task_order)')) return [[{ next_order: 4 }]];
      if (sql.includes('MAX(step_order)')) return [[{ next_order: 5 }]];
      if (sql.includes('INSERT INTO smart_package_tasks')) return [{ insertId: 21, affectedRows: 1 }];
      if (sql.includes('INSERT INTO smart_package_steps')) return [{ insertId: 31, affectedRows: 1 }];
      return [{ affectedRows: 1 }];
    })
  };
  const service = new Service({ pool: { getConnection: async () => connection } });
  service.readManagementResult = jest.fn(async () => ({ id: PACKAGE_ID, version: VERSION + 1, name: 'Current' }));
  return { service, connection, calls };
}

const cases = [
  ['add task', (service) => service.addTaskToPackage(PACKAGE_ID, { name: 'Task', hours: 1 }, VERSION)],
  ['update task', (service) => service.updateTask(21, { name: 'Renamed', hours: 2, rate: 725, timeUnit: 'per_meter', timePerUnit: 0.25 }, VERSION)],
  ['delete task', (service) => service.deleteTask(21, VERSION)],
  ['reorder tasks', (service) => service.reorderTasks(PACKAGE_ID, [{ taskId: 21, order: 1 }], VERSION)],
  ['add custom task', (service) => service.createCustomTask({ packageId: PACKAGE_ID, name: 'Custom', timeUnit: 'per_meter', timePerUnit: 0.2, expectedVersion: VERSION })],
  ['add step', (service) => service.addStepToTask(21, { title: 'Step' }, VERSION)],
  ['update step', (service) => service.updateStep(31, { title: 'Renamed' }, VERSION)],
  ['delete step', (service) => service.deleteStep(31, VERSION)],
  ['reorder steps', (service) => service.reorderSteps(21, [{ stepId: 31, order: 1 }], VERSION)]
];

describe('transactional package child mutations', () => {
  test.each(cases)('%s locks the parent, bumps its version exactly once and returns the current package', async (_name, mutate) => {
    const { service, connection, calls } = fixture();

    await expect(mutate(service)).resolves.toMatchObject({
      package: { id: PACKAGE_ID, version: VERSION + 1 },
      version: VERSION + 1
    });

    expect(connection.beginTransaction).toHaveBeenCalledTimes(1);
    expect(connection.commit).toHaveBeenCalledTimes(1);
    expect(connection.rollback).not.toHaveBeenCalled();
    expect(connection.release).toHaveBeenCalledTimes(1);
    expect(calls.some(({ sql }) => sql.includes('FOR UPDATE'))).toBe(true);
    const parentWrites = calls.filter(({ sql }) => /^\s*UPDATE material_packages\b/.test(sql));
    expect(parentWrites).toHaveLength(1);
    expect(parentWrites[0].sql).toContain('version = version + 1');
  });

  test.each(cases)('%s rejects a stale expectedVersion before any child write', async (_name, mutate) => {
    const { service, connection, calls } = fixture({ stale: true });

    await expect(mutate(service)).rejects.toMatchObject({
      status: 409,
      code: 'SMART_PACKAGE_VERSION_CONFLICT'
    });

    expect(connection.rollback).toHaveBeenCalledTimes(1);
    expect(connection.commit).not.toHaveBeenCalled();
    expect(calls.some(({ sql }) => /^(\s*)(INSERT|UPDATE|DELETE) (smart_package_tasks|smart_package_steps)/.test(sql))).toBe(false);
    expect(calls.some(({ sql }) => /^\s*UPDATE material_packages\b/.test(sql))).toBe(false);
  });

  test('a child write failure rolls the task mutation and parent version back atomically', async () => {
    const { service, connection, calls } = fixture({ failOn: 'UPDATE smart_package_tasks' });

    await expect(service.updateTask(21, { name: 'Renamed', hours: 2 }, VERSION))
      .rejects.toThrow('child write failed');

    expect(connection.rollback).toHaveBeenCalledTimes(1);
    expect(connection.commit).not.toHaveBeenCalled();
    expect(calls.some(({ sql }) => /^\s*UPDATE material_packages\b/.test(sql))).toBe(false);
  });

  test('name, rate, basis and dependency-only task changes still advance the aggregate version', async () => {
    const { service, calls } = fixture();

    await service.updateTask(21, {
      name: 'Only metadata changed',
      hours: 2,
      rate: 725,
      timeUnit: 'per_meter',
      timePerUnit: 0.25,
      dependsOn: 20
    }, VERSION);

    expect(calls.filter(({ sql }) => /^\s*UPDATE material_packages\b/.test(sql))).toHaveLength(1);
  });

  test.each([
    ['addTaskToPackage', service => service.addTaskToPackage(PACKAGE_ID, { name: 'Task' })],
    ['updateTask', service => service.updateTask(21, { name: 'Task' })],
    ['deleteTask', service => service.deleteTask(21)],
    ['reorderTasks', service => service.reorderTasks(PACKAGE_ID, [])],
    ['createCustomTask', service => service.createCustomTask({ packageId: PACKAGE_ID, name: 'Custom', timeUnit: 'per_meter', timePerUnit: 1 })],
    ['addStepToTask', service => service.addStepToTask(21, { title: 'Step' })],
    ['updateStep', service => service.updateStep(31, { title: 'Step' })],
    ['deleteStep', service => service.deleteStep(31)],
    ['reorderSteps', service => service.reorderSteps(21, [])]
  ])('%s fails closed when expectedVersion is absent', async (_method, mutate) => {
    const { service, connection } = fixture();
    await expect(mutate(service)).rejects.toMatchObject({ status: 400 });
    expect(connection.beginTransaction).not.toHaveBeenCalled();
  });
});