@olea-bps/base 1.0.0

package/libraries/redux-offline/src/__tests__/defaults/discard.js

@@ -0,0 +1,22 @@
+import discard from '../../defaults/discard';
+
+test('discards non-http error', () => {
+  const error = { message: 'Non-http error' };
+  const action = { type: 'DISCARD', meta: { offline: { effect: {} } } };
+
+  expect(discard(error, action)).toEqual(true);
+});
+
+test('discards http 4xx errors', () => {
+  const error = { status: 404 };
+  const action = { type: 'DISCARD', meta: { offline: { effect: {} } } };
+
+  expect(discard(error, action)).toEqual(true);
+});
+
+test('does not discard http 5xx errors', () => {
+  const error = { status: 500 };
+  const action = { type: 'DISCARD', meta: { offline: { effect: {} } } };
+
+  expect(discard(error, action)).toEqual(false);
+});

package/libraries/redux-offline/src/__tests__/defaults/effect.js

@@ -0,0 +1,118 @@
+import effectReconciler, { getHeaders } from '../../defaults/effect';
+
+function fetch(body) {
+  return Promise.resolve({
+    ok: true,
+    headers: { get: jest.fn(() => 'application/json') },
+    text: jest.fn(() => Promise.resolve(body))
+  });
+}
+
+let globalFetch;
+
+beforeAll(() => {
+  globalFetch = global.fetch;
+});
+afterAll(() => {
+  global.fetch = globalFetch;
+});
+
+test('effector accept JSON stringified object', () => {
+  const body = {
+    email: 'email@example.com',
+    password: 'p4ssw0rd'
+  };
+
+  global.fetch = jest.fn((url, options) => {
+    expect(options.headers['content-type']).toEqual('application/json');
+    expect(JSON.parse(options.body)).toEqual(body);
+
+    return fetch('');
+  });
+
+  return effectReconciler({ body: JSON.stringify(body) }).then(body2 => {
+    expect(body2).toEqual(null);
+  });
+});
+
+test('effector accept JSON object', () => {
+  const json = {
+    email: 'email@example.com',
+    password: 'p4ssw0rd'
+  };
+
+  global.fetch = jest.fn((url, options) => {
+    expect(options.headers['content-type']).toEqual('application/json');
+    expect(JSON.parse(options.body)).toEqual(json);
+
+    return fetch('');
+  });
+
+  return effectReconciler({ json }).then(body2 => {
+    expect(body2).toEqual(null);
+  });
+});
+
+test('effector rejects invalid JSON object', () => {
+  const circularObject = {};
+  circularObject.self = circularObject;
+
+  return effectReconciler({ json: circularObject }).catch(error => {
+    expect(error).toBeInstanceOf(TypeError);
+  });
+});
+
+test('effector receive JSON and response objects', () => {
+  const body = { id: 1234 };
+
+  global.fetch = jest.fn(() => fetch(JSON.stringify(body)));
+
+  return effectReconciler({}).then(body2 => {
+    expect(body2).toEqual(body);
+  });
+});
+
+test('effector accepts content-type and Content-Type headers', () => {
+  const otherHeaders = { 'other-one': 'other-one', 'other-two': 'other-two' };
+  const formUrlEncoded = 'application/x-www-form-urlencoded';
+
+  const noHeaders = undefined;
+  const capitalizedHeaders = {
+    'Content-Type': formUrlEncoded,
+    ...otherHeaders
+  };
+  const lowerCasedHeaders = { 'content-type': formUrlEncoded, ...otherHeaders };
+
+  expect(getHeaders(noHeaders)).toEqual({ 'content-type': 'application/json' });
+  expect(getHeaders(capitalizedHeaders)).toEqual({
+    'content-type': formUrlEncoded,
+    ...otherHeaders
+  });
+  expect(getHeaders(lowerCasedHeaders)).toEqual({
+    'content-type': formUrlEncoded,
+    ...otherHeaders
+  });
+});
+
+test('effector receives object as multipart/form-data', () => {
+  const body = new FormData();
+  body.append('id', 1234);
+  body.append('name', 'john');
+  body.forEach((value, key) => {
+    body[key] = value;
+  });
+
+  global.fetch = jest.fn((url, options) => {
+    expect(options.headers['content-type']).toEqual('multipart/form-data');
+    expect(options.body).toBeInstanceOf(FormData);
+    expect(options.body.get('id')).toBe('1234');
+    return fetch('');
+  });
+
+  return effectReconciler({
+    body,
+    headers: { 'content-type': 'multipart/form-data' }
+  }).then(body2 => {
+    expect(body2).toEqual(null);
+  });
+});

