import assert from 'node:assert/strict';
import test from 'node:test';

import { finishRollback } from '../../dist/server/services/rollback.js';

test('shared rollback rethrows the original error after successful ordered restores', async () => {
  const original = new Error('original');
  const events = [];
  await assert.rejects(
    finishRollback(original, [
      { run: () => { events.push('first'); } },
      { run: async () => { events.push('second'); } },
    ], 'Rollback failed'),
    (error) => error === original,
  );
  assert.deepEqual(events, ['first', 'second']);
});

test('shared rollback continues, preserves aggregate order and message', async () => {
  const original = new Error('original');
  const first = new Error('first restore');
  const second = new Error('second restore');
  const events = [];
  await assert.rejects(
    finishRollback(original, [
      { run: () => { events.push('first'); throw first; } },
      { run: () => { events.push('middle'); } },
      { run: () => { events.push('second'); throw second; } },
    ], 'Expected rollback message'),
    (error) => {
      assert.ok(error instanceof AggregateError);
      assert.equal(error.message, 'Expected rollback message');
      assert.deepEqual(error.errors, [original, first, second]);
      return true;
    },
  );
  assert.deepEqual(events, ['first', 'middle', 'second']);
});

test('shared rollback maps a runtime restore failure to PROCESS_START_FAILED', async () => {
  const original = new Error('original');
  const config = new Error('config restore');
  const runtime = new Error('runtime restore');
  await assert.rejects(
    finishRollback(original, [
      { run: () => { throw config; } },
      { run: () => { throw runtime; }, runtime: true },
    ], 'Runtime rollback failed'),
    (error) => {
      assert.equal(error.code, 'PROCESS_START_FAILED');
      assert.equal(error.cause.message, 'Runtime rollback failed');
      assert.deepEqual(error.cause.errors, [original, config, runtime]);
      return true;
    },
  );
});