export function configureStore(initialState = {}, debug = IS_DEVELOPMENT) {
const envMiddlewares = {
dev: [thunk.withExtraArgument(axios), routerMiddleware(history)],
prod: [thunk.withExtraArgument(axios), routerMiddleware(history)],
}
const storeEnhancers = debug
? compose(
applyMiddleware(...envMiddlewares.dev),
window.devToolsExtension ? window.devToolsExtension() : f => f
)
: compose(applyMiddleware(...envMiddlewares.prod))
const store = createStore(connectRouter(history)(rootReducer), initialState, storeEnhancers)
if (module.hot) {
// Enable Webpack hot module replacement for reducers
module.hot.accept('./redux', () => {
const nextRootReducer = require('./redux/index').rootReducer // eslint-disable-line
store.replaceReducer(nextRootReducer)
})
}
return store
}
createStore(rootReducer, initialState = {}) {
const middlewares = [
thunk.withExtraArgument({ app: this }),
createAppendActionMiddleware({
key: 'appName',
value: this.getOption('name')
})
];
if (process.env.NODE_ENV !== 'production') {
const createLogger = require('redux-logger'); // eslint-disable-line
middlewares.push(createLogger());
}
this.options.store = createStore(
rootReducer,
initialState,
compose(
applyMiddleware(...middlewares)
)
);
return this.options.store;
}
export default function configureStore(initialState) {
const store = createStore(rootReducer, initialState,
applyMiddleware(thunk.withExtraArgument({room, socketWrapper}))
);
room.setDispatch(store.dispatch);
socketWrapper.setDispatch(store.dispatch);
return store;
}
describe('Videos actions', () => {
// Test async action
const middleware = [thunk.withExtraArgument(mockApi)];
const mockStore = configureMockStore(middleware);
it('should create LOAD_VIDEOS_SUCCESS when loading videos', (done) => {
const expectedActions = {
type: types.LOAD_VIDEOS_SUCCESS,
videos: [{_id: '1', name: 'video1', ratings: [1,2,3]}]
};
const store = mockStore({videos: []}, [expectedActions], done);
store.dispatch(videoActions.loadVideos({skip: 5, limit: 5})).then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(types.LOAD_VIDEOS_SUCCESS);
expect(actions[0].videos.length).toEqual(1);
expect(actions[0].videos[0].name).toEqual('video1');
done();
});
});
it('should create VIDEO_SUCCESS when loading single video', (done) => {
const expectedActions = {
type: types.VIDEO_SUCCESS,
video: {_id: '1', name: 'video1'}
};
const store = mockStore({videos: []}, [expectedActions], done);
store.dispatch(videoActions.getVideo(1)).then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(types.VIDEO_SUCCESS);
expect(actions[0].video.name).toEqual('video1');
done();
});
});
it('should create RATING_SUCCESS when rate a video', (done) => {
const expectedActions = {
type: types.RATING_SUCCESS,
video: {_id: '1', name: 'video1', ratings: [1,2,3]}
};
const store = mockStore({videos: []}, [expectedActions], done);
store.dispatch(videoActions.clickStar(1, 3)).then(() => {
const actions = store.getActions();
expect(actions[0].type).toEqual(types.RATING_SUCCESS);
expect(actions[0].video.name).toEqual('video1');
expect(actions[0].video.ratings.length).toEqual(3);
done();
});
});
});
export const licenseManagementStore = (initialState = {}, services = {}) => {
const enhancers = [ applyMiddleware(thunk.withExtraArgument(services)) ];
window.__REDUX_DEVTOOLS_EXTENSION__ && enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__());
return createStore(
licenseManagement,
initialState,
compose(...enhancers)
);
};
export default function getStore(initialState, {cookies, request}) {
return createStore(
reducer,
initialState,
compose(
applyMiddleware(
thunk.withExtraArgument({cookies, request})
),
typeof window === 'object' && typeof window.devToolsExtension !== 'undefined' ? window.devToolsExtension() : f => f
)
);
}
const createComponent = (services, dispatch = sinon.spy()) => {
const store = createStore(
reducers,
applyMiddleware(thunk.withExtraArgument(services))
);
return (
<Provider store={store}>
<AddEntity dispatch={dispatch} />
</Provider>
);
};
const createComponent = () => {
const services = { fetchEntities: () => Promise.resolve([]) };
const store = createStore(
reducers,
applyMiddleware(thunk.withExtraArgument(services))
);
return (
<Provider store={store}>
<Routes />
</Provider>
);
};
const configureStore = initialState => {
let middlewares = [thunk.withExtraArgument(api)];
if (process.env.NODE_ENV !== 'production') {
middlewares = [...middlewares, logger];
}
const store = createStore(
reducers,
initialState,
applyMiddleware(...middlewares)
);
return store;
};
export default function configureStore(initialState, helpersConfig) {
const helpers = createHelpers(helpersConfig);
const middleware = [thunk.withExtraArgument(helpers)];
let enhancer;
if (__DEV__) {
if (process.env.BROWSER) {
const createLogger = require('redux-logger');
middleware.push(createLogger({
collapsed: true,
}));
} else {
// Server side redux action logger
middleware.push(store => next => action => { // eslint-disable-line no-unused-vars
//const payload = JSON.stringify(action.payload);
//console.log(` * ${action.type}: ${payload}`); // eslint-disable-line no-console
return next(action);
});
}
// https://github.com/zalmoxisus/redux-devtools-extension#redux-devtools-extension
let devToolsExtension = f => f;
if (process.env.BROWSER && window.devToolsExtension) {
devToolsExtension = window.devToolsExtension();
}
enhancer = compose(
applyMiddleware(...middleware),
devToolsExtension,
);
} else {
enhancer = applyMiddleware(...middleware);
}
// See https://github.com/rackt/redux/releases/tag/v3.1.0
const store = createStore(rootReducer, Immutable.fromJS(initialState), enhancer);
// Hot reload reducers (requires Webpack or Browserify HMR to be enabled)
if (__DEV__ && module.hot) {
module.hot.accept('../reducers', () =>
store.replaceReducer(require('../reducers').default)
);
}
return store;
}
createStore(rootReducer, initialState = {}) {
this.options.store = createStore(
rootReducer,
initialState,
compose(
applyMiddleware(
thunk.withExtraArgument({ app: this }),
createAppendActionMiddleware({
key: 'appName',
value: this.getOption('name')
}),
createLogger() // @TODO: load it in DEV environment only
)
)
);
return this.options.store;
}
export default () => {
// ======================================================
// Middleware Configuration
// ======================================================
const middleware = [thunk.withExtraArgument(socket)];
// ======================================================
// Store Enhancers
// ======================================================
const enhancers = [responsiveStoreEnhancer];
let composeEnhancers = compose;
if (__DEV__) {
const composeWithDevToolsExtension = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__;
if (typeof composeWithDevToolsExtension === 'function') {
composeEnhancers = composeWithDevToolsExtension
}
}
// ======================================================
// Store Instantiation and HMR Setup
// ======================================================
const store = createStore(
makeRootReducer,
composeEnhancers(
applyMiddleware(...middleware),
...enhancers
)
);
store.asyncReducers = {};
// To unsubscribe, invoke `store.unsubscribeHistory()` anytime
store.unsubscribeHistory = browserHistory.listen(updateLocation(store));
if (module.hot) {
module.hot.accept('./mainReducer', () => {
const reducers = require('./mainReducer').default;
store.replaceReducer(reducers(store.asyncReducers))
})
}
return store
}
export default (initialState = { firebase: {} }) => {
// initialize firebase
const firebase = RNFirebase.initializeApp(reactNativeFirebaseConfig);
const middleware = [
// make getFirebase available in third argument of thunks
thunk.withExtraArgument({ getFirebase }),
];
const store = createStore(
makeRootReducer(),
initialState, // initial state
compose(
reactReduxFirebase(firebase, reduxFirebaseConfig), // pass initialized react-native-firebase app instance
applyMiddleware(...middleware)
)
)
return store
}
export default function storeFactory(diContainer) {
const initialState = {
urlShortener: Immutable.fromJS({
isLoading: false,
inputUrl: '',
outputUrl: null,
error: null
})
};
let middlewares = [
thunk.withExtraArgument(diContainer),
routerMiddleware(diContainer.history)
];
middlewares = compose(
applyMiddleware(...middlewares),
window.devToolsExtension ? window.devToolsExtension() : (f) => f
);
return createStore(reducer, initialState, middlewares);
}
export default function configureStore(initialState, config) {
const helpers = createHelpers(config);
const { apolloClient } = config;
const middleware = [
thunk.withExtraArgument(helpers),
apolloClient.middleware(),
];
let enhancer;
if (__DEV__) {
middleware.push(createLogger());
// https://github.com/zalmoxisus/redux-devtools-extension#redux-devtools-extension
let devToolsExtension = f => f;
if (process.env.BROWSER && window.devToolsExtension) {
devToolsExtension = window.devToolsExtension();
}
enhancer = compose(applyMiddleware(...middleware), devToolsExtension);
} else {
enhancer = applyMiddleware(...middleware);
}
const rootReducer = createRootReducer({
apolloClient,
});
// See https://github.com/rackt/redux/releases/tag/v3.1.0
const store = createStore(rootReducer, initialState, enhancer);
// Hot reload reducers (requires Webpack or Browserify HMR to be enabled)
if (__DEV__ && module.hot) {
module.hot.accept('../reducers', () =>
// Don't forget to remove `()` if you change reducers back to normal rootReducer.
// eslint-disable-next-line global-require
store.replaceReducer(require('../reducers').default({ apolloClient })),
);
}
return store;
}
const configureStore = (initialState) => {
const store = createStore(
rootReducer,
initialState,
applyMiddleware(
thunk.withExtraArgument({ axios }),
routerMiddleware(browserHistory)
)
);
if (module.hot) {
// Enable Webpack hot module replacement for reducers
module.hot.accept('../reducers', () => {
const nextRootReducer = require('../reducers').default;
store.replaceReducer(nextRootReducer);
});
}
return store;
};
export const createMockStore = (initialState, mapOfParamsForCallback) => {
const socketMock = requestMock(mapOfParamsForCallback);
const mockStoreFactory = configureMockStore([thunk.withExtraArgument(socketMock)]);
const mockStore = mockStoreFactory(initialState);
mockStore.socketCalledWith = (...expectedArgs) => {
const matchedCalls = socketMock.calls.filter(calledArgs =>
deepEqual(calledArgs, expectedArgs));
if (matchedCalls.length === 0) {
throw new Error("socketio request not called with args " + expectedArgs);
}
};
mockStore.socketNotCalled = () => {
if (socketMock.calls.length > 0) {
throw new Error("socketio request should never be called, but it was called with args " + socketMock.calls);
}
};
mockStore.socketCalledWith = mockStore.socketCalledWith.bind(mockStore);
mockStore.socketNotCalled = mockStore.socketNotCalled.bind(mockStore);
return mockStore;
};
app.get('*', asyncCatch(async (req: $Request, res) => {
const store: Store<State, BatchedAction> = createStore(
reducer,
defaultState(stores.positionEligibilityStore),
applyMiddleware(batcher, thunk.withExtraArgument(api)),
);
await store.dispatch(selectLoggedInUserId(readAuthTokenFromCookies(req)));
await store.dispatch(translateUrl(req.path, req.query) || throw404(req.path));
const jsBundleName: string = bundles.js_bundle_name || 'public/bundle.js';
const cssBundleName: string = bundles.css_bundle_name || 'public/bundle.css';
res.send(
layout(
getTitle(store.getState()),
renderToString(<Provider store={store}><App /></Provider>),
store.getState(),
jsBundleName,
cssBundleName,
),
);
}));
export function configureStore (initialState) {
let store = createStore(createReducer(), initialState, compose(
applyMiddleware(
thunk.withExtraArgument({ axios })
),
process.env.NODE_ENV === 'development' &&
typeof window === 'object' &&
typeof window.devToolsExtension !== 'undefined'
? window.devToolsExtension()
: f => f
))
store.asyncReducers = {}
if (process.env.NODE_ENV === 'development') {
if (module.hot) {
module.hot.accept('./createReducer', () => store.replaceReducer(require('./createReducer').default))
}
}
return store
}
import { composeWithDevTools } from 'redux-devtools-extension';
import project from 'reducers/project';
import projectBoard from 'reducers/projectBoard';
import users from 'reducers/users';
import stories from 'reducers/stories';
import pastIterations from 'reducers/pastIterations';
import * as Story from '../models/beta/story';
import * as Task from '../models/beta/task'
import * as ProjectBoard from '../models/beta/projectBoard';
import * as Note from '../models/beta/note';
const dependencies = { Story, ProjectBoard, Note, Task };
const reducer = combineReducers({
project,
projectBoard,
users,
stories,
pastIterations
});
const store = createStore(
reducer, composeWithDevTools(
applyMiddleware(
thunk.withExtraArgument(dependencies)
)
)
);
export default store;
import promiseMiddleware from 'redux-promise';
import thunkMiddleware from 'redux-thunk';
import loggerMiddleware from './middleware/loggerMiddleware';
import { apolloClient } from './apollo';
// define store middlewares as an array
export default [
promiseMiddleware,
thunkMiddleware.withExtraArgument(),
apolloClient.middleware(),
loggerMiddleware,
];
import api from './api';
import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';
import reducer from './reducers';
export default createStore(
reducer,
applyMiddleware(thunk.withExtraArgument(api))
);
describe('modules/monod', () => {
const middlewares = [thunk.withExtraArgument({ db: dbMock })];
const mockStore = configureMockStore(middlewares);
const secret = 'secret';
beforeEach(() => {
dbMock.reset();
});
it('should return the initial state', () => {
const state = reducer(undefined, {});
expect(state).to.have.all.keys([
'offline',
]);
});
it('can flag the app as online', () => {
const state = reducer(undefined, actions.isOnline());
expect(state.offline).to.be.false;
});
it('can flag the app as offline', () => {
const state = reducer(undefined, actions.isOffline());
expect(state.offline).to.be.true;
});
describe('load()', () => {
it('should dispatch documents.LOAD_DEFAULT when no document id supplied', () => {
const store = mockStore();
const expectedActions = [
{ type: documents.LOAD_DEFAULT },
];
store.dispatch(actions.load());
expect(store.getActions()).to.eql(expectedActions);
});
it('should look into the local storage first', () => {
const store = mockStore();
const id = '123';
const content = 'foo';
dbMock.addDocument(id, encrypt(content, secret));
return store
.dispatch(actions.load(id, secret, dbMock))
.then(() => {
const triggeredActions = store.getActions();
// there is also the synchronize() action that is dispatched
expect(triggeredActions).to.have.length(2);
expect(triggeredActions[0].type).to.equal(documents.LOAD_SUCCESS);
expect(triggeredActions[0].document.get('uuid')).to.equal(id);
expect(triggeredActions[0].document.get('content')).to.equal(content);
});
});
it('should notify user when decryption failed', () => {
const store = mockStore();
const id = '123';
const content = 'foo';
dbMock.addDocument(id, encrypt(content, secret));
return store
.dispatch(actions.load(id, 'bad-secret', dbMock)) // decryption will fail
.then(() => {
const triggeredActions = store.getActions();
expect(triggeredActions).to.have.length(2);
expect(triggeredActions[0].type).to.equal(NOTIFY);
expect(triggeredActions[1].type).to.equal(documents.LOAD_DEFAULT);
expect(dbMock.nbGetItemCall).to.equal(1);
});
});
describe('(API call)', () => {
beforeEach(() => {
fauxJax.install();
});
afterEach(() => {
fauxJax.restore();
});
it('should fetch the server when not found locally', () => {
const id = '456';
const content = 'hello';
const encrypted = encrypt(content, secret);
fauxJax.on('request', (request) => {
request.respond(
200, { 'Content-Type': 'application/json' },
JSON.stringify({
uuid: id,
content: encrypted,
last_modified: Date.now(),
})
);
});
const store = mockStore();
return store
.dispatch(actions.load(id, secret, dbMock))
.then(() => {
const triggeredActions = store.getActions();
expect(triggeredActions).to.have.length(3);
expect(triggeredActions[0].type).to.equal(actions.IS_ONLINE);
expect(triggeredActions[1].type).to.equal(documents.LOAD_SUCCESS);
expect(triggeredActions[1].document.get('uuid')).to.equal(id);
// 3rd action is SYNCHRONIZE
});
});
it('deals with 404 error when document is not stored locally', () => {
const id = '456';
fauxJax.on('request', (request) => {
request.respond(
404, { 'Content-Type': 'application/json' }
);
});
const store = mockStore();
return store
.dispatch(actions.load(id, secret, dbMock))
.then(() => {
const triggeredActions = store.getActions();
expect(triggeredActions).to.have.length(2);
expect(triggeredActions[0].type).to.equal(NOTIFY);
expect(triggeredActions[1].type).to.equal(documents.LOAD_DEFAULT);
});
});
});
it('should notify user when server is unreachable', () => {
const id = 'not-in-local-db';
const store = mockStore();
return store
.dispatch(actions.load(id, secret, dbMock))
.then(() => {
const triggeredActions = store.getActions();
expect(triggeredActions).to.have.length(3);
expect(triggeredActions[0].type).to.equal(actions.IS_OFFLINE);
expect(triggeredActions[1].type).to.equal(NOTIFY);
expect(triggeredActions[2].type).to.equal(documents.LOAD_DEFAULT);
});
});
});
});
export default (initialState = {}) => {
// ======================================================
// Redux + Firebase Config (react-redux-firebase & redux-firestore)
// ======================================================
const defaultRRFConfig = {
userProfile: 'users', // root that user profiles are written to
updateProfileOnLogin: false, // enable/disable updating of profile on login
presence: 'presence', // list currently online users under "presence" path in RTDB
sessions: null, // Skip storing of sessions
enableLogging: false, // enable/disable Firebase Database Logging
useFirestoreForProfile: true, // Save profile to Firestore instead of Real Time Database
useFirestoreForStorageMeta: true, // Metadata associated with storage file uploads goes to Firestore
onAuthStateChanged: (auth, firebaseInstance, dispatch) => {
if (auth) {
// Set auth within error handler
setErrorUser(auth)
// Initalize messaging with dispatch
initializeMessaging(dispatch)
// Set auth within analytics
setAnalyticsUser(auth)
}
}
}
// Combine default config with overrides if they exist (set within .firebaserc)
const combinedConfig = rrfConfig
? { ...defaultRRFConfig, ...rrfConfig }
: defaultRRFConfig
// ======================================================
// Store Enhancers
// ======================================================
const enhancers = []
if (env === 'dev') {
const devToolsExtension = window.__REDUX_DEVTOOLS_EXTENSION__
if (typeof devToolsExtension === 'function') {
enhancers.push(devToolsExtension())
}
}
// ======================================================
// Middleware Configuration
// ======================================================
const middleware = [
thunk.withExtraArgument(getFirebase)
// This is where you add other middleware like redux-observable
]
// ======================================================
// Firebase Initialization
// ======================================================
firebase.initializeApp(fbConfig)
// ======================================================
// Store Instantiation and HMR Setup
// ======================================================
const store = createStore(
makeRootReducer(),
initialState,
compose(
applyMiddleware(...middleware),
reduxFirestore(firebase),
reactReduxFirebase(firebase, combinedConfig),
...enhancers
)
)
store.asyncReducers = {}
if (module.hot) {
module.hot.accept('./reducers', () => {
const reducers = require('./reducers').default // eslint-disable-line global-require
store.replaceReducer(reducers(store.asyncReducers))
})
}
return store
}
import * as schema from '../api/schema';
import api from '../api';
import reducer from './reducer';
import thunk from 'redux-thunk';
import { applyMiddleware, createStore } from 'redux';
export default createStore(reducer, applyMiddleware(thunk.withExtraArgument({ api, schema })));
export default (initialState = {}) => {
// ======================================================
// Redux + Firebase Config (react-redux-firebase & redux-firestore)
// ======================================================
const defaultRRFConfig = {
userProfile: 'users', // root that user profiles are written to
updateProfileOnLogin: false, // enable/disable updating of profile on login
presence: 'presence', // list currently online users under "presence" path in RTDB
sessions: null, // Skip storing of sessions
enableLogging: false // enable/disable Firebase Database Logging
// profileDecorator: (userData) => ({ email: userData.email }) // customize format of user profile
}
// Combine default config with overrides if they exist (set within .firebaserc)
const combinedConfig = rrfConfig
? { ...defaultRRFConfig, ...rrfConfig }
: defaultRRFConfig
// ======================================================
// Store Enhancers
// ======================================================
const enhancers = []
if (env === 'local') {
const devToolsExtension = window.devToolsExtension
if (typeof devToolsExtension === 'function') {
enhancers.push(devToolsExtension())
}
}
// ======================================================
// Middleware Configuration
// ======================================================
const middleware = [
thunk.withExtraArgument(getFirebase)
// This is where you add other middleware like redux-observable
]
// ======================================================
// Firebase Initialization
// ======================================================
firebase.initializeApp(fbConfig)
// ======================================================
// Store Instantiation and HMR Setup
// ======================================================
const store = createStore(
makeRootReducer(),
initialState,
compose(
applyMiddleware(...middleware),
reactReduxFirebase(firebase, combinedConfig),
...enhancers
)
)
store.asyncReducers = {}
if (module.hot) {
module.hot.accept('./reducers', () => {
const reducers = require('./reducers').default
store.replaceReducer(reducers(store.asyncReducers))
})
}
return store
}
import { createStore, applyMiddleware } from 'redux';
import thunkMiddleware from 'redux-thunk';
import rootReducer from './reducers';
import {batchActions, enableBatching} from 'redux-batched-actions';
import axios from 'axios';
let api = axios.create({
baseURL: 'http://api.edtr.dev/api/v1',
timeout: 30000
})
const createStoreWithMiddleware = applyMiddleware(
thunkMiddleware.withExtraArgument({ api, batchActions })
)(createStore);
export default function configureStore(initialState = {}) {
const store = createStoreWithMiddleware(enableBatching(rootReducer), initialState);
return store;
}
return state;
}
}
let unauthorized = false;
function defaultErrorHandler(err, res) {
if(res.unauthorized) {
unauthorized = true;
}
}
const request = new ReduxThunkRequest({baseUrl: 'http://localhost:8080', defaultErrorHandler});
const store = createStore(reducer, applyMiddleware(thunk.withExtraArgument({request})));
describe('Test', function() {
beforeEach(function() {
store.dispatch(reset());
unauthorized = false;
request.reset();
});
it('Set value {waitServer : false}', function (done) {
store.dispatch((dispatch, getState, {request}) => {
const r = request('/').then(({value}) => dispatch({
type : UPDATE_VALUE,
value
}));
assert(false === request.isWaited());
}
}
const loggerMiddleware = createLogger({
collapsed: true,
predicate: predicate,
logger: logger,
// We're turning off all colors here because the formatting chars obscure the
// content server-side.
colors: {
title: false,
prevState: false,
action: false,
nextState: false,
error: false
}
});
const store = createStore(
appReducer,
hydrateStore(),
applyMiddleware(
thunkMiddleware.withExtraArgument({ getIntl }),
loggerMiddleware
)
);
logger.setReduxDispatch(store.dispatch);
export default store;
import configureMockStore from 'redux-mock-store';
import reduxThunk from 'redux-thunk';
import { middleware as reduxPack, KEY } from 'redux-pack';
import api from './api';
export const makeReduxPackAction = (lifecycle, { type, payload, meta = {} }) => ({
type,
payload,
meta: {
...meta,
[KEY.LIFECYCLE]: lifecycle,
},
});
export const removeReduxPackTransaction = (action) => ({
...action,
meta: {
...action.meta,
'redux-pack/TRANSACTION': undefined,
},
});
export const mockStore = configureMockStore([
reduxThunk.withExtraArgument({ api }),
reduxPack,
]);