Unit-testing Axios CancelToken behaviour

actions.js

const tableCanceller = new Cancellation();
...
export const fetchTableData = (store, payload) => {
  tableCanceller.check('Table API request cancelled');

  return axios
    .post(`${payload.profileId}/report/${payload.reportId}/tabular`, payload.body, {
      params: {
        fromDate: payload.body.fromDate,
        toDate: payload.body.toDate,
      },
      cancelToken: new CancelToken(function executor(cancel) {
        tableCanceller.create(cancel);
      }),
    })
    .then(response => {
      tableCanceller.restore();
      return store.commit('SET_REPORT_TABLE_DATA', response.data.result);
    })
    .catch(cancel => {
      return cancel.message;
    });
};

actions.spec.js

beforeEach(() => {
  mockStore = {
    commit: sinon.stub(),
    dispatch: sinon.stub(),
  };
  fakeResponse = { headers: { authorization: 'Bearer' }, response: { result: {} } };
  moxios.install(http);
  moxios.stubRequest(/.*/, fakeResponse);
});

describe('#fetchTableData', () => {
    ...
    it('will be cancelled if a second request is issued before the request completes', done => {
      const mockPayload = {
        profileId: 'realProfile',
        reportId: 'verySeriousReport',
        body: { fromDate: 'yesterday', toDate: 'today' },
      };
      const cancelledRequest = fetchTableData(mockStore, mockPayload);
      fetchTableData(mockStore, mockPayload).then(async () => {
        const cancelMessage = await cancelledRequest;
        expect(cancelMessage).to.equal('Table API request cancelled');
        done();
      });
    });
  });

cancellation.js

class Cancellation {
  constructor() {
    this.runningCall = null;
  }
  create(func) {
    this.runningCall = func;
  }
  restore() {
    this.runningCall = null;
  }
  check(message) {
    if (this.runningCall) {
      this.runningCall(message);
    }
  }
}

export { Cancellation as default };

cancellation.spec.js

describe('Cancellation', () => {
  let dummyFunc;
  let cancellation;

  beforeEach(() => {
    dummyFunc = sinon.stub();
    cancellation = new Cancellation();
  });

  describe('#create', () => {
    it('sets the passed function to the runningCall property', () => {
      cancellation.create(dummyFunc);
      expect(cancellation.runningCall).to.equal(dummyFunc);
    });
  });

  describe('#restore', () => {
    it('sets the runningCall property back to null', () => {
      cancellation.create(dummyFunc);
      cancellation.restore();
      expect(cancellation.runningCall).to.be.null;
    });
  });

  describe('#check', () => {
    it('executes runningCall if it has been set', () => {
      cancellation.create(dummyFunc);
      cancellation.check('Down with this sort of thing');
      expect(dummyFunc).calledWith('Down with this sort of thing');
    });

    it('otherwise does nothing', () => {
      cancellation.create(dummyFunc);
      cancellation.restore();
      cancellation.check('Down with this sort of thing');
      expect(dummyFunc).not.called;
    });
  });
});