package/libraries/redux-offline/src/__tests__/index.js

@@ -0,0 +1,116 @@
+import { applyMiddleware, combineReducers, compose, createStore } from "redux";
+import { KEY_PREFIX } from "redux-persist/lib/constants"
+import { AsyncNodeStorage } from "redux-persist-node-storage";
+import instrument from "redux-devtools-instrument";
+import { createOffline, offline } from "../index";
+import { applyDefaults } from "../config";
+import { networkStatusChanged } from "../actions";
+
+const storageKey = `${KEY_PREFIX}offline`;
+const defaultReducer = (state = {}) => state;
+const noop = () => {};
+
+let defaultConfig;
+beforeEach(() => {
+  const storage = new AsyncNodeStorage("/tmp/storageDir");
+  defaultConfig = applyDefaults({
+    effect: jest.fn(() => Promise.resolve()),
+    persistOptions: { storage }
+  });
+});
+
+test("offline() creates storeEnhancer", () => {
+  const storeEnhancer = offline(defaultConfig);
+
+  const store = storeEnhancer(createStore)(defaultReducer);
+  expect(store.dispatch).toEqual(expect.any(Function));
+  expect(store.getState).toEqual(expect.any(Function));
+});
+
+test("createOffline() creates storeEnhancer", () => {
+  const { middleware, enhanceReducer, enhanceStore } =
+    createOffline(defaultConfig);
+  const reducer = enhanceReducer(defaultReducer);
+  const store = createStore(reducer, compose(
+    applyMiddleware(middleware),
+    enhanceStore
+  ));
+  expect(store.dispatch).toEqual(expect.any(Function));
+  expect(store.getState).toEqual(expect.any(Function));
+});
+
+// see https://github.com/redux-offline/redux-offline/issues/31
+test("supports HMR by overriding `replaceReducer()`", () => {
+  const store = offline(defaultConfig)(createStore)(defaultReducer);
+  store.replaceReducer(combineReducers({
+    data: defaultReducer
+  }));
+  store.dispatch({ type: "SOME_ACTION" });
+  expect(store.getState()).toHaveProperty("offline");
+});
+
+test("createOffline() supports HMR", () => {
+  const { middleware, enhanceReducer, enhanceStore } =
+    createOffline(defaultConfig);
+  const reducer = enhanceReducer(defaultReducer);
+  const store = createStore(reducer, compose(
+    applyMiddleware(middleware),
+    enhanceStore
+  ));
+  store.replaceReducer(combineReducers({
+    data: defaultReducer
+  }));
+  store.dispatch({ type: "SOME_ACTION" });
+  expect(store.getState()).toHaveProperty("offline");
+});
+
+// see https://github.com/redux-offline/redux-offline/issues/4
+test("restores offline outbox when rehydrates", done => {
+  const actions = [{
+    type: "SOME_OFFLINE_ACTION",
+    meta: { offline: { effect: {} } }
+  }];
+  defaultConfig.persistOptions.storage.setItem(
+    storageKey,
+    JSON.stringify({ outbox: actions }),
+    noop
+  );
+
+  const store = offline({
+    ...defaultConfig,
+    persistCallback() {
+      const { offline: { outbox } } = store.getState();
+      expect(outbox).toEqual(actions);
+      done();
+    }
+  })(createStore)(defaultReducer);
+});
+
+// see https://github.com/jevakallio/redux-offline/pull/91
+test("works with devtools store enhancer", () => {
+  const monitorReducer = state => state;
+  const store = createStore(
+    defaultReducer,
+    compose(offline(defaultConfig), instrument(monitorReducer))
+  );
+
+  expect(() => {
+    store.dispatch({ type: "SOME_ACTION" });
+  }).not.toThrow();
+});
+
+// there were some reports that this might not be working correctly
+test("coming online processes outbox", () => {
+  const { middleware, enhanceReducer } = createOffline(defaultConfig);
+  const reducer = enhanceReducer(defaultReducer);
+  const store = createStore(reducer, applyMiddleware(middleware));
+
+  expect(store.getState().offline.online).toBe(false);
+  const action = { type: "REQUEST", meta: { offline: { effect: {} } } };
+  store.dispatch(action);
+  expect(defaultConfig.effect).not.toBeCalled();
+
+  store.dispatch(networkStatusChanged(true));
+  expect(store.getState().offline.online).toBe(true);
+  expect(defaultConfig.effect).toBeCalled();
+});

