typescript - Simular valores resueltos cuando se realizan múltiples llamadas a Axios desde un único método

Antecedentes: Tengo una serie de métodos que en conjunto realizarán múltiples llamadas axios. En mi escenario, debo hacer la primera llamada axios para obtener algunos datos que luego puedo usar para generar la segunda llamada axios. Después de eso, tengo la tercera llamada axios que puede no estar relacionada con las dos primeras.

En mi prueba debo validar que la URL utilizada por la última llamada de axios sea una URL determinada

Problema: Cuando valido la URL, solo obtengo la primera llamada de axios. Según algunas pruebas que hice, parece que Jest solo ejecuta la primera llamada de axios o que mis valores resueltos no se están interpretando correctamente.

Pregunta: ¿Hay alguna manera de que lo que estoy tratando de hacer en mi escenario pueda funcionar? Cualquier ayuda es muy apreciada.

Aquí hay parte del código que he saneado lo mejor que puedo.

Programa principal:

interface IPrerequisite {
  // Some implementation
}

class Prerequisite implements IPrerequisite {
  error = "";
  async checkStatus(token: string) {
    return Promise.resolve(true);
  }

  async getAxiosResponse(url: string, token: string) {
    const headers: AxiosRequestConfig = {
      headers: {
        Accept: "application/json",
        "Content-Type": "application/json",
        Authorization: `Bearer ${token}`,
      },
      timeout: timeoutDuration,
    };

    return axios
      .post(url, {}, headers)
      .then((res: AxiosResponse) => {
        return Promise.resolve(res.data);
      })
      .catch((err: AxiosError) => {
        return Promise.resolve("");
      });
  }
}

class ListKeysPrereq extends Prerequisite {
  constructor() {
    super();
  }
  async checkStatus(token: string) {
    // First axios request
    const firstResponse = await this.getAxiosResponse(url, token);
    if (firstResponse === "") {
      return Promise.resolve(false);
    }

    // Second axios request
      // Do some stuff with first response to pass to second request
    const secondResponse = await this.getAxiosResponse(url, token);
    if (secondResponse === "") {
      return Promise.resolve(false);
    }

    // Do some stuff with second response

    return Promise.resolve(true);
  }
}

class PrerequisiteFactory {
  static getInstance(prerequisite: string): IPrerequisite {
    switch (prerequisite) {
      case "LIST_KEYS_PREREQ":
        return new ListKeysPrereq();
      default:
        return null;
    }
  }
}

const checkConnectionPrerequisites = async (token: string) => {
  enum Prerequisites {
    LIST_KEYS_PREREQ,
  }

  for (const prereq in Prerequisites) {
    if (isNaN(Number(prereq))) {
      const prerequisite = PrerequisiteFactory.getInstance(prereq);
      const prerequisiteStatus = await prerequisite.checkStatus(token);
      if (!prerequisiteStatus) {
        return Promise.resolve(prerequisite.error);
      }
    }
  }

  return Promise.resolve("");
};

const getConnectionString = async (url: string, token: string, location: string): Promise<string> => {
  try {
    const prereqStatus = await checkPrerequisites(token);
    // Do some stuff
  } catch (err) {
    // Handle exception
  }

  // Last axios request
  return axios
    .post(url, {}, headers)
    .then((response: AxiosResponse) => {
      // Do something with the last response
      return Promise.resolve("sometext");
    })
    .catch((err: AxiosError) => {
      handleError(operationName, err);
      return Promise.resolve("");
    });
};

export const startProgram = async (token: string) => {
  connectionString = await getConnectionString(url, token, location);

};

Prueba Jest

const postMock: jest.Mock = jest
  .fn()
  .mockResolvedValueOnce({
    status: 200,
    data: {
      someUri: "https://somefakestorageaccount.blob.core.contoso.com:443/somefakecontainer/somefakeblob",
    },
  })
  .mockResolvedValueOnce({ status: 200, data: { connectionString: "wss://thisfakestring/" } })
  .mockResolvedValueOnce({ status: 400 })
  .mockResolvedValue({ status: 200, data: { connectionString: "wss://thisfakestring/" } });

jest.mock("axios", () => {
  return {
    post: postMock,
  };
});

test("Sample Test", () => {
    const assertedUrl = "https://assertedurl.constoso.com/somecontainer/someblob";
    main.startprogram("token").then(() => {
      expect(postMock).toHaveBeenCalledTimes(1);
      expect(postMock.mock.calls[0][0]).toBe(assertedUrl); // This returns the call from only the first axios call
      expect(loadMock).toHaveBeenCalledTimes(4);
      expect(openMock).toHaveBeenCalledTimes(2);
    });
  });