Javascript 如何在Redux中测试递归分派

我实现了自己处理访问/刷新令牌的方法。基本上，当

accessToken

过期时，它会等待另一个操作的分派，如果成功，它会再次分派自己。下面的代码更好地解释了这一点：

export const refresh = () => async (dispatch) => {
  dispatch({
    type: REFRESH_USER_FETCHING,
  });

  try {
    const user = await api.refresh();

    dispatch({
      type: REFRESH_USER_SUCCESS,
      payload: user,
    });
    return history.push("/");
  } catch (err) {
    const { code } = err;
    if (code !== "ACCESS_TOKEN_EXPIRED") {
      dispatch({
        type: REFRESH_USER_ERROR,
        payload: err,
      });

      const pathsToRedirect = ["/signup"];

      const {
        location: { pathname },
      } = history;

      const path = pathsToRedirect.includes(pathname) ? pathname : "/login";
      return history.push(path);
    }

    try {
      await dispatch(refreshToken());
      return dispatch(refresh());
    } catch (subErr) {
      dispatch({
        type: REFRESH_USER_ERROR,
        payload: err,
      });
      return history.push("/login");
    }
  }
};

export const refreshToken = () => async (dispatch) => {
  dispatch({
    type: REFRESH_TOKEN_FETCHING,
  });

  try {
    await api.refreshToken();
    dispatch({
      type: REFRESH_TOKEN_SUCCESS,
    });
  } catch (err) {
    dispatch({
      type: REFRESH_TOKEN_ERROR,
      payload: err,
    });
  }
};

问题是我发现很难用玩笑来测试。事实上，我已经实施了这个测试：

import configureMockStore from "redux-mock-store";
import thunk from "redux-thunk";
import * as actionCreators from "./actionCreators";
import * as actions from "./actions";
import api from "../../api";
jest.mock("../../api");

const middlewares = [thunk];
const mockStore = configureMockStore(middlewares);

describe("authentication actionCreators", () => {
  it("runs refresh, both token expired, should match the whole flow", async () => {
    api.refresh.mockRejectedValue({
      code: "ACCESS_TOKEN_EXPIRED",
      message: "jwt expired",
    });

    api.refreshToken.mockRejectedValue({
      code: "REFRESH_TOKEN_EXPIRED",
      message: "jwt expired",
    });

    const expectedActions = [
      { type: actions.REFRESH_USER_FETCHING },
      { type: actions.REFRESH_TOKEN_FETCHING },
      { type: actions.REFRESH_TOKEN_ERROR },
      { type: actions.REFRESH_USER_ERROR },
    ];
    const store = mockStore({ auth: {} });

    await store.dispatch(actionCreators.refresh());

    expect(store.getActions()).toEqual(expectedActions);
  });
});

但是测试并没有完成，而是不间断地运行。当我手动测试它时，这个问题并没有发生，所以我认为在开玩笑时遗漏了一些东西，所以我的问题是：有没有一种方法来测试这种递归行为

---

谢谢

问题是等待您与dispatch一起使用，dispatch返回一个操作，而不是承诺，请使用

承诺。解决

。

refreshToken

代码缺失-问题可能是

等待

您与dispatch一起使用时，dispatch将返回一个操作，据我所知，这不是一个承诺。@mavarazy更新了上面的代码。但是，您是对的-dispatch返回一个操作，返回

Promise。resolve（）

是解决方案