redux#combineReducers JavaScript Examples

describe('handle comment saga error tests', () => {
  it('should handle comments error', () => {
    expectSaga(handleCommentsError, mockError)
      .withReducer(combineReducers({ commentsReducer, Snackbar }), {
        commentsReducer: {
          ...initialState,
          commentsLoading: true
        },
        Snackbar: mockSnackbarState
      })
      .put(setCommentsLoading(false))
      .put(setCommentError({ e: mockError }))
      .put(setSnackBarSeverity(snackBarError))
      .put(setSnackBarMessage(mockError.message))
      .put(setSnackBarStatus(true))
      .hasFinalState({
        commentsReducer: {
          ...initialState,
          commentsLoading: false,
          commentsError: { e: mockError }
        },
        Snackbar: {
          snackBarStatus: true,
          snackBarSeverity: snackBarError,
          snackBarMessage: mockError.message
        }
      })
      .run();
  });
});

rootReducer = combineReducers({
    navigation,
    auth,
    cards,
    games,
    news,
    toastr: toastrReducer,
    api,
    admin,
    user,
    account,
    lobby,
    stats
})

pagination = combineReducers({
  starredByUser: paginate({
    mapActionToKey: (action) => action.login,
    types: [
      ActionTypes.STARRED_REQUEST,
      ActionTypes.STARRED_SUCCESS,
      ActionTypes.STARRED_FAILURE,
    ],
  }),
  stargazersByRepo: paginate({
    mapActionToKey: (action) => action.fullName,
    types: [
      ActionTypes.STARGAZERS_REQUEST,
      ActionTypes.STARGAZERS_SUCCESS,
      ActionTypes.STARGAZERS_FAILURE,
    ],
  }),
})

mainReducer = combineReducers({
    projectList: projectListReducer,
    notifications: notificationReducer,
    parameters: parametersReducer,
    updateParameters: updateParametersReducer,
    uiFlags: uiFlagsReducer,
    profile: profileReducer,
    bom: bomReducer
})

store = createStore(
  combineReducers({
    Material: (_state = [], _action = '') => material,
    Model: (_state = [], _action = '') => model,
    Pattern: (_state = [], _action = '') => pattern,
    Constructor: (_state = [], _action = '') => constructor,
    Table: (_state = [], _action = '') => table
  })
)

describe('app', () => {
  it('should have the expected watchers', done =>
    expectSaga(app)
      .run({ silenceTimeout: true })
      .then(saga => {
        expect(saga).toMatchSnapshot();
        done();
      }));

  it('should have the switch menu saga', () =>
    expectSaga(switchMenu, { payload: { query: 'react' } })
      .withReducer(combineReducers({ ...rootReducer }))
      .put({
        type: ActionTypes.GITHUB_GET_REPOS,
        payload: { query: 'react' },
      })
      .run());
});

//mock redux

function renderWithRedux(
    ui,
    {
        store = createStore(
            combineReducers({
                user: reducer
            }),
            applyMiddleware(thunk, logger)
        )
    } = {}
) {
    
    return {
        ...render(<Provider store={store}>{<Router>{ui}</Router>}</Provider>),
        store
    };
}

allReducers = combineReducers({
  wallpaper: wallReducer,
  taskbar: taskReducer,
  desktop: deskReducer,
  startmenu: menuReducer,
  sidepane: paneReducer,
  widpane: widReducer,
  apps: appReducer,
  menus: menusReducer,
  globals: globalReducer,
  setting: settReducer,
  files: fileReducer
})

appReducer = combineReducers({
  users: usersReducer,
  posts: postsReducer,
  filter: filterReducer,
  loading: loadingReducer,
  error: errorReducer,
  session: sessionReducer,
  route: routerReducer,
})

rootReducer = combineReducers({
	form: formReducer,
	user: userReducer,
	store: storeReducer,
	cart: cartReducer,
	search: searchReducer,
	savedCart: savedCartReducer,
	dashboard: dashboardReducer,
	order: orderReducer,
	product: productReducer,
	orders: getOrdersReducer,
	onboard: onboardReducer,
	logo: logoReducer,
	color: colorReducer
})

