@modern-js/plugin-testing 1.5.6 → 1.6.0

package/dist/js/treeshaking/cli/bff/env.js

@@ -0,0 +1,98 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import NodeEnvironment from 'jest-environment-node';
+import { createApp } from "./app";
+import { bff_info_key } from "./constant";
+
+var _default = /*#__PURE__*/function (_NodeEnvironment) {
+  _inherits(_default, _NodeEnvironment);
+
+  var _super = _createSuper(_default);
+
+  function _default() {
+    var _this;
+
+    _classCallCheck(this, _default);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "app", void 0);
+
+    return _this;
+  }
+
+  _createClass(_default, [{
+    key: "setup",
+    value: function () {
+      var _setup = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var bff_info, plugins;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                bff_info = this.global[bff_info_key];
+                plugins = bff_info.plugins; // eslint-disable-next-line no-multi-assign
+
+                _context.next = 4;
+                return createApp(bff_info.appDir, bff_info.modernUserConfig, plugins, bff_info.routes);
+
+              case 4:
+                this.global.app = this.app = _context.sent;
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function setup() {
+        return _setup.apply(this, arguments);
+      }
+
+      return setup;
+    }()
+  }, {
+    key: "teardown",
+    value: function () {
+      var _teardown = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var _this$app, _this$app$server;
+
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return (_this$app = this.app) === null || _this$app === void 0 ? void 0 : (_this$app$server = _this$app.server) === null || _this$app$server === void 0 ? void 0 : _this$app$server.close();
+
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function teardown() {
+        return _teardown.apply(this, arguments);
+      }
+
+      return teardown;
+    }()
+  }]);
+
+  return _default;
+}(NodeEnvironment);
+
+export { _default as default };

package/dist/js/treeshaking/cli/bff/index.js

