@tramvai/test-mocks 2.28.0 → 2.31.0

package/README.md

@@ -27,14 +27,41 @@ store.dispatch('event');
 
 #### Initial State
 
+Pass required stores, initial state will be applied automatically:
+
+```ts
+import { createMockStore } from '@tramvai/test-mocks';
+
+const reducer = createReducer('test', 'value');
+
+const store = createMockStore({ stores: [reducer] });
+
+const state = store.getState(); // { test: 'value' }
+```
+
+Or pass just initialState, fake reducers will be created under the hood:
+
 ```ts
 import { createMockStore } from '@tramvai/test-mocks';
 
 const initialState = { a: 1, b: 2 };
-const reducerC = createReducer('c', 3);
-const store = createMockStore({ stores: [reducerC], initialState });
 
-const state = store.getState();
+const store = createMockStore({ initialState });
+
+const state = store.getState(); // { a: 1, b: 2 }
+```
+
+Also you can change initial state of passed reducer:
+
+```ts
+import { createMockStore } from '@tramvai/test-mocks';
+
+const initialState = { test: 'modified' };
+const reducer = createReducer('test', 'default');
+
+const store = createMockStore({ stores: [reducer], initialState });
+
+const state = store.getState(); // { test: 'modified' }
 ```
 
 <p>

package/lib/CommonTestModule.d.ts

@@ -0,0 +1,16 @@
+import type { Provider } from '@tramvai/core';
+import type { Cache } from '@tramvai/tokens-common';
+import { createMockEnvManager } from './envManager';
+import { createMockCookieManager } from './cookie';
+declare type CommonModuleOptions = {
+    env?: Parameters<typeof createMockEnvManager>[0];
+    cookies?: Parameters<typeof createMockCookieManager>[0];
+    onCacheCreated?: (cache: Cache) => void;
+};
+export declare class CommonTestModule {
+    static forRoot(options: CommonModuleOptions): {
+        providers: Provider<any, any>[];
+        mainModule: typeof CommonTestModule;
+    };
+}
+export {};

package/lib/context.d.ts

