import { test } from 'node:test';
import assert from 'node:assert/strict';
import { JobQueue } from '../src/jobQueue.js';
import { createLogger } from '../src/logger.js';

const silentLogger = createLogger({}).child({});
// Silence output for these tests by pointing at a level above error.
process.env.LOG_LEVEL = 'error';

test('runs the job for a fresh key', async () => {
  const queue = new JobQueue(silentLogger);
  let ran = false;
  await queue.runExclusive('a', async () => {
    ran = true;
  });
  assert.equal(ran, true);
  assert.equal(queue.isRunning('a'), false);
});

test('skips a second call for the same key while the first is running', async () => {
  const queue = new JobQueue(silentLogger);
  let resolveFirst;
  const first = queue.runExclusive('a', () => new Promise((r) => (resolveFirst = r)));

  assert.equal(queue.isRunning('a'), true);
  let secondRan = false;
  await queue.runExclusive('a', async () => {
    secondRan = true;
  });
  assert.equal(secondRan, false);

  resolveFirst();
  await first;
  assert.equal(queue.isRunning('a'), false);
});

test('different keys run independently', async () => {
  const queue = new JobQueue(silentLogger);
  const order = [];
  let resolveA;
  const a = queue.runExclusive('a', () => new Promise((r) => (resolveA = r))).then(() => order.push('a'));
  const b = queue.runExclusive('b', async () => order.push('b'));
  await b;
  resolveA();
  await a;
  assert.deepEqual(order, ['b', 'a']);
});

test('clears the running key even when the job throws', async () => {
  const queue = new JobQueue(silentLogger);
  await queue.runExclusive('a', async () => {
    throw new Error('boom');
  });
  assert.equal(queue.isRunning('a'), false);
});