@@ -0,0 +1,145 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import path from 'path';
+import { isApiOnly } from '@modern-js/utils';
+import { getModuleNameMapper, DEFAULT_RESOLVER_PATH } from "../../base";
+import { bff_info_key } from "./constant";
+import { isBFFProject } from "./utils";
+export var setJestConfigForBFF = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var _userConfig$source;
+
+    var pwd, userConfig, plugins, routes, utils, bffConfig, jestConfig, alias, aliasMapper, transform, moduleNameMapper, apiOnly, mergedModuleNameMapper, resolver, configFields, commonConfig;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            pwd = _ref.pwd, userConfig = _ref.userConfig, plugins = _ref.plugins, routes = _ref.routes, utils = _ref.utils;
+            bffConfig = {
+              rootDir: path.join(pwd, './api'),
+              setupFilesAfterEnv: [require.resolve("./setup")],
+              testEnvironment: require.resolve("./env"),
+              testMatch: ["**/api/**/*.test.[jt]s"],
+              globals: _defineProperty({}, bff_info_key, {
+                appDir: pwd,
+                modernUserConfig: userConfig,
+                plugins: plugins,
+                routes: routes
+              })
+            };
+            jestConfig = utils.jestConfig;
+            alias = (userConfig === null || userConfig === void 0 ? void 0 : (_userConfig$source = userConfig.source) === null || _userConfig$source === void 0 ? void 0 : _userConfig$source.alias) || {};
+            aliasMapper = getModuleNameMapper(alias);
+            transform = jestConfig.transform, moduleNameMapper = jestConfig.moduleNameMapper;
+            _context.next = 8;
+            return isApiOnly(pwd);
+
+          case 8:
+            apiOnly = _context.sent;
+            mergedModuleNameMapper = _objectSpread(_objectSpread({}, moduleNameMapper), aliasMapper);
+            resolver = jestConfig.resolver || DEFAULT_RESOLVER_PATH; // 这三个配置不能设置在 projects 中，需要设置在外层(https://github.com/facebook/jest/issues/9696)
+
+            configFields = ['coverage', 'collectCoverage', 'testTimeout'];
+            commonConfig = configFields.reduce(function (obj, field) {
+              if (jestConfig.hasOwnProperty(field)) {
+                obj[field] = jestConfig[field];
+              }
+
+              return obj;
+            }, {});
+
+            if (!apiOnly) {
+              utils.setJestConfig({
+                projects: [_objectSpread({}, jestConfig), _objectSpread({
+                  transform: transform,
+                  moduleNameMapper: mergedModuleNameMapper,
+                  resolver: resolver
+                }, bffConfig)]
+              }, {
+                force: true
+              });
+            } else {
+              utils.setJestConfig({
+                projects: [_objectSpread({
+                  transform: transform,
+                  moduleNameMapper: mergedModuleNameMapper,
+                  resolver: resolver
+                }, bffConfig)]
+              }, {
+                force: true
+              });
+            }
+
+            utils.setJestConfig(commonConfig);
+
+          case 15:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function setJestConfigForBFF(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export default (function () {
+  return {
+    name: '@modern-js/testing-plugin-bff',
+    setup: function setup(api) {
+      return {
+        jestConfig: function () {
+          var _jestConfig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(utils, next) {
+            var appContext, pwd, userConfig, plugins;
+            return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+              while (1) {
+                switch (_context2.prev = _context2.next) {
+                  case 0:
+                    appContext = api.useAppContext();
+                    pwd = appContext.appDirectory;
+
+                    if (isBFFProject(pwd)) {
+                      _context2.next = 4;
+                      break;
+                    }
+
+                    return _context2.abrupt("return", next(utils));
+
+                  case 4:
+                    userConfig = api.useResolvedConfigContext();
+                    plugins = appContext.plugins.map(function (p) {
+                      return p.server;
+                    }).filter(Boolean);
+                    _context2.next = 8;
+                    return setJestConfigForBFF({
+                      pwd: pwd,
+                      userConfig: userConfig,
+                      plugins: plugins,
+                      routes: appContext.serverRoutes,
+                      utils: utils
+                    });
+
+                  case 8:
+                    return _context2.abrupt("return", next(utils));
+
+                  case 9:
+                  case "end":
+                    return _context2.stop();
+                }
+              }
+            }, _callee2);
+          }));
+
+          function jestConfig(_x2, _x3) {
+            return _jestConfig.apply(this, arguments);
+          }
+
+          return jestConfig;
+        }()
+      };
+    }
+  };
+});

package/dist/js/treeshaking/cli/bff/mockAPI.js

