@modern-js/plugin-testing 1.5.7 → 1.6.0

package/dist/js/modern/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";
+let uped = false;
+
+const setup = () => {
+  var _bff_info$modernUserC, _bff_info$modernUserC2;
+
+  if (uped) {
+    return;
+  }
+
+  uped = true;
+  const bff_info = global[bff_info_key];
+  const 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;
+  const apiRouter = new ApiRouter({
+    apiDir: path.join(bff_info.appDir, './api'),
+    prefix
+  });
+  const apiInfos = apiRouter.getApiHandlers();
+  const apiInfosByFile = apiInfos.reduce((res, apiInfo) => {
+    if (!res[apiInfo.filename]) {
+      res[apiInfo.filename] = [];
+    }
+
+    res[apiInfo.filename].push(apiInfo);
+    return res;
+  }, {});
+  mockAPI(apiInfosByFile, global.app);
+};
+
+setup();

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

@@ -0,0 +1,25 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import path from 'path';
+import { chalk } from '@modern-js/utils';
+export const isBFFProject = pwd => {
+  try {
+    const packageJson = require(path.join(pwd, './package.json'));
+
+    const {
+      dependencies,
+      devDependencies
+    } = packageJson;
+    const isBFF = Object.keys(_objectSpread(_objectSpread({}, dependencies), devDependencies)).some(dependency => dependency.includes('plugin-bff'));
+    const isMWA = Object.keys(devDependencies).some(devDependency => 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/modern/cli/index.js

@@ -1,9 +1,9 @@
 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 const mergeUserJestConfig = testUtils => {
   const resolveJestConfig = testUtils.testConfig.jest; // resolveJestConfig 如果是函数类型，在所有测试插件 jestConfig 都执行后，再执行生成最终配置

package/dist/js/modern/cli/test.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { compiler } from '@modern-js/babel-compiler';
-import { runTest } from '@modern-js/testing';
+import { runTest } from "../base";
 
 const test = async api => {
   const userConfig = api.useResolvedConfigContext();

package/dist/js/modern/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/modern/runtime-testing/request.js

@@ -0,0 +1,17 @@
+/* eslint-disable eslint-comments/disable-enable-pair */
+import supertest from 'supertest';
+
+function request(...args) {
+  const [fn, ...extraArgs] = args;
+
+  if (!fn) {
+    return supertest(global.app);
+  }
+
+  fn.returnHttp = true;
+  const res = fn(...extraArgs);
+  fn.returnHttp = false;
+  return res;
+}
+
+export { request };

package/dist/js/node/base/config/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.patchConfig = exports.getJestUtils = exports.DEFAULT_RESOLVER_PATH = void 0;
+
+var _patches = require("./patches");
+
+var _testConfigOperator = require("./testConfigOperator");
+
+/**
+ * Parse jest config
+ */
+const getJestUtils = testConfig => {
+  const testOperator = new _testConfigOperator.TestConfigOperator(testConfig);
+  return testOperator;
+};
+
+exports.getJestUtils = getJestUtils;
+
+const patchConfig = async testOperator => {
+  await (0, _patches.applyPatches)(testOperator);
+  return testOperator.jestConfig;
+};
+
+exports.patchConfig = patchConfig;
+
+const DEFAULT_RESOLVER_PATH = require.resolve("./resolver");
+
+exports.DEFAULT_RESOLVER_PATH = DEFAULT_RESOLVER_PATH;

package/dist/js/node/base/config/patches/assetsModule.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.patchAssetsModule = void 0;
+
+/**
+ * Merge config from testConfig.jest
+ */
+const patchAssetsModule = testOperator => {
+  testOperator.mergeJestConfig({
+    moduleNameMapper: {
+      '\\.(css|less|scss|sass)$': require.resolve('identity-obj-proxy'),
+      '\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$': require.resolve("./filemock.js")
+    }
+  });
+};
+
+exports.patchAssetsModule = patchAssetsModule;

package/dist/js/node/base/config/patches/filemock.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = 'test-file-stub';
+exports.default = _default;

package/dist/js/node/base/config/patches/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyPatches = void 0;
+
+var _transformer = require("./transformer");
+
+var _assetsModule = require("./assetsModule");
+
+const _applyPatches = async (patches, testOperator) => {
+  for (const patch of patches) {
+    await patch(testOperator);
+  }
+};
+
+const patches = [_transformer.patchTransformer, _assetsModule.patchAssetsModule];
+
+const applyPatches = async testConfig => {
+  await _applyPatches(patches, testConfig);
+};
+
+exports.applyPatches = applyPatches;

package/dist/js/node/base/config/patches/transformer.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.patchTransformer = void 0;
+
+var _utils = require("../../utils");
+
+const resolveTsCompilerOptions = () => {
+  const tsCompilerOptions = (0, _utils.readCompilerOptions)() || {};
+  const {
+    jsx
+  } = tsCompilerOptions;
+
+  if (!jsx) {
+    return null;
+  }
+
+  tsCompilerOptions.jsx = 'react-jsx';
+  return tsCompilerOptions;
+};
+/**
+ * Map `TestConfig.transformer` to jest config
+ */
+
+
+const patchTransformer = testOperator => {
+  const {
+    transformer
+  } = testOperator.testConfig;
+
+  if (transformer === 'babel-jest') {
+    testOperator.mergeJestConfig({
+      transform: {
+        '\\.[jt]sx?$': require.resolve("../transformer/babelTransformer")
+      }
+    });
+  }
+
+  if (transformer === 'ts-jest') {
+    testOperator.mergeJestConfig({
+      transform: {
+        '\\.[jt]sx?$': require.resolve('ts-jest')
+      }
+    });
+    const compilerOptions = resolveTsCompilerOptions();
+    compilerOptions && testOperator.mergeJestConfig({
+      globals: {
+        'ts-jest': {
+          tsconfig: compilerOptions
+        }
+      }
+    });
+  }
+};
+
+exports.patchTransformer = patchTransformer;

package/dist/js/node/base/config/resolver.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _enhancedResolve = _interopRequireDefault(require("enhanced-resolve"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const resolver = _enhancedResolve.default.create.sync({
+  conditionNames: ['require', 'node', 'default'],
+  extensions: ['.js', '.json', '.node', '.ts', '.tsx']
+});
+
+const shouldResolveByEnhance = url => /^@[^/]+\/[^/]+\/.*/.test(url);
+
+module.exports = function (request, options) {
+  if (shouldResolveByEnhance(request)) {
+    return resolver(options.basedir, request);
+  }
+
+  return options.defaultResolver(request, options);
+};

package/dist/js/node/base/config/testConfigOperator.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestConfigOperator = void 0;
+
+var _lodash = require("@modern-js/utils/lodash");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class TestConfigOperator {
+  constructor(testConfig) {
+    _defineProperty(this, "_testConfig", void 0);
+
+    _defineProperty(this, "_jestConfig", void 0);
+
+    _defineProperty(this, "userJestConfig", void 0);
+
+    _defineProperty(this, "defaultTestConfig", {
+      transformer: 'babel-jest'
+    });
+
+    this._testConfig = testConfig;
+    this._jestConfig = {};
+    this.userJestConfig = testConfig.jest;
+    this.initial();
+  }
+
+  initial() {
+    this._testConfig = (0, _lodash.merge)({}, this.defaultTestConfig, this.testConfig);
+  }
+
+  get jestConfig() {
+    return this._jestConfig;
+  }
+
+  get testConfig() {
+    return this._testConfig;
+  }
+
+  mergeJestConfig(sourceConfig) {
+    this._jestConfig = (0, _lodash.merge)({}, this._jestConfig, sourceConfig);
+  }
+
+  setJestUserConfig() {
+    const {
+      userJestConfig
+    } = this;
+
+    if (typeof userJestConfig === 'object') {
+      this.setJestConfig(userJestConfig);
+    }
+  }
+
+  setJestConfig(sourceConfig, options) {
+    if (options) {
+      const {
+        force
+      } = options;
+
+      if (force) {
+        this._jestConfig = sourceConfig;
+        return;
+      }
+    }
+
+    this._jestConfig = _objectSpread(_objectSpread({}, this._jestConfig), sourceConfig);
+  }
+
+  getFinalConfig() {
+    const {
+      userJestConfig
+    } = this;
+
+    if (!userJestConfig) {
+      return this._jestConfig;
+    }
+
+    if (typeof userJestConfig === 'function') {
+      return userJestConfig(this._jestConfig);
+    }
+
+    return this.jestConfig;
+  }
+
+}
+
+exports.TestConfigOperator = TestConfigOperator;

package/dist/js/node/base/config/transformer/babelTransformer.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _babelJest = _interopRequireDefault(require("babel-jest"));
+
+var _babelJest$createTran;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const babelTransformer = (_babelJest$createTran = _babelJest.default.createTransformer) === null || _babelJest$createTran === void 0 ? void 0 : _babelJest$createTran.call(_babelJest.default, {
+  presets: [[require.resolve('@modern-js/babel-preset-app'), {
+    appDirectory: process.cwd(),
+    modules: 'cjs'
+  }]],
+  configFile: false,
+  babelrc: false
+});
+var _default = babelTransformer;
+exports.default = _default;

package/dist/js/node/base/hook.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testingHooks = exports.jestConfigHook = exports.afterTestHook = void 0;
+
+var _plugin = require("@modern-js/plugin");
+
+const jestConfigHook = (0, _plugin.createAsyncPipeline)();
+exports.jestConfigHook = jestConfigHook;
+const afterTestHook = (0, _plugin.createParallelWorkflow)();
+exports.afterTestHook = afterTestHook;
+const testingHooks = {
+  jestConfig: (0, _plugin.createAsyncPipeline)(),
+  afterTest: (0, _plugin.createParallelWorkflow)()
+};
+exports.testingHooks = testingHooks;

package/dist/js/node/base/index.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  runTest: true,
+  runJest: true,
+  getModuleNameMapper: true,
+  DEFAULT_RESOLVER_PATH: true,
+  TestConfigOperator: true,
+  testingHooks: true
+};
+Object.defineProperty(exports, "DEFAULT_RESOLVER_PATH", {
+  enumerable: true,
+  get: function () {
+    return _config.DEFAULT_RESOLVER_PATH;
+  }
+});
+Object.defineProperty(exports, "TestConfigOperator", {
+  enumerable: true,
+  get: function () {
+    return _testConfigOperator.TestConfigOperator;
+  }
+});
+Object.defineProperty(exports, "getModuleNameMapper", {
+  enumerable: true,
+  get: function () {
+    return _utils.getModuleNameMapper;
+  }
+});
+Object.defineProperty(exports, "runJest", {
+  enumerable: true,
+  get: function () {
+    return _runJest.runJest;
+  }
+});
+Object.defineProperty(exports, "runTest", {
+  enumerable: true,
+  get: function () {
+    return _runJest.runTest;
+  }
+});
+Object.defineProperty(exports, "testingHooks", {
+  enumerable: true,
+  get: function () {
+    return _hook.testingHooks;
+  }
+});
+
+var _runJest = require("./runJest");
+
+var _utils = require("./utils");
+
+var _config = require("./config");
+
+var _testConfigOperator = require("./config/testConfigOperator");
+
+var _hook = require("./hook");
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});

package/dist/js/node/base/runJest.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runJest = runJest;
+exports.runTest = runTest;
+
+var _yargs = _interopRequireDefault(require("yargs/yargs"));
+
+var _jest = require("jest");
+
+var _utils = require("@modern-js/utils");
+
+var _config = require("./config");
+
+var _utils2 = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @file run jest by nodejs API
+ * @description
+ * Jest does not provide node API to run jest.
+ * The followed code is inspired by
+ * https://github.com/facebook/jest/blob/fdc74af37235354e077edeeee8aa2d1a4a863032/packages/jest-cli/src/cli/index.ts#L21
+ */
+const buildArgv = async (rawArgv, config) => {
+  const argv = await (0, _yargs.default)(rawArgv).argv;
+  const result = {
+    $0: argv.$0,
+    _: argv._.slice(1)
+  };
+  Object.keys(argv).forEach(key => {
+    if (key.includes('-') || key === '_') {
+      return;
+    }
+
+    result[key] = argv[key];
+  });
+
+  if (config) {
+    result.config = JSON.stringify(config);
+  }
+
+  return result;
+};
+
+const readResultsAndExit = (result, globalConfig) => {
+  const code = !result || result.success ? 0 : globalConfig.testFailureExitCode; // Only exit if needed
+
+  process.on('exit', () => {
+    if (typeof code === 'number' && code !== 0) {
+      process.exitCode = code;
+    }
+  });
+
+  if (globalConfig.forceExit) {
+    if (!globalConfig.detectOpenHandles) {
+      console.warn(`${_utils.chalk.bold('Force exiting Jest: ')}Have you considered using \`--detectOpenHandles\` to detect ` + `async operations that kept running after all tests finished?`);
+    } // eslint-disable-next-line no-process-exit
+
+
+    process.exit(code);
+  } else if (!globalConfig.detectOpenHandles) {
+    setTimeout(() => {
+      console.warn(_utils.chalk.yellow.bold('Jest did not exit one second after the test run has completed.\n\n') + _utils.chalk.yellow('This usually means that there are asynchronous operations that ' + "weren't stopped in your tests. Consider running Jest with " + '`--detectOpenHandles` to troubleshoot this issue.'));
+    }, 1000).unref();
+  }
+};
+/**
+ * Node API: execute jest
+ */
+
+
+async function runJest(config, pwd = process.cwd()) {
+  try {
+    const argvConfig = await buildArgv(process.argv.slice(2), config);
+    const {
+      results,
+      globalConfig
+    } = await (0, _jest.runCLI)(argvConfig, [pwd]);
+    readResultsAndExit(results, globalConfig);
+  } catch (e) {
+    console.error(_utils.chalk.red((e === null || e === void 0 ? void 0 : e.stack) || e)); // eslint-disable-next-line no-process-exit
+
+    process.exit(1);
+  }
+}
+/**
+ * Node API: run test
+ */
+
+
+async function runTest(api, config, pwd = process.cwd()) {
+  process.env.NODE_ENV = 'test';
+  const jestUtils = (0, _config.getJestUtils)(config);
+  await (0, _config.patchConfig)(jestUtils); // 确保用户设置的配置可以被插件处理，比如设置在 projects 中
+
+  jestUtils.setJestUserConfig();
+  const hookRunners = api.useHookRunners();
+  const testConfigOperator = await hookRunners.jestConfig(jestUtils, {
+    onLast: input => input
+  });
+  const finalConfig = testConfigOperator.getFinalConfig();
+  (0, _utils2.debug)('Jest config:', finalConfig);
+  await runJest(finalConfig, pwd);
+  await hookRunners.afterTest();
+}

package/dist/js/node/base/utils.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readCompilerOptions = exports.getModuleNameMapper = exports.debug = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const debug = (0, _utils.createDebugger)('test');
+exports.debug = debug;
+
+/**
+ * Read `compilerOptions` in the current pwd's tsconfig.json file
+ */
+const readCompilerOptions = (pwd = process.cwd(), filename = 'tsconfig.json') => {
+  let tsConfig = {};
+  let extendedCompilerOptions = {};
+  let tsconfigFile = '';
+
+  try {
+    const maybeTsconfigFile = _path.default.join(pwd, filename);
+
+    if (_fs.default.existsSync(maybeTsconfigFile)) {
+      tsconfigFile = maybeTsconfigFile;
+    } else {
+      tsconfigFile = require.resolve(filename);
+    }
+
+    ({
+      config: tsConfig
+    } = require('typescript').parseConfigFileTextToJson(tsconfigFile, _fs.default.readFileSync(tsconfigFile, 'utf8')));
+  } catch (e) {
+    return {};
+  }
+
+  if (tsConfig.extends) {
+    extendedCompilerOptions = readCompilerOptions(_path.default.dirname(tsconfigFile), tsConfig.extends);
+  }
+
+  return _objectSpread(_objectSpread({}, extendedCompilerOptions), tsConfig.compilerOptions);
+};
+
+exports.readCompilerOptions = readCompilerOptions;
+
+const getModuleNameMapper = alias => Object.keys(alias).reduce((memo, cur) => {
+  const aliasValue = Array.isArray(alias[cur]) ? alias[cur] : [alias[cur]];
+  const isFile = aliasValue.some(s => s.endsWith('.js')); // It's special for if using @modern-js/runtime alias other module @modern-js/runtime/model would not work.
+
+  if (cur === '@modern-js/runtime$') {
+    memo[`.+${cur}`] = aliasValue[0];
+    return memo;
+  }
+
+  if (isFile) {
+    memo[cur] = aliasValue[0];
+  }
+
+  const key = `^${cur}/(.*)$`;
+
+  const value = _path.default.normalize(`${aliasValue}/$1`);
+
+  memo[key] = value;
+  return memo;
+}, {});
+
+exports.getModuleNameMapper = getModuleNameMapper;