import asyncFn from '@asyncFn/sinon';
 
it('given called, a result can be resolved *after* the mock is called', async () => {
  const mockFunction = asyncFn();
  const promise = mockFunction();
 
  // Note how we resolve the returned promise *after* it is called.
  // This permits us to write our tests so that they read like a story.
  await mockFunction.resolve('some-value');
 
  const actual = await promise;
  expect(actual).toBe('some-value');
});

import asyncFn from '@asyncFn/sinon';
 
it('given called multiple times, the results can be resolved *after* the mock was called', async () => {
  const mockFunction = asyncFn();
 
  const promise = Promise.all([mockFunction(), mockFunction(), mockFunction()]);
 
  await mockFunction.resolve('some-first-value');
  await mockFunction.resolve('some-second-value');
  await mockFunction.resolve('some-third-value');
 
  const actual = await promise;
 
  expect(actual).toEqual([
    'some-first-value',
    'some-second-value',
    'some-third-value',
  ]);
});

import asyncFn from '@asyncFn/sinon';
 
it('can be awaited to test the coincidences of resolve', async () => {
  const mockFunction = asyncFn();
 
  let coincidenceHasHappened = false;
 
  mockFunction()
    .then()
    .then()
    .then(() => {
      coincidenceHasHappened = true;
    });
 
  await mockFunction.resolve();
 
  expect(coincidenceHasHappened).toBe(true);
});

import asyncFn from '@asyncFn/sinon';
 
it('can be rejected with a rejection', () => {
  const mockFunction = asyncFn();
  const promise = mockFunction();
 
  mockFunction.reject('some-rejection');
 
  return expect(promise).rejects.toBe('some-rejection');
});

import asyncFn from '@asyncFn/sinon';
 
it('does what sinon.spy does', () => {
  const mockFunction = asyncFn();
 
  mockFunction('some-argument', 'some-other-argument');
 
  expect(mockFunction.calledWith('some-argument', 'some-other-argument')).toBe(
    true,
  );
});