export default function createDeferred() {
  throw new Error('Not implemented');
}

import createDeferred from './createDeferred';

describe('createDeferred', () => {
  test('returns promise, resolve, and reject controls', () => {
    const d = createDeferred();

    expect(typeof d).toBe('object');
    expect(typeof d.promise.then).toBe('function');
    expect(typeof d.resolve).toBe('function');
    expect(typeof d.reject).toBe('function');
  });

  test('does not settle before resolve or reject is called', async () => {
    const d = createDeferred();
    let settled = false;

    d.promise.finally(() => {
      settled = true;
    });

    await Promise.resolve();

    expect(settled).toBe(false);

    d.resolve('ok');
    await d.promise;

    expect(settled).toBe(true);
  });

  test('resolves when resolve is called', async () => {
    const d = createDeferred();

    d.resolve(123);

    await expect(d.promise).resolves.toBe(123);
  });

  test('rejects with the exact reason when reject is called', async () => {
    const d = createDeferred();
    const error = new Error('nope');

    d.reject(error);

    await expect(d.promise).rejects.toBe(error);
  });

  test('adopts another promise when resolving', async () => {
    const d = createDeferred();

    d.resolve(Promise.resolve('ok'));

    await expect(d.promise).resolves.toBe('ok');
  });

  test('only the first settlement wins', async () => {
    const d = createDeferred();

    d.resolve('first');
    d.resolve('second');
    d.reject(new Error('ignored'));

    await expect(d.promise).resolves.toBe('first');
  });

  test('then callbacks do not run synchronously after resolve', async () => {
    const d = createDeferred();
    let value = 'pending';

    d.promise.then((result) => {
      value = result;
    });

    d.resolve('done');

    expect(value).toBe('pending');

    await Promise.resolve();

    expect(value).toBe('done');
  });
});