Polish code and improve tests

README.md

@@ -347,7 +347,7 @@ type MiddlewareConfig = {
   regexActionType?: RegExp = /FETCH.*REQUEST/,
   actionTypes?: Array<string> = [],
   queueReleaseThrottle?: number = 50,
-  shouldDequeueSelector: (state: State) => boolean = state => state.conditionToReleaseQueue
+  shouldDequeueSelector: (state: RootReduxState) => boolean = () => true
 }
 ```
 
@@ -361,7 +361,7 @@ By default it's configured to intercept actions for fetching data following the
 
 `queueReleaseThrottle`: waiting time in ms between dispatches when flushing the offline queue. Useful to reduce the server pressure when coming back online. Defaults to 50ms.
 
-`shouldDequeueSelector`: state selector used to control if the queue should be released on connection change. Returning `true` releases the queue, returning `false` prevents queue release. Note, if the result of `shouldDequeueSelector` changes *while* the queue is being released, the queue will not halt. If you want to halt the queue *while* is being released, please see relevant FAQ section.
+`shouldDequeueSelector`: function that receives the redux application state and returns a boolean. It'll be executed every time an action is dispatched, before it reaches the reducer. This is useful to control if the queue should be released when the connection is regained and there were actions queued up. Returning `true` (the default behaviour) releases the queue, whereas returning `false` prevents queue release. For example, you may wanna perform some authentication checks, prior to releasing the queue. Note, if the result of `shouldDequeueSelector` changes *while* the queue is being released, the queue will not halt. If you want to halt the queue *while* is being released, please see relevant FAQ section.
 
 
 ##### Thunks Config

src/redux/createNetworkMiddleware.js

@@ -80,11 +80,20 @@ function didQueueResume(action, isQueuePaused) {
   );
 }
 
-export const createReleaseQueue = (getState, next, delay) => async queue => {
+export const createReleaseQueue = (
+  getState,
+  next,
+  delay,
+  shouldDequeueSelector,
+) => async queue => {
   // eslint-disable-next-line
   for (const action of queue) {
-    const { isConnected, isQueuePaused } = getState().network;
-    if (isConnected && !isQueuePaused) {
+    const state = getState();
+    const {
+      network: { isConnected, isQueuePaused },
+    } = state;
+
+    if (isConnected && !isQueuePaused && shouldDequeueSelector(state)) {
       next(removeActionFromQueue(action));
       next(action);
       // eslint-disable-next-line
@@ -109,6 +118,7 @@ function createNetworkMiddleware({
       getState,
       next,
       queueReleaseThrottle,
+      shouldDequeueSelector,
     );
     validateParams(regexActionType, actionTypes);
 

src/redux/createReducer.js

@@ -1,6 +1,7 @@
 /* @flow */
 
 import { get, without } from 'lodash';
+import { SEMAPHORE_COLOR } from '../utils/constants';
 import actionTypes from './actionTypes';
 import getSimilarActionInQueue from '../utils/getSimilarActionInQueue';
 import type {
@@ -89,7 +90,7 @@ function handleChangeQueueSemaphore(
 ): NetworkState {
   return {
     ...state,
-    isQueuePaused: semaphoreColor === 'RED',
+    isQueuePaused: semaphoreColor === SEMAPHORE_COLOR.RED,
   };
 }
 

test/createNetworkMiddleware.test.js

@@ -393,15 +393,46 @@ describe('createNetworkMiddleware with dismissing actions functionality', () =>
   });
 });
 
+describe('createNetworkMiddleware with queueDeselector', () => {
+  const mockDequeueSelector = jest.fn();
+  const networkMiddleware = createNetworkMiddleware({
+    shouldDequeueSelector: mockDequeueSelector,
+  });
+  const middlewares = [networkMiddleware];
+  const mockStore = configureStore(middlewares);
+
+  it('Proxies action to next middleware if deselector returns false', () => {
+    const initialState = {
+      network: {
+        isConnected: true,
+        actionQueue: [],
+      },
+    };
+    const store = mockStore(initialState);
+    const action = getFetchAction('REFRESH_DATA');
+    store.dispatch(action);
+
+    const actions = store.getActions();
+    expect(actions).toEqual([getFetchAction('REFRESH_DATA')]);
+  });
+});
+
 describe('createReleaseQueue', () => {
   const mockDispatch = jest.fn();
-  const mockGetState = jest.fn().mockImplementation(() => ({
-    network: {
-      isConnected: true,
-      isQueuePaused: false,
-    },
-  }));
+  const mockGetState = jest.fn();
+  const mockDequeueSelector = jest.fn();
   const mockDelay = 50;
+
+  beforeEach(() => {
+    mockDequeueSelector.mockImplementation(() => true);
+    mockGetState.mockImplementation(() => ({
+      network: {
+        isConnected: true,
+        isQueuePaused: false,
+      },
+    }));
+  });
+
   afterEach(() => {
     mockDispatch.mockClear();
     mockGetState.mockClear();
@@ -412,6 +443,7 @@ describe('createReleaseQueue', () => {
       mockGetState,
       mockDispatch,
       mockDelay,
+      mockDequeueSelector,
     );
     const actionQueue = ['foo', 'bar'];
     await releaseQueue(actionQueue);
@@ -428,7 +460,7 @@ describe('createReleaseQueue', () => {
     expect(mockDispatch).toHaveBeenNthCalledWith(4, 'bar');
   });
 
-  it('does not empty the queue if we are online and dequeue selector returns false', async () => {
+  it('does not empty the queue if dequeue selector returns false', async () => {
     const mockDequeueSelector = () => false;
     const releaseQueue = createReleaseQueue(
       mockGetState,
@@ -438,17 +470,24 @@ describe('createReleaseQueue', () => {
     );
     const actionQueue = ['foo', 'bar'];
     await releaseQueue(actionQueue);
-    expect(mockDispatch).toHaveBeenCalledTimes(4);
-    expect(mockDispatch).toHaveBeenNthCalledWith(
-      1,
-      actionCreators.removeActionFromQueue('foo'),
-    );
-    expect(mockDispatch).toHaveBeenNthCalledWith(2, 'foo');
-    expect(mockDispatch).toHaveBeenNthCalledWith(
-      3,
-      actionCreators.removeActionFromQueue('bar'),
+    expect(mockDispatch).toHaveBeenCalledTimes(0);
+  });
+
+  it('does not empty the queue if queue has been halted', async () => {
+    mockGetState.mockImplementation(() => ({
+      network: {
+        isQueuePaused: true,
+      },
+    }));
+    const releaseQueue = createReleaseQueue(
+      mockGetState,
+      mockDispatch,
+      mockDelay,
+      mockDequeueSelector,
     );
-    expect(mockDispatch).toHaveBeenNthCalledWith(4, 'bar');
+    const actionQueue = ['foo', 'bar'];
+    await releaseQueue(actionQueue);
+    expect(mockDispatch).toHaveBeenCalledTimes(0);
   });
 
   it('dispatches only during the online window', async () => {
@@ -466,6 +505,7 @@ describe('createReleaseQueue', () => {
       mockGetState,
       mockDispatch,
       mockDelay,
+      mockDequeueSelector,
     );
     const actionQueue = ['foo', 'bar'];
     await Promise.all([releaseQueue(actionQueue), switchToOffline()]);
@@ -476,27 +516,6 @@ describe('createReleaseQueue', () => {
     );
     expect(mockDispatch).toHaveBeenNthCalledWith(2, 'foo');
   });
-
-  it('should stop dispatching if queue has been halted', async () => {
-    const haltQueue = () =>
-      new Promise(async resolve => {
-        await wait(30);
-        mockGetState.mockImplementation(() => ({
-          network: {
-            isQueuePaused: true,
-          },
-        }));
-        resolve();
-      });
-    const releaseQueue = createReleaseQueue(
-      mockGetState,
-      mockDispatch,
-      mockDelay,
-    );
-    const actionQueue = ['foo', 'bar'];
-    await Promise.all([releaseQueue(actionQueue), haltQueue()]);
-    expect(mockDispatch).toHaveBeenCalledTimes(0);
-  });
 });
 
 describe('createNetworkMiddleware with wrong type params', () => {

test/reducer.test.js

@@ -406,11 +406,3 @@ describe('networkSelector', () => {
     });
   });
 });
-
-describe('network reducer config', () => {
-  it('has isQueuePaused set to false by default', () => {
-    expect(networkReducer(undefined, { type: 'ACTION_I_DONT_CARE' })).toEqual(
-      initialState,
-    );
-  });
-});