@@ -0,0 +1,113 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as ptr from 'path-to-regexp';
+import * as mock_appModule from "./app"; // eslint-disable-next-line @typescript-eslint/naming-convention
+
+var mock_replaceUrlWithParams = function mock_replaceUrlWithParams(url, paramValues, payload) {
+  var keys = [];
+  ptr.pathToRegexp(url, keys);
+  var params = keys.reduce(function (cur, key, index) {
+    if (paramValues[index]) {
+      cur[key.name] = paramValues[index];
+    }
+
+    return cur;
+  }, {});
+  var getFinalPath = ptr.compile(url, {
+    encode: encodeURIComponent
+  });
+  return getFinalPath(_objectSpread(_objectSpread({}, params), payload));
+}; // eslint-disable-next-line @typescript-eslint/naming-convention
+
+
+var mock_getParamsAndPayload = function mock_getParamsAndPayload(args) {
+  if (args.length === 0) {
+    return [[], {}];
+  }
+
+  var head = args[0];
+
+  if (_typeof(head) === 'object') {
+    return [[], head];
+  } else {
+    var latest = args[args.length - 1];
+
+    if (_typeof(latest) === 'object') {
+      return [args.slice(0, args.length - 1), latest];
+    } else {
+      return [args, {}];
+    }
+  }
+};
+
+export default (function (mock_apiInfosByFile, mock_app) {
+  var files = Object.keys(mock_apiInfosByFile);
+  files.forEach(function (mockedFile) {
+    jest.mock(mockedFile, function () {
+      var supertest = require('supertest');
+
+      return mock_apiInfosByFile[mockedFile].reduce(function (res, info) {
+        var module = _defineProperty({}, info.name, function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+
+          if (mock_appModule.isInHandler()) {
+            return info.handler.apply(info, args);
+          }
+
+          var _mock_getParamsAndPay = mock_getParamsAndPayload(args),
+              _mock_getParamsAndPay2 = _slicedToArray(_mock_getParamsAndPay, 2),
+              params = _mock_getParamsAndPay2[0],
+              payload = _mock_getParamsAndPay2[1];
+
+          var _ref = module[info.name],
+              returnHttp = _ref.returnHttp;
+          var url = mock_replaceUrlWithParams(info.routePath, params, payload.params);
+          var test = supertest(mock_app)[info.httpMethod.toLowerCase()](url);
+
+          if (payload.query) {
+            test = test.query(payload.query);
+          }
+
+          if (payload.body) {
+            test = test.send(payload.body);
+          }
+
+          if (payload.data) {
+            test = test.send(payload.data);
+          }
+
+          if (payload.headers) {
+            for (var name in payload.headers) {
+              test = test.set(name, payload.headers[name]);
+            }
+          }
+
+          if (payload.cookies) {
+            test = test.set('Cookie', [payload.cookies]);
+          }
+
+          if (returnHttp) {
+            return test;
+          }
+
+          return test.then(function (value) {
+            try {
+              return JSON.parse(value.text);
+            } catch (_unused) {
+              return value.text;
+            }
+          });
+        });
+
+        res[info.name] = module[info.name];
+        Object.assign(res[info.name], info.handler);
+        res.__esModule = true;
+        return res;
+      }, {});
+    });
+  });
+});

package/dist/js/treeshaking/cli/bff/setup.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import { ApiRouter } from '@modern-js/bff-core';
+import { bff_info_key } from "./constant";
+import mockAPI from "./mockAPI";
+var uped = false;
+
+var setup = function setup() {
+  var _bff_info$modernUserC, _bff_info$modernUserC2;
+
+  if (uped) {
+    return;
+  }
+
+  uped = true;
+  var bff_info = global[bff_info_key];
+  var prefix = bff_info === null || bff_info === void 0 ? void 0 : (_bff_info$modernUserC = bff_info.modernUserConfig) === null || _bff_info$modernUserC === void 0 ? void 0 : (_bff_info$modernUserC2 = _bff_info$modernUserC.bff) === null || _bff_info$modernUserC2 === void 0 ? void 0 : _bff_info$modernUserC2.prefix;
+  var apiRouter = new ApiRouter({
+    apiDir: path.join(bff_info.appDir, './api'),
+    prefix: prefix
+  });
+  var apiInfos = apiRouter.getApiHandlers();
+  var apiInfosByFile = apiInfos.reduce(function (res, apiInfo) {
+    if (!res[apiInfo.filename]) {
+      res[apiInfo.filename] = [];
+    }
+
+    res[apiInfo.filename].push(apiInfo);
+    return res;
+  }, {});
+  mockAPI(apiInfosByFile, global.app);
+};
+
+setup();

package/dist/js/treeshaking/cli/bff/utils/index.js

@@ -0,0 +1,22 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import path from 'path';
+import { chalk } from '@modern-js/utils';
+export var isBFFProject = function isBFFProject(pwd) {
+  try {
+    var packageJson = require(path.join(pwd, './package.json'));
+
+    var dependencies = packageJson.dependencies,
+        devDependencies = packageJson.devDependencies;
+    var isBFF = Object.keys(_objectSpread(_objectSpread({}, dependencies), devDependencies)).some(function (dependency) {
+      return dependency.includes('plugin-bff');
+    });
+    var isMWA = Object.keys(devDependencies).some(function (devDependency) {
+      return devDependency.includes('app-tools');
+    });
+    return isMWA && isBFF;
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.log(chalk.red(error));
+    return false;
+  }
+};

package/dist/js/treeshaking/cli/index.js