package/libraries/redux-offline/src/__tests__/middleware.js

@@ -0,0 +1,185 @@
+import { createOfflineMiddleware } from '../middleware';
+import { completeRetry, scheduleRetry } from '../actions';
+import defaultConfig from '../defaults';
+import { OFFLINE_SEND } from '../constants';
+import send from '../send';
+import offlineActionTracker from '../offlineActionTracker';
+
+const offlineAction = {
+  type: 'OFFLINE_ACTION_REQUEST',
+  meta: {
+    offline: {
+      effect: { url: '/api/endpoint', method: 'POST' },
+      commit: { type: 'OFFLINE_ACTION_COMMIT' },
+      rollback: { type: 'OFFLINE_ACTION_ROLLBACK' }
+    },
+    transaction: 0
+  }
+};
+
+const defaultOfflineState = {
+  busy: false,
+  lastTransaction: 0,
+  online: true,
+  outbox: [offlineAction],
+  receipts: [],
+  retryToken: 0,
+  retryCount: 0,
+  retryScheduled: false,
+  netInfo: {
+    isConnectionExpensive: null,
+    reach: 'NONE'
+  }
+};
+
+function setup(offlineState = {}) {
+  const state = {
+    offline: { ...defaultOfflineState, ...offlineState }
+  };
+  return {
+    config: {
+      ...defaultConfig,
+      rehydrate: false,
+      persist: null,
+      detectNetwork: null,
+      batch: jest.fn(outbox => outbox.slice(0, 1)),
+      effect: jest.fn(),
+      retry: jest.fn(),
+      discard: jest.fn(),
+      offlineActionTracker: offlineActionTracker.withoutPromises
+    },
+    store: {
+      getState: jest.fn(() => state),
+      dispatch: jest.fn()
+    },
+    next: jest.fn(action => ({ actions: [action] })),
+    action: { type: 'NOT_OFFLINE_ACTION' }
+  };
+}
+
+// NOTE: there is not currently an action creator for this
+function offlineSend() {
+  return { type: OFFLINE_SEND };
+}
+
+jest.mock('../send', () => jest.fn(() => Promise.resolve()));
+beforeEach(send.mockClear);
+
+test('creates middleware', () => {
+  const { config, store, next, action } = setup();
+  const middleware = createOfflineMiddleware(config);
+
+  const result = middleware(store)(next)(action);
+  expect(next).toBeCalled();
+  expect(result).toEqual(next(action));
+});
+
+describe('on any action', () => {
+  it('processes outbox when idle', () => {
+    const { config, store, next, action } = setup();
+    createOfflineMiddleware(config)(store)(next)(action);
+    expect(send).toBeCalled();
+  });
+
+  it('does not process outbox when busy', () => {
+    const { config, store, next, action } = setup({ busy: true });
+    createOfflineMiddleware(config)(store)(next)(action);
+    expect(send).not.toBeCalled();
+  });
+
+  it('does not process outbox when retry scheduled', () => {
+    const { config, store, next, action } = setup({ retryScheduled: true });
+    createOfflineMiddleware(config)(store)(next)(action);
+    expect(send).not.toBeCalled();
+  });
+
+  it('does not process outbox when offline', () => {
+    const { config, store, next, action } = setup({ online: false });
+    createOfflineMiddleware(config)(store)(next)(action);
+    expect(send).not.toBeCalled();
+  });
+});
+
+// TODO: test for double dispatch
+describe('on OFFLINE_SEND', () => {
+  it('processes outbox when idle', () => {
+    const { config, store, next } = setup();
+    createOfflineMiddleware(config)(store)(next)(offlineSend());
+    expect(send).toBeCalled();
+  });
+
+  it('does not process outbox when busy', () => {
+    const { config, store, next } = setup({ busy: true });
+    createOfflineMiddleware(config)(store)(next)(offlineSend());
+    expect(send).not.toBeCalled();
+  });
+
+  it('processes outbox when retry scheduled', () => {
+    const { config, store, next } = setup({ retryScheduled: true });
+    createOfflineMiddleware(config)(store)(next)(offlineSend());
+    expect(send).toBeCalled();
+  });
+
+  it('processes outbox when offline', () => {
+    const { config, store, next } = setup({ online: false });
+    createOfflineMiddleware(config)(store)(next)(offlineSend());
+    expect(send).toBeCalled();
+  });
+});
+
+// TODO: wrapping `setTimeout()` in a promise in `after()` is pointless
+describe('on OFFLINE_SCHEDULE_RETRY', () => {
+  jest.useFakeTimers();
+  const delay = 15000;
+
+  test('dispatches COMPLETE_RETRY after delay', () => {
+    const { config, store, next } = setup();
+    createOfflineMiddleware(config)(store)(next)(scheduleRetry(delay));
+    jest.runTimersToTime(delay);
+
+    expect.assertions(1);
+    const nextAction = store.getState().offline.outbox[0];
+    return Promise.resolve().then(() =>
+      expect(store.dispatch).toBeCalledWith(completeRetry(nextAction)));
+  });
+});
+
+test('offlineActionTracker without promises', () => {
+  const { config, store, next } = setup();
+
+  const value = createOfflineMiddleware(config)(store)(next)(offlineAction);
+  expect(value).not.toHaveProperty('then');
+});
+
+describe('offlineActionTracker integration', () => {
+  let config, store, next;
+  beforeEach(() => {
+    ({ config, store, next } = setup())
+    config = {
+      ...config,
+      offlineActionTracker: offlineActionTracker.withPromises 
+    };
+  });
+
+  test('returns a promise that can be resolved', () => {
+    const promise = createOfflineMiddleware(config)(store)(next)(offlineAction);
+
+    const transaction = 0;
+    const data = { some: "data" };
+    config.offlineActionTracker.resolveAction(transaction, data);
+
+    expect.assertions(1);
+    return promise.then(value => expect(value).toEqual(data));
+  });
+
+  test('returns a promise that can be rejected', () => {
+    const promise = createOfflineMiddleware(config)(store)(next)(offlineAction);
+
+    const transaction = 0;
+    const data = { some: 'data' };
+    config.offlineActionTracker.rejectAction(transaction, data);
+
+    expect.assertions(1);
+    return promise.catch(error => expect(error).toEqual(data));
+  });
+});