rootReducer = combineReducers({
  settings: settingsReducer,
  list: listReducer,
  active: activeReducer,
  pendings: pendingsReducer,
  connected: connectionReducer,
  data: dataReducer,
  carburetor: carburetorReducer,
  symbols: symbolsReducer,
  prices: pricesReducer,
  tracked: trackedReducer
})

reducer = combineReducers({
	home: homeReducer,
	login: loginReducer,
	adapter: adapterReducer,
	header: headerReducer,
	projectList: projectListReducer,
	newProject: newProjectReducer,
	customAlert: customAlertReducer,
	project: projectReducer,
})

reducers = combineReducers({
  nav: require('./NavigationRedux').reducer,
  products: require('./ProductsRedux').reducer,
  category: require('./CategoryRedux').reducer,
  auth: require('./AuthRedux').reducer,
  session: require('./SessionRedux').reducer,
  invoice: require('./InvoiceRedux').reducer,
  order: require('./OrderRedux').reducer,
  confirm: require('./ConfirmPaymentRedux').reducer,
})

store = createStore(
	combineReducers({
		brokerConfigurations: brokerConfigurationsReducer,
		brokerConnections: brokerConnectionsReducer,
		proxyConnection: proxyConnectionReducer,
		groups: groupsReducer,
		license: licenseReducer,
		version: versionsReducer,
		roles: rolesReducer,
		settings: settingsReducer,
		webSocketConnections: webSocketConnectionsReducer,
		streams: streamsReducer,
		systemStatus: systemStatusReducer,
		topicTree: topicTreeReducer,
		clients: clientsReducer,
		userRoles: userRolesReducer,
		userProfile: userProfileReducer,
		users: usersReducer,
		clusters: clustersReducer,
		inspectClients: inspectClientsReducer,
		brokerLicense: brokerLicenseReducer,
		tests: testsReducer,
		// bridges: bridgesReducer
	})
)

export function makeRootReducer(asyncReducers) {
  return combineReducers({
    // Add sync reducers here
    firebase,
    firestore,
    notifications,
    location: locationReducer,
    ...asyncReducers
  })
}

rootReducer = combineReducers({
  user,
  signup,
  login,
  search,
  searchForm,
  wishlists,
  trips,
  message,
  home,
  modal,
  map,
  reservation,
  socket,
  mouseEvents,
})

rootReducer = combineReducers({
  users,
  alerts,
  apis,
  metas,
  operations,
  resources,
  applications
})

createReducer = history => {
  return combineReducers({
    router: connectRouter(history),
    signupReducer,
    browser: createResponsiveStateReducer({
      mobile: 320,
      tablet: 768,
      desktop: 1024
    })
  });
}

rootReducer = combineReducers({
    actionType: actionTypeReducer,
    plannerList: fetchPlannerReducer,
    appLoginPayload: appLoginReducer,
    addPlannerPayload: addPlannerReducer,
    firebasePlannerList: fetchFirebasePlannerReducer,
    googlePlannerList: fetchGoogleCalendarReducer,
    microsoftPlannerList: fetchMicrosoftPlannerReducer,
    fetchStudentsListPayload: fetchStudentsListReducer,
    loadFBAnnoucements: fetchFBAnnouncementReducer,
    fetchAnnouncementPayload: fetchAnnouncementReducer,
    grantDrivePermissionState: grantGoogleDrivePermissionReducer,
    uploadDriveAttachment: uploadFilesGoogleDriveReducer,
    plannerCallback: createPlannerReducer,
    createFirebasePlannerPayload: createFirebasePlannerReducer,
    createGooglePlannerPayload: createGooglePlannerReducer,
    createMicrosoftPlannerPayload: createMicrosoftPlannerReducer,
})

constructor(history, initialState = {}) {
    const reducer = combineReducers({
      ...reducers,
      apollo: ApolloClientSingleton.reducer(),
      routing: routerReducer
    });

    this.data = createStore(
      reducer,
      initialState,
      compose(
        applyMiddleware(
          routerMiddleware(history),
          ApolloClientSingleton.middleware(),
          ReduxThunk.withExtraArgument(ApolloClientSingleton)
        ),
        typeof window === "object" &&
          typeof window.devToolsExtension !== "undefined"
          ? window.devToolsExtension()
          : f => f
      )
    );
  }

