export default function promiseAny(promises) {
  // TODO: resolve on first fulfillment; reject with AggregateError if all reject
  throw new Error('Not implemented');
}

import promiseAny from './promiseAny';

describe('promiseAny', () => {
  test('resolves on first fulfillment', async () => {
    const bad = Promise.reject(new Error('nope'));
    const slow = new Promise((resolve) => setTimeout(() => resolve('slow'), 20));
    const fast = Promise.resolve('fast');

    await expect(promiseAny([bad, slow, fast])).resolves.toBe('fast');
  });

  test('handles non-promise values', async () => {
    await expect(promiseAny([0, Promise.resolve(2)])).resolves.toBe(0);
  });

  test('rejects with AggregateError when all reject', async () => {
    let err;
    try {
      await promiseAny([Promise.reject('a'), Promise.reject('b')]);
    } catch (e) {
      err = e;
    }
    expect(err).toBeTruthy();
    expect(err.name).toBe('AggregateError');
    expect(Array.isArray(err.errors)).toBe(true);
    expect(err.errors.length).toBe(2);
  });

  test('rejects for empty input', async () => {
    let err;
    try {
      await promiseAny([]);
    } catch (e) {
      err = e;
    }
    expect(err).toBeTruthy();
    expect(err.name).toBe('AggregateError');
  });


  test('rejects when input is not an array', async () => {
    // @ts-expect-error runtime guard
    await expect(promiseAny(null)).rejects.toThrow(TypeError);
  });
});