@tramvai/test-mocks 2.70.1 → 2.72.0

package/lib/CommonTestModule.es.js

@@ -0,0 +1,81 @@
+import { __decorate } from 'tslib';
+import { Module, provide, APP_INFO_TOKEN } from '@tramvai/core';
+import { ENV_MANAGER_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, CREATE_CACHE_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { COOKIE_MANAGER_TOKEN } from '@tramvai/module-common';
+import { createMockEnvManager } from './envManager.es.js';
+import { createMockCookieManager } from './cookie.es.js';
+import { createMockLogger } from './logger.es.js';
+import { createMockAppInfo } from './appInfo.es.js';
+import { createMockRequestManager } from './requestManager.es.js';
+import { createMockCache } from './cache.es.js';
+import { createMockContext } from './context.es.js';
+
+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 };

package/lib/CommonTestModule.js

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+var moduleCommon = require('@tramvai/module-common');
+var envManager = require('./envManager.js');
+var cookie = require('./cookie.js');
+var logger = require('./logger.js');
+var appInfo = require('./appInfo.js');
+var requestManager = require('./requestManager.js');
+var cache = require('./cache.js');
+var context = require('./context.js');
+
+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: envManager.createMockEnvManager(env),
+            });
+        }
+        if (cookies) {
+            providers.push({
+                provide: moduleCommon.COOKIE_MANAGER_TOKEN,
+                useValue: cookie.createMockCookieManager(cookies),
+            });
+        }
+        if (onCacheCreated) {
+            providers.push({
+                provide: tokensCommon.CREATE_CACHE_TOKEN,
+                useValue: () => {
+                    const cache$1 = cache.createMockCache();
+                    onCacheCreated(cache$1);
+                    return cache$1;
+                },
+            });
+        }
+        return {
+            providers,
+            mainModule: CommonTestModule_1,
+        };
+    }
+};
+exports.CommonTestModule = CommonTestModule_1 = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensCommon.ENV_MANAGER_TOKEN,
+                useValue: envManager.createMockEnvManager(),
+            }),
+            core.provide({
+                provide: tokensCommon.LOGGER_TOKEN,
+                useValue: logger.createMockLogger(),
+            }),
+            core.provide({
+                provide: core.APP_INFO_TOKEN,
+                useValue: appInfo.createMockAppInfo(),
+            }),
+            core.provide({
+                provide: tokensCommon.REQUEST_MANAGER_TOKEN,
+                useValue: requestManager.createMockRequestManager(),
+            }),
+            core.provide({
+                provide: tokensCommon.CREATE_CACHE_TOKEN,
+                useValue: () => cache.createMockCache(),
+            }),
+            core.provide({
+                provide: moduleCommon.COOKIE_MANAGER_TOKEN,
+                useValue: cookie.createMockCookieManager(),
+            }),
+            core.provide({
+                provide: tokensCommon.CONTEXT_TOKEN,
+                useValue: context.createMockContext(),
+            }),
+        ],
+    })
+], exports.CommonTestModule);

package/lib/appInfo.es.js

@@ -0,0 +1,7 @@
+const createMockAppInfo = ({ appName = 'test', } = {}) => {
+    return {
+        appName,
+    };
+};
+
+export { createMockAppInfo };

package/lib/appInfo.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const createMockAppInfo = ({ appName = 'test', } = {}) => {
+    return {
+        appName,
+    };
+};
+
+exports.createMockAppInfo = createMockAppInfo;

package/lib/cache.es.js

@@ -0,0 +1,18 @@
+const createMockCache = (entries = {}) => {
+    let cache = { ...entries };
+    return {
+        has: (key) => !!cache[key],
+        get: (key) => cache[key],
+        set: (key, value) => {
+            cache[key] = value;
+        },
+        clear: () => {
+            cache = {};
+        },
+        // TODO: в @tinkoff/request- используются методы из lru-cache которых нету в Cache
+        // @ts-ignore
+        peek: (key) => cache[key],
+    };
+};
+
+export { createMockCache };