package/libraries/redux-offline/src/__tests__/offlineActionTracker.js

@@ -0,0 +1,54 @@
+import offlineActionTracker from '../offlineActionTracker.js';
+const {
+  registerAction,
+  resolveAction,
+  rejectAction
+} = offlineActionTracker.withPromises;
+
+test('resolves first action with correct transaction', () => {
+  const transaction = 0;
+  const promise = registerAction(transaction);
+
+  const data = { some: "data" };
+  resolveAction(transaction, data);
+
+  expect.assertions(1);
+  return promise.then(value => expect(value).toEqual(data));
+});
+
+test('rejects first action with correct transaction', () => {
+  const transaction = 0;
+  const promise = registerAction(transaction);
+
+  const data = { some: "data" };
+  rejectAction(transaction, data);
+
+  expect.assertions(1);
+  return promise.catch(error => expect(error).toEqual(data));
+});
+
+test('does not resolve first action with incorrect transaction', () => {
+  const transaction = 0;
+  const promise = registerAction(transaction);
+
+  const incorrectData = { incorrect: "data" };
+  resolveAction(transaction + 1, incorrectData);
+
+  const correctData = { some: "data" };
+  resolveAction(transaction, correctData);
+
+  expect.assertions(1);
+  return promise.then(value => expect(value).toEqual(correctData));
+});
+
+test('resolves second action with correct transaction', () => {
+  const array = [];
+
+  registerAction(0).then(() => array.push(0));
+  const promise = registerAction(1).then(() => array.push(1));
+  resolveAction(1);
+  resolveAction(0);
+
+  expect.assertions(1);
+  return promise.then(() => expect(array).toEqual([1, 0]));
+});