@@ -3,10 +3,10 @@ import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import path from 'path';
 import { PLUGIN_SCHEMAS, createRuntimeExportsUtils, isApiOnly } from '@modern-js/utils';
-import { testingHooks, getModuleNameMapper, DEFAULT_RESOLVER_PATH } from '@modern-js/testing';
 import { getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack';
-import TestingBffPlugin from '@modern-js/testing-plugin-bff';
+import { testingHooks, getModuleNameMapper, DEFAULT_RESOLVER_PATH } from "../base";
 import { MODERNJS_CONFIG_KEY } from "../constant";
+import TestingBffPlugin from "./bff";
 import test from "./test";
 export var mergeUserJestConfig = function mergeUserJestConfig(testUtils) {
   var resolveJestConfig = testUtils.testConfig.jest; // resolveJestConfig 如果是函数类型，在所有测试插件 jestConfig 都执行后，再执行生成最终配置

package/dist/js/treeshaking/cli/test.js

@@ -2,7 +2,7 @@ import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import path from 'path';
 import { compiler } from '@modern-js/babel-compiler';
-import { runTest } from '@modern-js/testing';
+import { runTest } from "../base";
 
 var test = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(api) {

package/dist/js/treeshaking/runtime-testing/base.js

@@ -1,3 +1,3 @@
 export { default as renderApp } from "./customRender";
 export * from '@testing-library/react';
-export { testBff } from '@modern-js/testing-plugin-bff';
+export { request as testBff } from "./request";

package/dist/js/treeshaking/runtime-testing/request.js

@@ -0,0 +1,24 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+
+/* eslint-disable eslint-comments/disable-enable-pair */
+import supertest from 'supertest';
+
+function request() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var fn = args[0],
+      extraArgs = args.slice(1);
+
+  if (!fn) {
+    return supertest(global.app);
+  }
+
+  fn.returnHttp = true;
+  var res = fn.apply(void 0, _toConsumableArray(extraArgs));
+  fn.returnHttp = false;
+  return res;
+}
+
+export { request };

package/dist/types/base/config/index.d.ts

@@ -0,0 +1,124 @@
+import { TestConfig } from '../types';
+import { TestConfigOperator } from './testConfigOperator';
+/**
+ * Parse jest config
+ */
+
+declare const getJestUtils: (testConfig: TestConfig) => TestConfigOperator;
+declare const patchConfig: (testOperator: TestConfigOperator) => Promise<Partial<{
+  automock: boolean;
+  bail: number | boolean;
+  cache: boolean;
+  cacheDirectory: string;
+  ci: boolean;
+  clearMocks: boolean;
+  changedFilesWithAncestor: boolean;
+  changedSince: string;
+  collectCoverage: boolean;
+  collectCoverageFrom: string[];
+  collectCoverageOnlyFrom: {
+    [key: string]: boolean;
+  };
+  coverageDirectory: string;
+  coveragePathIgnorePatterns: string[];
+  coverageProvider: "babel" | "v8";
+  coverageReporters: import("@jest/types/build/Config").CoverageReporters;
+  coverageThreshold: {
+    [path: string]: import("@jest/types/build/Config").CoverageThresholdValue;
+    global: import("@jest/types/build/Config").CoverageThresholdValue;
+  };
+  dependencyExtractor: string;
+  detectLeaks: boolean;
+  detectOpenHandles: boolean;
+  displayName: string | import("@jest/types/build/Config").DisplayName;
+  expand: boolean;
+  extensionsToTreatAsEsm: string[];
+  extraGlobals: string[];
+  filter: string;
+  findRelatedTests: boolean;
+  forceCoverageMatch: string[];
+  forceExit: boolean;
+  json: boolean;
+  globals: import("@jest/types/build/Config").ConfigGlobals;
+  globalSetup: string | null | undefined;
+  globalTeardown: string | null | undefined;
+  haste: import("@jest/types/build/Config").HasteConfig;
+  injectGlobals: boolean;
+  reporters: (string | import("@jest/types/build/Config").ReporterConfig)[];
+  logHeapUsage: boolean;
+  lastCommit: boolean;
+  listTests: boolean;
+  maxConcurrency: number;
+  maxWorkers: string | number;
+  moduleDirectories: string[];
+  moduleFileExtensions: string[];
+  moduleLoader: string;
+  moduleNameMapper: {
+    [key: string]: string | string[];
+  };
+  modulePathIgnorePatterns: string[];
+  modulePaths: string[];
+  name: string;
+  noStackTrace: boolean;
+  notify: boolean;
+  notifyMode: string;
+  onlyChanged: boolean;
+  onlyFailures: boolean;
+  outputFile: string;
+  passWithNoTests: boolean;
+  preprocessorIgnorePatterns: string[];
+  preset: string | null | undefined;
+  prettierPath: string | null | undefined;
+  projects: (string | import("@jest/types/build/Config").InitialProjectOptions)[];
+  replname: string | null | undefined;
+  resetMocks: boolean;
+  resetModules: boolean;
+  resolver: string | null | undefined;
+  restoreMocks: boolean;
+  rootDir: string;
+  roots: string[];
+  runner: string;
+  runTestsByPath: boolean;
+  scriptPreprocessor: string;
+  setupFiles: string[];
+  setupTestFrameworkScriptFile: string;
+  setupFilesAfterEnv: string[];
+  silent: boolean;
+  skipFilter: boolean;
+  skipNodeResolution: boolean;
+  slowTestThreshold: number;
+  snapshotResolver: string;
+  snapshotSerializers: string[];
+  snapshotFormat: import("@jest/types/build/Config").PrettyFormatOptions;
+  errorOnDeprecated: boolean;
+  testEnvironment: string;
+  testEnvironmentOptions: Record<string, unknown>;
+  testFailureExitCode: string | number;
+  testLocationInResults: boolean;
+  testMatch: string[];
+  testNamePattern: string;
+  testPathDirs: string[];
+  testPathIgnorePatterns: string[];
+  testRegex: string | string[];
+  testResultsProcessor: string;
+  testRunner: string;
+  testSequencer: string;
+  testURL: string;
+  testTimeout: number;
+  timers: "modern" | "real" | "fake" | "legacy";
+  transform: {
+    [regex: string]: string | import("@jest/types/build/Config").TransformerConfig;
+  };
+  transformIgnorePatterns: string[];
+  watchPathIgnorePatterns: string[];
+  unmockedModulePathPatterns: string[];
+  updateSnapshot: boolean;
+  useStderr: boolean;
+  verbose?: boolean | undefined;
+  watch: boolean;
+  watchAll: boolean;
+  watchman: boolean;
+  watchPlugins: (string | [string, Record<string, unknown>])[];
+}>>;
+export declare const DEFAULT_RESOLVER_PATH: string;
+export { getJestUtils, patchConfig };

package/dist/types/base/config/patches/assetsModule.d.ts

@@ -0,0 +1,6 @@
+import { TestConfigOperator } from '../testConfigOperator';
+/**
+ * Merge config from testConfig.jest
+ */
+
+export declare const patchAssetsModule: (testOperator: TestConfigOperator) => void;

package/dist/types/base/config/patches/filemock.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "test-file-stub";
+
+export default _default;

package/dist/types/base/config/patches/index.d.ts

@@ -0,0 +1,2 @@
+import { TestConfigOperator } from '../testConfigOperator';
+export declare const applyPatches: (testConfig: TestConfigOperator) => Promise<void>;

package/dist/types/base/config/patches/transformer.d.ts

@@ -0,0 +1,6 @@
+import { TestConfigOperator } from '../testConfigOperator';
+/**
+ * Map `TestConfig.transformer` to jest config
+ */
+
+export declare const patchTransformer: (testOperator: TestConfigOperator) => void;

package/dist/types/base/config/resolver.d.ts

@@ -0,0 +1 @@
+export {};