rootReducer = combineReducers({
  Auth,
  ConnectWallet,
  HeaderOptions,
  Modal,
  Filter,
  Collections,
  Tokens,
  Price,
})

export default function configureStore(history, initialState) {
  const reducers = {
    form: formReducer,
    router: connectRouter(history),
    auth,
    home,
    provider,
    store
  };

  const middleware = [thunk, routerMiddleware(history)];

  const enhancers = [];
  // eslint-disable-next-line no-undef
  const isDevelopment = process.env.NODE_ENV === "development";

  if (
    isDevelopment &&
    typeof window !== "undefined" &&
    window.devToolsExtension
  ) {
    enhancers.push(window.devToolsExtension());
  }

  const rootReducer = combineReducers(reducers);

  return createStore(
    rootReducer,
    initialState,
    compose(
      applyMiddleware(...middleware),
      ...enhancers
    )
  );
}

makeStore = () => {
  const isServer = typeof window === 'undefined';

  if (isServer) {
    return createOwnStore(rootReducer);
  }

  const rootReducers = combineReducers({
    notification: notificationReducer
  });
  return createOwnStore(rootReducers);

}

rootReducer = combineReducers({
  
  // INSERT HERE YOUR CUSTOM REDUCERS
  LoginReducer,
  ProfileReducer,
  UserEditReducer,
  UserListReducer,

  // START COMBINE REDUCERS
	HomeReducer,
	CourseEditReducer,
	CourseListReducer,
	ExamEditReducer,
	ExamListReducer,
	StudentEditReducer,
	StudentListReducer,
	TeacherEditReducer,
	TeacherListReducer,
 // END COMBINE REDUCERS

})

MonsterReducer = combineReducers({
  auth: AuthReducer,
  courses: CoursesReducer,
  tracks: TracksReducer,
  user: UserReducer,
  tasks: TaskReducer,
  stages: StagesReducer,
  API: APIReducer,
})

pagination = combineReducers({
  starredByUser: paginate({
    mapActionToKey: (action) => action.login,
    types: [
      ActionTypes.STARRED_REQUEST,
      ActionTypes.STARRED_SUCCESS,
      ActionTypes.STARRED_FAILURE,
    ],
  }),
  stargazersByRepo: paginate({
    mapActionToKey: (action) => action.fullName,
    types: [
      ActionTypes.STARGAZERS_REQUEST,
      ActionTypes.STARGAZERS_SUCCESS,
      ActionTypes.STARGAZERS_FAILURE,
    ],
  }),
})

/**
 * Merges the main reducer with the router state and dynamically injected reducers
 */
export default function createReducer(injectedReducers = {}) {
  const rootReducer = combineReducers({
    global: globalReducer,
    language: languageProviderReducer,
    router: connectRouter(history),
    ...injectedReducers,
  });

  return rootReducer;
}

// Root reducer
export default function createRootReducer(history: HashHistory) {
  return combineReducers<{}, *>({
    router: connectRouter(history),
    window: windowReducer,
    monaco: monacoReducer,
    preferences: preferencesReducer,
    contextEvaluation: contextEvaluationReducer
  });
}

rootReducer = (history) =>
  combineReducers({
    router: connectRouter(history),
    exchange: ExchangeInfoReducer,
    tabs: TabsReducer,
    tradePanel: TradePanelReducer,
    layoutManager: LayoutManagerReducer,
    liquidityMining: LiquidityMiningReducer,
    currentMarket: CurrentMarketReducer,
    orderBook: OrderBookReducer,
    tradeHistory: TradeHistoryReducer,
    ticker: TickerReducer,
    modalManager: ModalManagerReducer,
    balances: MyAccountPageReducer,
    myOrders: MyOrdersReducer,
    myOrderPage: MyOrderPageReducer,
    metaMask: MetaMaskReducer,
    walletConnect: WalletConnectReducer,
    walletLink: WalletLinkReducer,
    mewConnect: MewConnectReducer,
    authereum: AuthereumReducer,
    dexAccount: DexAccountReducer,
    nonce: NonceReducer,
    gasPrice: GasPriceReducer,
    legalPrice: LegalPriceReducer,
    commissionReward: CommissionRewardReducer,
    userPreferences: UserPreferenceManagerReducer,
    notifyCenter: NotifyCenterReducer,
  })