static updateContent(content: string): Promise<FluxAction> {
   return Flux.dispatch({content, type: AppConstants.UPDATE_CONTENT});
 }

 beforeAll(async () => {
   await Flux.init({
     stores: [TestStore]
   });
 });

export const createArkhamStore = (configuration: ArkhamReduxStoreType): Store<any> => {
  const {
    arkhamMiddleware: middleware = [],
    flux,
    reducers,
    sagas,
    statePath = '',
    reduxMiddleware = [],
    devTools
  } = configuration;

  // Save initial state tree
  const {storage} = Flux.getOptions();
  let store: Store;

  if(storage) {
    const cachedState = Flux.getState(statePath);

    if(devTools) {
      store = createStore(
        devTools(reducers, cachedState),
        applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux)));
    } else {
      store = createStore(
        reducers,
        cachedState,
        applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux)));
    }

    if(cachedState === undefined) {
      const stateTree = store.getState();
      const updatedState = isPlainObject(stateTree) ? merge(stateTree, cachedState) : stateTree;
      Flux.setState(statePath, updatedState);
    }
  } else {
    store = createStore(
      reducers,
      devTools,
      applyMiddleware(...reduxMiddleware, arkhamMiddleware(statePath, flux))
    );

    Flux.setState(statePath, store.getState());
  }

  // If saga is being added, run.
  reduxMiddleware.every((item: any) => {
    if(sagas) {
      item.run(sagas);
      return false;
    }

    return true;
  });

  // Add redux middleware to Arkham to relay dispatches to Redux
  middleware.push(new ReduxMiddleware(store, statePath));

  // Initialize ArkhamJS
  Flux.addMiddleware(middleware);

  return store;
};

 listeners.forEach(({handler, type}: FluxActionListener) => {
   Flux.off(type, handler);
 });