I have a major function that call 3 other functions. I want to test if those 3 function were called.

myController.ts

import axios from 'axios';

export async function functionOne() {
  console.log('Hit functionOne');
  const result = await axios.get('https://www.urlOne.com/first');
  return result;
}

export async function functionTwo() {
  const result = await axios.get('https://www.urlTwo.com/second');
  return result;
}

export async function functionThree() {
  const result = await axios.get('https://www.urlThree.com/third');
  return result;
}

export async function mainFunction() {
  const resultOne = await functionOne();
  // some logic that also calls functionTwo & functionThree
}

test.spec.ts

import * as myCtrl from '../controllers';
import { expect } from 'chai';
import * as sinon from 'sinon';
import * as sinonChai from 'sinon-chai';
import * as chaiAsPromised from 'chai-as-promised';

chai.use(sinonChai);
chai.use(chaiAsPromised);
chai.should();

describe('success', () => {
  const sandbox = sinon.createSandbox();

  // Create Spies
  beforeEach(() => {
    sandbox.spy(myCtrl, 'functionOne');
    sandbox.spy(myCtrl, 'functionTwo');
    sandbox.spy(myCtrl, 'functionThree');
  });

  afterEach(() => {
    sandbox.restore();
  })


  it('test something', async () => {
    nock('https://www.urlOne.com')
      .get('first')
      .reply(200)

    nock('https://www.urlTwo.com')
      .get('second')
      .reply(200)

    nock('https://www.urlThree.com')
      .get('third')
      .reply(200)

    await myCtrl.mainFunction();

    expect(myCtrl.functionOne).to.be.calledOnce();
    expect(myCtrl.functionTwo).to.be.calledOnce();
    expect(myCtrl.functionThree).to.be.calledOnce();
  });
});

It looks weird, but according to the nock documentation, using multiple nocks is the right way.

The problem is, it always returns:

AssertionError: expected functionOne to have been called exactly once, but it was called 0 times

I can see the console.log message on console, but the count still 0. Am I missing something here?