ora-handler_spec.js

import { expect } from 'chai';
import proxyquire from 'proxyquire';
import sinon from 'sinon';

describe('asyncOra', () => {
  let asyncOra;
  let MockOra;
  let currentOra;

  beforeEach(() => {
    currentOra = undefined;
    MockOra = (text) => {
      currentOra = {
        start() {
          this.started = true;
          return currentOra;
        },
        succeed() {
          this.succeeded = true;
          return currentOra;
        },
        fail() {
          this.failed = true;
          return currentOra;
        },
        get text() {
          return currentOra._text;
        },
        set text(newText) {
          currentOra._text = newText;
        },
      };
      currentOra.succeeded = false;
      currentOra.failed = false;
      currentOra._text = text;
      return currentOra;
    };
    asyncOra = proxyquire.noCallThru().load('../../src/util/ora-handler', {
      './ora': MockOra,
    }).default;
  });

  it('should create an ora with an initial value', () => {
    asyncOra('say this first', async () => {});
    expect(currentOra).to.not.equal(undefined);
    expect(currentOra.text).to.equal('say this first');
  });

  it('should not create an ora when in non-interactive mode', () => {
    asyncOra.interactive = false;
    asyncOra('say this again', async () => {});
    expect(currentOra).to.equal(undefined);
  });

  it('should call the provided async function', async () => {
    const spy = sinon.spy();
    await asyncOra('random text', async () => {
      spy();
    });
    expect(spy.callCount).to.equal(1);
  });

  it('should succeed the ora if the async fn passes', async () => {
    await asyncOra('random text', async () => {
      if (2 + 2 === 5) console.error('Big brother is at it again'); // eslint-disable-line
    });
    expect(currentOra.succeeded).to.equal(true);
    expect(currentOra.failed).to.equal(false);
  });

  it('should fail the ora if the async fn throws', async () => {
    await asyncOra('this is gonna end badly', async () => {
      throw { message: 'Not an error', stack: 'No Stack - Not an error' }; // eslint-disable-line
    }, () => {});
    expect(currentOra.succeeded).to.equal(false);
    expect(currentOra.failed).to.equal(true);
  });

  it('should exit the process with status 1 if the async fn throws', async () => {
    const processExitSpy = sinon.spy();
    await asyncOra('this is dodge', async () => {
      throw 'woops'; // eslint-disable-line
    }, processExitSpy);
    expect(processExitSpy.callCount).to.equal(1);
    expect(processExitSpy.firstCall.args).to.deep.equal([1]);
  });

  it('should exit the process with status 1 if the async fn throws a number', async () => {
    const processExitSpy = sinon.spy();
    await asyncOra('this is dodge', async () => {
      throw 42; // eslint-disable-line
    }, processExitSpy);
    expect(processExitSpy.callCount).to.equal(1);
    expect(processExitSpy.firstCall.args).to.deep.equal([1]);
  });

  it('should just reject the promise in non-interactive mode if the fn throws', (done) => {
    asyncOra.interactive = false;
    asyncOra('doo-wop', async () => {
      throw new Error('uh oh');
    }).then(() => done(new Error('expected asyncOra to be rejected')))
      .catch(() => done());
  });

  it('should provide a fully functioning mock ora in non-interactive mode', async () => {
    asyncOra.interactive = false;
    await asyncOra('ora-magic', async (spinner) => {
      expect(spinner).to.have.property('start');
      expect(spinner).to.have.property('stop');
      expect(spinner).to.have.property('succeed');
      expect(spinner).to.have.property('fail');
      expect(spinner.start().stop().fail().succeed()).to.equal(spinner);
    });
  });
});