Better support unit-testing of reducers that handle lifecycle actions

Context

Using createAsyncThunk, I created a thunk fetchDatato fetch data from the network. I unit-test the (non-trivial) thunk logic and the lifecycle reducers seperately, that is, I have unit tests to

• Check if the thunk dispatches the right actions, and
• Check if the reducers update the store correctly for each of the three lifecycle actions.

Problem

To test the reducer logic for any of the lifecycle actions, say the fulfilled action, I need to dispatch the action. I see three options to create the action, none of which seems ideal:

1. One option is to call fetchData.fulfilled. However, the action creator’s parameters are not explained anywhere in the official docs, and the number of parameters was silently changed in release 1.5.0. This suggests that the action creator is not intended to be called from outside of RTK.
2. Instead, I could easily write my own action creator of course. However, I guess it would be better if RTK provided it as it would likely be beneficial for many RTK users. After all, unit-testing reducers is quite a common use case 😃
3. A third option is to mock the data fetching to have the thunk dispatch the lifecycle actions. This is not optimal either because unit-testing reducers should be independent of thunks.

TLDR

I think it would be best if the three lifecycle action creators exposed by a thunk would be an official part of RTK’s API.

[lukasgebhard]

For the meantime, I chose option (2), that is, I wrote action creators to mock the lifecycle actions:

export function mockPendingAction<ThunkArg>(
  typePrefix: string,
  thunkArg: ThunkArg
): PendingAction<ThunkArg> {
  return {
    type: typePrefix + '/pending',
    payload: undefined,
    meta: {
      requestId: '0',
      arg: thunkArg,
      requestStatus: 'pending'
    }
  }
}
export function mockFulfilledAction<PromiseResult, ThunkArg>(
  typePrefix: string,
  promiseResult: PromiseResult,
  thunkArg: ThunkArg
): FulfilledAction<ThunkArg, PromiseResult> {
  return {
    type: typePrefix + '/fulfilled',
    payload: promiseResult,
    meta: {
      requestId: '0',
      arg: thunkArg,
      requestStatus: 'fulfilled'
    }
  }
}
export function mockRejectedAction<ThunkArg>(
  typePrefix: string,
  error: SerializedError,
  thunkArg: ThunkArg
): RejectedAction<ThunkArg> {
  return {
    type: typePrefix + '/rejected',
    payload: undefined,
    error: error,
    meta: {
      requestId: '0',
      arg: thunkArg,
      aborted: false,
      condition: false,
      requestStatus: 'rejected',
      rejectedWithValue: false
    }
  }
}
export function mockRejectedWithValueAction<ThunkArg, RejectedValue>(
  typePrefix: string,
  rejectedValue: RejectedValue,
  thunkArg: ThunkArg
): RejectedWithValueAction<ThunkArg, RejectedValue> {
  return {
    type: typePrefix + '/rejected',
    payload: rejectedValue,
    error: { message: 'Rejected' },
    meta: {
      requestId: '0',
      arg: thunkArg,
      aborted: false,
      condition: false,
      requestStatus: 'rejected',
      rejectedWithValue: true
    }
  }
}

However, this requires redefining the action types (PendingAction, FulfilledAction, RejectedAction, RejectedWithValueAction). Would you mind exporting these types to avoid the need for redefining them?

[markerikson]

Resolved in #1083 .