package/libraries/redux-offline/src/__tests__/send.js

@@ -0,0 +1,208 @@
+import send from '../send';
+import { busy, scheduleRetry } from '../actions';
+import defaultCommitAction from '../defaults/defaultCommit';
+import defaultRollbackAction from '../defaults/defaultRollback';
+import offlineActionTracker from '../offlineActionTracker';
+
+const DELAY = 1000;
+const completedMeta = {
+  meta: expect.objectContaining({ completed: expect.any(Boolean) })
+};
+
+function setup(partialConfig) {
+  const defaultConfig = {
+    effect: jest.fn(() => Promise.resolve()),
+    discard: () => false,
+    retry: () => DELAY,
+    defaultCommit: defaultCommitAction,
+    defaultRollback: defaultRollbackAction,
+    offlineActionTracker: offlineActionTracker.withoutPromises
+  };
+
+  return {
+    action: {
+      type: 'REQUEST',
+      meta: {
+        offline: {
+          effect: { url: '/api/resource', method: 'get' },
+          commit: { type: 'COMMIT' },
+          rollback: { type: 'ROLLBACK' }
+        },
+        transaction: 0
+      }
+    },
+    config: { ...defaultConfig, ...partialConfig },
+    dispatch: jest.fn()
+  };
+}
+
+test('dispatches busy action', () => {
+  const { action, config, dispatch } = setup();
+  const promise = send(action, dispatch, config);
+
+  expect.assertions(2);
+  return promise.then(() => {
+    expect(dispatch).toBeCalledWith(busy(true));
+    expect(dispatch).toHaveBeenLastCalledWith(busy(false));
+  });
+});
+
+test('requests resource using effects reconciler', () => {
+  const { action, config, dispatch } = setup();
+  send(action, dispatch, config);
+  expect(config.effect).toBeCalledWith(action.meta.offline.effect, action);
+});
+
+describe('when request succeeds', () => {
+  test('dispatches complete action', () => {
+    const effect = () => Promise.resolve();
+    const { action, config, dispatch } = setup({ effect });
+    const promise = send(action, dispatch, config);
+
+    const { commit } = action.meta.offline;
+    expect.assertions(2);
+    return promise.then(() => {
+      expect(dispatch).toBeCalledWith(expect.objectContaining(commit));
+      expect(dispatch).toBeCalledWith(expect.objectContaining(completedMeta));
+    });
+  });
+});
+
+describe('when request fails', () => {
+  test('dispatches schedule retry action', () => {
+    const effect = () => Promise.reject();
+    const { action, config, dispatch } = setup({ effect });
+    const promise = send(action, dispatch, config);
+
+    expect.assertions(1);
+    return promise.then(() => {
+      expect(dispatch).toBeCalledWith(scheduleRetry(DELAY));
+    });
+  });
+
+  test('dispatches complete action on discard', () => {
+    const effect = () => Promise.reject();
+    const discard = () => true;
+    const { action, config, dispatch } = setup({ effect, discard });
+    const promise = send(action, dispatch, config);
+
+    const { rollback } = action.meta.offline;
+    expect.assertions(2);
+    return promise.then(() => {
+      expect(dispatch).toBeCalledWith(expect.objectContaining(rollback));
+      expect(dispatch).toBeCalledWith(expect.objectContaining(completedMeta));
+    });
+  });
+
+  test('dispatches complete action with promised discard', () => {
+    const effect = () => Promise.reject();
+    const discard = () => Promise.resolve(true);
+    const { action, config, dispatch } = setup({ effect, discard });
+    const promise = send(action, dispatch, config);
+
+    const { rollback } = action.meta.offline;
+    expect.assertions(2);
+    return promise.then(() => {
+      expect(dispatch).toBeCalledWith(expect.objectContaining(rollback));
+      expect(dispatch).toBeCalledWith(expect.objectContaining(completedMeta));
+    });
+  });
+
+  test('dispatches complete action when discard throw an exception', () => {
+    const effect = () => Promise.reject();
+    const discard = () => {throw new Error};
+    const { action, config, dispatch } = setup({ effect, discard });
+    const promise = send(action, dispatch, config);
+
+    const { rollback } = action.meta.offline;
+    expect.assertions(2);
+    return promise.then(() => {
+      expect(dispatch).toBeCalledWith(expect.objectContaining(rollback));
+      expect(dispatch).toBeCalledWith(expect.objectContaining(completedMeta));
+    });
+  });
+});
+
+describe('when request succeeds and commit is undefined', () => {
+  test('dispatches default commit action', () => {
+    const effect = () => Promise.resolve();
+
+    const action = {
+      type: 'REQUEST',
+      meta: {
+        offline: {
+          effect: { type: 'MOCK' },
+        },
+      },
+    };
+
+    const { config, dispatch } = setup({ effect });
+
+    const promise = send(action, dispatch, config)
+
+    return promise.then(() => {
+      expect(dispatch).toBeCalledWith(expect.objectContaining(defaultCommitAction));
+      expect(dispatch).toBeCalledWith(expect.objectContaining(completedMeta));
+    });
+  });
+});
+
+describe('when request is to be discarded and rollback is undefined', () => {
+  test('dispatches default rollback action', () => {
+    const effect = () => Promise.reject();
+    const discard = () => true;
+
+    const action = {
+      type: 'REQUEST',
+      meta: {
+        offline: {
+          effect: { type: 'MOCK' },
+        },
+      },
+    };
+
+    const { config, dispatch } = setup({ effect, discard });
+
+    const promise = send(action, dispatch, config)
+
+    return promise.then(() => {
+      expect(dispatch).toBeCalledWith(expect.objectContaining(defaultRollbackAction));
+      expect(dispatch).toBeCalledWith(expect.objectContaining(completedMeta));
+    });
+  });
+});
+
+describe('offlineActionTracker', () => {
+  let trackerMock;
+  beforeEach(() => {
+    trackerMock = {
+      registerAction: () => {},
+      resolveAction: jest.fn(),
+      rejectAction: jest.fn()
+    }
+  })
+  test('resolves action on successful complete', () => {
+    const effect = () => Promise.resolve();
+    const { action, config, dispatch } = setup({ effect });
+    const promise = send(action, dispatch, {
+      ...config,
+      offlineActionTracker: trackerMock
+    });
+
+    expect.assertions(1);
+    return promise.then(() => expect(trackerMock.resolveAction).toBeCalled());
+  });
+
+  test('rejects action on failed complete', () => {
+    const effect = () => Promise.reject(new Error());
+    const discard = () => true;
+    const { action, config, dispatch } = setup({ effect, discard });
+    const promise = send(action, dispatch, {
+      ...config,
+      offlineActionTracker: trackerMock
+    });
+
+    expect.assertions(1);
+    return promise.then(() => expect(trackerMock.rejectAction).toBeCalled());
+  });
+});