package/lib/cache.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const createMockCache = (entries = {}) => {
+    let cache = { ...entries };
+    return {
+        has: (key) => !!cache[key],
+        get: (key) => cache[key],
+        set: (key, value) => {
+            cache[key] = value;
+        },
+        clear: () => {
+            cache = {};
+        },
+        // TODO: в @tinkoff/request- используются методы из lru-cache которых нету в Cache
+        // @ts-ignore
+        peek: (key) => cache[key],
+    };
+};
+
+exports.createMockCache = createMockCache;

package/lib/context.es.js

@@ -0,0 +1,62 @@
+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 { PubSub } from '@tinkoff/pubsub';
+import { DI_TOKEN } from '@tinkoff/dippy';
+import { createMockStore } from './store.es.js';
+import { createMockDi } from './di.es.js';
+
+/**
+ * Создаёт мок для consumerContext
+ *
+ * @param stores - список сторов, которые будут переданы в createMockStore если явно не передавать store
+ * @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, modules, di = createMockDi({ providers, modules }), useTramvaiActionsConditionals = false, } = {}) => {
+    const { __dispatcherContext__: dispatcherContext } = store; // хак для получения уже созданного dispatcherContext в сторе
+    const pubsub = new PubSub();
+    di.register({
+        provide: STORE_TOKEN,
+        useValue: store,
+    });
+    if (!di.get({ token: ACTION_EXECUTION_TOKEN, optional: true })) {
+        if (useTramvaiActionsConditionals) {
+            di.register({
+                provide: ACTION_CONDITIONALS,
+                multi: true,
+                useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
+            });
+        }
+        di.register({
+            provide: EXECUTION_CONTEXT_MANAGER_TOKEN,
+            useClass: ExecutionContextManager,
+        });
+        di.register({
+            provide: ACTION_EXECUTION_TOKEN,
+            useClass: ActionExecution,
+            deps: {
+                actionConditionals: { token: ACTION_CONDITIONALS, optional: true },
+                context: CONTEXT_TOKEN,
+                store: STORE_TOKEN,
+                di: DI_TOKEN,
+                transformAction: {
+                    token: 'actionTransformAction',
+                    optional: true,
+                },
+                executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
+            },
+        });
+    }
+    const context = createConsumerContext({ store, pubsub, di, dispatcherContext });
+    di.register({
+        provide: CONTEXT_TOKEN,
+        useValue: context,
+    });
+    return context;
+};
+
+export { createMockContext };

package/lib/context.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensCommon = require('@tramvai/tokens-common');
+var moduleCommon = require('@tramvai/module-common');
+var pubsub = require('@tinkoff/pubsub');
+var dippy = require('@tinkoff/dippy');
+var store = require('./store.js');
+var di = require('./di.js');
+
+/**
+ * Создаёт мок для consumerContext
+ *
+ * @param stores - список сторов, которые будут переданы в createMockStore если явно не передавать store
+ * @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: store$1 = store.createMockStore({ stores, initialState }), providers, modules, di: di$1 = di.createMockDi({ providers, modules }), useTramvaiActionsConditionals = false, } = {}) => {
+    const { __dispatcherContext__: dispatcherContext } = store$1; // хак для получения уже созданного dispatcherContext в сторе
+    const pubsub$1 = new pubsub.PubSub();
+    di$1.register({
+        provide: tokensCommon.STORE_TOKEN,
+        useValue: store$1,
+    });
+    if (!di$1.get({ token: tokensCommon.ACTION_EXECUTION_TOKEN, optional: true })) {
+        if (useTramvaiActionsConditionals) {
+            di$1.register({
+                provide: tokensCommon.ACTION_CONDITIONALS,
+                multi: true,
+                useValue: [moduleCommon.alwaysCondition, moduleCommon.onlyServer, moduleCommon.onlyBrowser, moduleCommon.pageServer, moduleCommon.pageBrowser],
+            });
+        }
+        di$1.register({
+            provide: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
+            useClass: moduleCommon.ExecutionContextManager,
+        });
+        di$1.register({
+            provide: tokensCommon.ACTION_EXECUTION_TOKEN,
+            useClass: moduleCommon.ActionExecution,
+            deps: {
+                actionConditionals: { token: tokensCommon.ACTION_CONDITIONALS, optional: true },
+                context: tokensCommon.CONTEXT_TOKEN,
+                store: tokensCommon.STORE_TOKEN,
+                di: dippy.DI_TOKEN,
+                transformAction: {
+                    token: 'actionTransformAction',
+                    optional: true,
+                },
+                executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
+            },
+        });
+    }
+    const context = moduleCommon.createConsumerContext({ store: store$1, pubsub: pubsub$1, di: di$1, dispatcherContext });
+    di$1.register({
+        provide: tokensCommon.CONTEXT_TOKEN,
+        useValue: context,
+    });
+    return context;
+};
+
+exports.createMockContext = createMockContext;

package/lib/cookie.es.js

@@ -0,0 +1,19 @@
+const createMockCookieManager = (entries = {}) => {
+    const cookies = { ...entries };
+    return {
+        get(name) {
+            return cookies[name];
+        },
+        set({ name, value }) {
+            cookies[name] = value;
+        },
+        all() {
+            return cookies;
+        },
+        remove(name) {
+            delete cookies[name];
+        },
+    };
+};
+
+export { createMockCookieManager };

package/lib/cookie.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const createMockCookieManager = (entries = {}) => {
+    const cookies = { ...entries };
+    return {
+        get(name) {
+            return cookies[name];
+        },
+        set({ name, value }) {
+            cookies[name] = value;
+        },
+        all() {
+            return cookies;
+        },
+        remove(name) {
+            delete cookies[name];
+        },
+    };
+};
+
+exports.createMockCookieManager = createMockCookieManager;

package/lib/di.es.js

@@ -0,0 +1,25 @@
+import { createContainer } from '@tinkoff/dippy';
+import { walkOfModules, getModuleParameters } from '@tramvai/core';
+
+/**
+ * Создаёт di-сontainer
+ *
+ * @param modules - список модулей, провайдеры которых будут добавлены в создаваемый di-контейнер
+ * @param providers - список провайдеров, которые будут добавлены в создаваемый di-контейнер
+ */
+const createMockDi = ({ modules = [], providers = [] } = {}) => {
+    const di = createContainer();
+    const resolvedModules = walkOfModules(modules);
+    resolvedModules.forEach((mod) => {
+        const moduleParameters = getModuleParameters(mod);
+        moduleParameters.providers.forEach((provider) => {
+            di.register(provider);
+        });
+    });
+    if (providers) {
+        providers.forEach((provider) => di.register(provider));
+    }
+    return di;
+};
+
+export { createMockDi };