@@ -16,8 +16,9 @@ declare type Options = OptionsDi & OptionsStore & {
  * @param initialState - начальное состояние, которое будет передано в createMockStore если явно не передавать store
  * @param store - глобальный стор приложения, по умолчанию используется результат createMockStore
  * @param providers - список провайдеров, которые будут переданы в createMockDi если явно не передавать di
+ * @param modules - список модулей, провайдеры которых будут добавлены в создаваемый di-контейнер
  * @param stores - di-контейнер, по умолчанию используется результат createMockDi
  * @param useTramvaiActionsConditionals - добавляет встроенные в tramvai actions conditionals
  */
-export declare const createMockContext: ({ stores, initialState, store, providers, di, useTramvaiActionsConditionals, }?: Options) => typeof CONTEXT_TOKEN;
+export declare const createMockContext: ({ stores, initialState, store, providers, modules, di, useTramvaiActionsConditionals, }?: Options) => typeof CONTEXT_TOKEN;
 export {};

package/lib/index.d.ts

@@ -8,3 +8,4 @@ export { createMockRequestManager } from './requestManager';
 export { createMockAppInfo } from './appInfo';
 export { createMockCache } from './cache';
 export { createMockCookieManager } from './cookie';
+export { CommonTestModule } from './CommonTestModule';

package/lib/index.es.js

@@ -1,14 +1,15 @@
-import { STORE_TOKEN, ACTION_EXECUTION_TOKEN, ACTION_CONDITIONALS, EXECUTION_CONTEXT_MANAGER_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
-import { alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser, ExecutionContextManager, ActionExecution, createConsumerContext } from '@tramvai/module-common';
+import { STORE_TOKEN, ACTION_EXECUTION_TOKEN, ACTION_CONDITIONALS, EXECUTION_CONTEXT_MANAGER_TOKEN, CONTEXT_TOKEN, ENV_MANAGER_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, CREATE_CACHE_TOKEN } from '@tramvai/tokens-common';
+import { alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser, ExecutionContextManager, ActionExecution, createConsumerContext, COOKIE_MANAGER_TOKEN } from '@tramvai/module-common';
 import { PubSub } from '@tinkoff/pubsub';
 import { createContainer, DI_TOKEN } from '@tinkoff/dippy';
 import keys from '@tinkoff/utils/object/keys';
 import difference from '@tinkoff/utils/array/difference';
 import { createReducer, createDispatcher } from '@tramvai/state';
-import { walkOfModules, getModuleParameters } from '@tramvai/core';
+import { walkOfModules, getModuleParameters, Module, provide, APP_INFO_TOKEN } from '@tramvai/core';
 import { AbstractRouter } from '@tinkoff/router';
 import { parse } from '@tinkoff/url';
 import noop from '@tinkoff/utils/function/noop';
+import { __decorate } from 'tslib';
 
 /**
  * Creates mock for a global app store
@@ -65,10 +66,11 @@ const createMockDi = ({ modules = [], providers = [] } = {}) => {
  * @param initialState - начальное состояние, которое будет передано в createMockStore если явно не передавать store
  * @param store - глобальный стор приложения, по умолчанию используется результат createMockStore
  * @param providers - список провайдеров, которые будут переданы в createMockDi если явно не передавать di
+ * @param modules - список модулей, провайдеры которых будут добавлены в создаваемый di-контейнер
  * @param stores - di-контейнер, по умолчанию используется результат createMockDi
  * @param useTramvaiActionsConditionals - добавляет встроенные в tramvai actions conditionals
  */
-const createMockContext = ({ stores, initialState, store = createMockStore({ stores, initialState }), providers, di = createMockDi({ providers }), useTramvaiActionsConditionals = false, } = {}) => {
+const createMockContext = ({ stores, initialState, store = createMockStore({ stores, initialState }), providers, modules, di = createMockDi({ providers, modules }), useTramvaiActionsConditionals = false, } = {}) => {
     const { __dispatcherContext__: dispatcherContext } = store; // хак для получения уже созданного dispatcherContext в сторе
     const pubsub = new PubSub();
     di.register({
@@ -246,4 +248,72 @@ const createMockCookieManager = (entries = {}) => {
     };
 };
 
-export { createMockAppInfo, createMockCache, createMockContext, createMockCookieManager, createMockDi, createMockEnvManager, createMockLogger, createMockRequestManager, createMockRouter, createMockStore };
+var CommonTestModule_1;
+let CommonTestModule = CommonTestModule_1 = class CommonTestModule {
+    static forRoot(options) {
+        const providers = [];
+        const { env, cookies, onCacheCreated } = options;
+        if (env) {
+            providers.push({
+                provide: ENV_MANAGER_TOKEN,
+                useValue: createMockEnvManager(env),
+            });
+        }
+        if (cookies) {
+            providers.push({
+                provide: COOKIE_MANAGER_TOKEN,
+                useValue: createMockCookieManager(cookies),
+            });
+        }
+        if (onCacheCreated) {
+            providers.push({
+                provide: CREATE_CACHE_TOKEN,
+                useValue: () => {
+                    const cache = createMockCache();
+                    onCacheCreated(cache);
+                    return cache;
+                },
+            });
+        }
+        return {
+            providers,
+            mainModule: CommonTestModule_1,
+        };
+    }
+};
+CommonTestModule = CommonTestModule_1 = __decorate([
+    Module({
+        providers: [
+            provide({
+                provide: ENV_MANAGER_TOKEN,
+                useValue: createMockEnvManager(),
+            }),
+            provide({
+                provide: LOGGER_TOKEN,
+                useValue: createMockLogger(),
+            }),
+            provide({
+                provide: APP_INFO_TOKEN,
+                useValue: createMockAppInfo(),
+            }),
+            provide({
+                provide: REQUEST_MANAGER_TOKEN,
+                useValue: createMockRequestManager(),
+            }),
+            provide({
+                provide: CREATE_CACHE_TOKEN,
+                useValue: () => createMockCache(),
+            }),
+            provide({
+                provide: COOKIE_MANAGER_TOKEN,
+                useValue: createMockCookieManager(),
+            }),
+            provide({
+                provide: CONTEXT_TOKEN,
+                useValue: createMockContext(),
+            }),
+        ],
+    })
+], CommonTestModule);
+
+export { CommonTestModule, createMockAppInfo, createMockCache, createMockContext, createMockCookieManager, createMockDi, createMockEnvManager, createMockLogger, createMockRequestManager, createMockRouter, createMockStore };

package/lib/index.js

@@ -13,6 +13,7 @@ var core = require('@tramvai/core');
 var router = require('@tinkoff/router');
 var url = require('@tinkoff/url');
 var noop = require('@tinkoff/utils/function/noop');
+var tslib = require('tslib');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -75,10 +76,11 @@ const createMockDi = ({ modules = [], providers = [] } = {}) => {
  * @param initialState - начальное состояние, которое будет передано в createMockStore если явно не передавать store
  * @param store - глобальный стор приложения, по умолчанию используется результат createMockStore
  * @param providers - список провайдеров, которые будут переданы в createMockDi если явно не передавать di
+ * @param modules - список модулей, провайдеры которых будут добавлены в создаваемый di-контейнер
  * @param stores - di-контейнер, по умолчанию используется результат createMockDi
  * @param useTramvaiActionsConditionals - добавляет встроенные в tramvai actions conditionals
  */
-const createMockContext = ({ stores, initialState, store = createMockStore({ stores, initialState }), providers, di = createMockDi({ providers }), useTramvaiActionsConditionals = false, } = {}) => {
+const createMockContext = ({ stores, initialState, store = createMockStore({ stores, initialState }), providers, modules, di = createMockDi({ providers, modules }), useTramvaiActionsConditionals = false, } = {}) => {
     const { __dispatcherContext__: dispatcherContext } = store; // хак для получения уже созданного dispatcherContext в сторе
     const pubsub$1 = new pubsub.PubSub();
     di.register({
@@ -256,6 +258,74 @@ const createMockCookieManager = (entries = {}) => {
     };
 };
 
+var CommonTestModule_1;
+exports.CommonTestModule = CommonTestModule_1 = class CommonTestModule {
+    static forRoot(options) {
+        const providers = [];
+        const { env, cookies, onCacheCreated } = options;
+        if (env) {
+            providers.push({
+                provide: tokensCommon.ENV_MANAGER_TOKEN,
+                useValue: createMockEnvManager(env),
+            });
+        }
+        if (cookies) {
+            providers.push({
+                provide: moduleCommon.COOKIE_MANAGER_TOKEN,
+                useValue: createMockCookieManager(cookies),
+            });
+        }
+        if (onCacheCreated) {
+            providers.push({
+                provide: tokensCommon.CREATE_CACHE_TOKEN,
+                useValue: () => {
+                    const cache = createMockCache();
+                    onCacheCreated(cache);
+                    return cache;
+                },
+            });
+        }
+        return {
+            providers,
+            mainModule: CommonTestModule_1,
+        };
+    }
+};
+exports.CommonTestModule = CommonTestModule_1 = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensCommon.ENV_MANAGER_TOKEN,
+                useValue: createMockEnvManager(),
+            }),
+            core.provide({
+                provide: tokensCommon.LOGGER_TOKEN,
+                useValue: createMockLogger(),
+            }),
+            core.provide({
+                provide: core.APP_INFO_TOKEN,
+                useValue: createMockAppInfo(),
+            }),
+            core.provide({
+                provide: tokensCommon.REQUEST_MANAGER_TOKEN,
+                useValue: createMockRequestManager(),
+            }),
+            core.provide({
+                provide: tokensCommon.CREATE_CACHE_TOKEN,
+                useValue: () => createMockCache(),
+            }),
+            core.provide({
+                provide: moduleCommon.COOKIE_MANAGER_TOKEN,
+                useValue: createMockCookieManager(),
+            }),
+            core.provide({
+                provide: tokensCommon.CONTEXT_TOKEN,
+                useValue: createMockContext(),
+            }),
+        ],
+    })
+], exports.CommonTestModule);
+
 exports.createMockAppInfo = createMockAppInfo;
 exports.createMockCache = createMockCache;
 exports.createMockContext = createMockContext;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/test-mocks",
-  "version": "2.28.0",
+  "version": "2.31.0",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -18,14 +18,14 @@
     "build-for-publish": "true"
   },
   "dependencies": {
-    "@tramvai/core": "2.28.0",
+    "@tramvai/core": "2.31.0",
     "@tinkoff/pubsub": "0.5.4",
     "@tinkoff/router": "0.2.3",
     "@tinkoff/url": "0.8.3",
-    "@tramvai/module-cookie": "2.28.0",
-    "@tramvai/module-common": "2.28.0",
-    "@tramvai/state": "2.28.0",
-    "@tramvai/tokens-common": "2.28.0"
+    "@tramvai/module-cookie": "2.31.0",
+    "@tramvai/module-common": "2.31.0",
+    "@tramvai/state": "2.31.0",
+    "@tramvai/tokens-common": "2.31.0"
   },
   "peerDependencies": {
     "@tinkoff/dippy": "0.8.6",