export default function promiseAny(iterable) {
  // TODO: consume a synchronous iterable, resolve first fulfillment, aggregate all rejections
  throw new Error('Not implemented');
}

import promiseAny from './promiseAny';

describe('promiseAny', () => {
  test('resolves on the first fulfillment', async () => {
    await expect(promiseAny([
      Promise.reject(new Error('nope')),
      Promise.resolve('fast'),
      Promise.resolve('later')
    ])).resolves.toBe('fast');
  });

  test('treats an array hole as undefined', async () => {
    await expect(promiseAny(new Array(1))).resolves.toBe(undefined);
  });

  test('does not hang when a sparse array also contains a rejection', async () => {
    const sparse = [];
    sparse[1] = Promise.reject('rejected');
    await expect(promiseAny(sparse)).resolves.toBe(undefined);
  });

  test('rejects empty input with an empty AggregateError', async () => {
    const error = await promiseAny([]).then(() => null, (reason) => reason);
    expect(error.name).toBe('AggregateError');
    expect(error.errors).toEqual([]);
  });

  test('preserves iteration order when every input rejects', async () => {
    let rejectFirst;
    let rejectSecond;
    const result = promiseAny([
      new Promise((_, reject) => { rejectFirst = reject; }),
      new Promise((_, reject) => { rejectSecond = reject; })
    ]).then(() => null, (reason) => reason);

    rejectSecond('second');
    rejectFirst('first');

    const error = await result;
    expect(error.name).toBe('AggregateError');
    expect(error.errors).toEqual(['first', 'second']);
  });

  test('accepts non-array synchronous iterables', async () => {
    const values = new Set([Promise.reject('no'), 'set value']);
    await expect(promiseAny(values)).resolves.toBe('set value');

    function* generate() {
      yield Promise.reject('still no');
      yield 'generator value';
    }
    await expect(promiseAny(generate())).resolves.toBe('generator value');
  });

  test('rejects non-iterable input with TypeError', async () => {
    await expect(promiseAny(null)).rejects.toThrow(TypeError);
  });
});