package/lib/di.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+var core = require('@tramvai/core');
+
+/**
+ * Создаёт di-сontainer
+ *
+ * @param modules - список модулей, провайдеры которых будут добавлены в создаваемый di-контейнер
+ * @param providers - список провайдеров, которые будут добавлены в создаваемый di-контейнер
+ */
+const createMockDi = ({ modules = [], providers = [] } = {}) => {
+    const di = dippy.createContainer();
+    const resolvedModules = core.walkOfModules(modules);
+    resolvedModules.forEach((mod) => {
+        const moduleParameters = core.getModuleParameters(mod);
+        moduleParameters.providers.forEach((provider) => {
+            di.register(provider);
+        });
+    });
+    if (providers) {
+        providers.forEach((provider) => di.register(provider));
+    }
+    return di;
+};
+
+exports.createMockDi = createMockDi;

package/lib/envManager.es.js

@@ -0,0 +1,14 @@
+import noop from '@tinkoff/utils/function/noop';
+
+const createMockEnvManager = (env = {}) => {
+    return {
+        get: (name) => env[name],
+        getInt: (name, def) => { var _a; return (_a = parseInt(env[name], 10)) !== null && _a !== void 0 ? _a : def; },
+        getAll: () => env,
+        update: noop,
+        clientUsed: () => env,
+        updateClientUsed: noop,
+    };
+};
+
+export { createMockEnvManager };

package/lib/envManager.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var noop = require('@tinkoff/utils/function/noop');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
+
+const createMockEnvManager = (env = {}) => {
+    return {
+        get: (name) => env[name],
+        getInt: (name, def) => { var _a; return (_a = parseInt(env[name], 10)) !== null && _a !== void 0 ? _a : def; },
+        getAll: () => env,
+        update: noop__default["default"],
+        clientUsed: () => env,
+        updateClientUsed: noop__default["default"],
+    };
+};
+
+exports.createMockEnvManager = createMockEnvManager;