@modern-js/plugin-testing 1.5.7-alpha.0 → 1.7.0

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

@@ -16,7 +16,7 @@ Object.defineProperty(exports, "renderApp", {
 Object.defineProperty(exports, "testBff", {
   enumerable: true,
   get: function () {
-    return _testingPluginBff.testBff;
+    return _request.request;
   }
 });
 
@@ -36,6 +36,6 @@ Object.keys(_react).forEach(function (key) {
   });
 });
 
-var _testingPluginBff = require("@modern-js/testing-plugin-bff");
+var _request = require("./request");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.request = request;
+
+var _supertest = _interopRequireDefault(require("supertest"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable eslint-comments/disable-enable-pair */
+function request(...args) {
+  const [fn, ...extraArgs] = args;
+
+  if (!fn) {
+    return (0, _supertest.default)(global.app);
+  }
+
+  fn.returnHttp = true;
+  const res = fn(...extraArgs);
+  fn.returnHttp = false;
+  return res;
+}

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

@@ -0,0 +1,40 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { applyPatches } from "./patches";
+import { TestConfigOperator } from "./testConfigOperator";
+/**
+ * Parse jest config
+ */
+
+var getJestUtils = function getJestUtils(testConfig) {
+  var testOperator = new TestConfigOperator(testConfig);
+  return testOperator;
+};
+
+var patchConfig = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(testOperator) {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return applyPatches(testOperator);
+
+          case 2:
+            return _context.abrupt("return", testOperator.jestConfig);
+
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function patchConfig(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+export var DEFAULT_RESOLVER_PATH = require.resolve("./resolver");
+export { getJestUtils, patchConfig };

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

@@ -0,0 +1,11 @@
+/**
+ * Merge config from testConfig.jest
+ */
+export var patchAssetsModule = function 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")
+    }
+  });
+};

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

@@ -0,0 +1 @@
+export default 'test-file-stub';

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

@@ -0,0 +1,85 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { patchTransformer } from "./transformer";
+import { patchAssetsModule } from "./assetsModule";
+
+var _applyPatches = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(patches, testOperator) {
+    var _iterator, _step, patch;
+
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _iterator = _createForOfIteratorHelper(patches);
+            _context.prev = 1;
+
+            _iterator.s();
+
+          case 3:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 9;
+              break;
+            }
+
+            patch = _step.value;
+            _context.next = 7;
+            return patch(testOperator);
+
+          case 7:
+            _context.next = 3;
+            break;
+
+          case 9:
+            _context.next = 14;
+            break;
+
+          case 11:
+            _context.prev = 11;
+            _context.t0 = _context["catch"](1);
+
+            _iterator.e(_context.t0);
+
+          case 14:
+            _context.prev = 14;
+
+            _iterator.f();
+
+            return _context.finish(14);
+
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[1, 11, 14, 17]]);
+  }));
+
+  return function _applyPatches(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var patches = [patchTransformer, patchAssetsModule];
+export var applyPatches = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(testConfig) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return _applyPatches(patches, testConfig);
+
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function applyPatches(_x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,45 @@
+import { readCompilerOptions } from "../../utils";
+
+var resolveTsCompilerOptions = function resolveTsCompilerOptions() {
+  var tsCompilerOptions = readCompilerOptions() || {};
+  var jsx = tsCompilerOptions.jsx;
+
+  if (!jsx) {
+    return null;
+  }
+
+  tsCompilerOptions.jsx = 'react-jsx';
+  return tsCompilerOptions;
+};
+/**
+ * Map `TestConfig.transformer` to jest config
+ */
+
+
+export var patchTransformer = function patchTransformer(testOperator) {
+  var transformer = testOperator.testConfig.transformer;
+
+  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')
+      }
+    });
+    var compilerOptions = resolveTsCompilerOptions();
+    compilerOptions && testOperator.mergeJestConfig({
+      globals: {
+        'ts-jest': {
+          tsconfig: compilerOptions
+        }
+      }
+    });
+  }
+};

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

@@ -0,0 +1,17 @@
+import enhanceResolve from 'enhanced-resolve';
+var resolver = enhanceResolve.create.sync({
+  conditionNames: ['require', 'node', 'default'],
+  extensions: ['.js', '.json', '.node', '.ts', '.tsx']
+});
+
+var shouldResolveByEnhance = function shouldResolveByEnhance(url) {
+  return /^@[^/]+\/[^/]+\/.*/.test(url);
+};
+
+module.exports = function (request, options) {
+  if (shouldResolveByEnhance(request)) {
+    return resolver(options.basedir, request);
+  }
+
+  return options.defaultResolver(request, options);
+};

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

@@ -0,0 +1,91 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { merge } from '@modern-js/utils/lodash';
+
+var TestConfigOperator = /*#__PURE__*/function () {
+  function TestConfigOperator(testConfig) {
+    _classCallCheck(this, TestConfigOperator);
+
+    _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();
+  }
+
+  _createClass(TestConfigOperator, [{
+    key: "initial",
+    value: function initial() {
+      this._testConfig = merge({}, this.defaultTestConfig, this.testConfig);
+    }
+  }, {
+    key: "jestConfig",
+    get: function get() {
+      return this._jestConfig;
+    }
+  }, {
+    key: "testConfig",
+    get: function get() {
+      return this._testConfig;
+    }
+  }, {
+    key: "mergeJestConfig",
+    value: function mergeJestConfig(sourceConfig) {
+      this._jestConfig = merge({}, this._jestConfig, sourceConfig);
+    }
+  }, {
+    key: "setJestUserConfig",
+    value: function setJestUserConfig() {
+      var userJestConfig = this.userJestConfig;
+
+      if (_typeof(userJestConfig) === 'object') {
+        this.setJestConfig(userJestConfig);
+      }
+    }
+  }, {
+    key: "setJestConfig",
+    value: function setJestConfig(sourceConfig, options) {
+      if (options) {
+        var force = options.force;
+
+        if (force) {
+          this._jestConfig = sourceConfig;
+          return;
+        }
+      }
+
+      this._jestConfig = _objectSpread(_objectSpread({}, this._jestConfig), sourceConfig);
+    }
+  }, {
+    key: "getFinalConfig",
+    value: function getFinalConfig() {
+      var userJestConfig = this.userJestConfig;
+
+      if (!userJestConfig) {
+        return this._jestConfig;
+      }
+
+      if (typeof userJestConfig === 'function') {
+        return userJestConfig(this._jestConfig);
+      }
+
+      return this.jestConfig;
+    }
+  }]);
+
+  return TestConfigOperator;
+}();
+
+export { TestConfigOperator };

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

@@ -0,0 +1,12 @@
+var _babelJest$createTran;
+
+import babelJest from 'babel-jest';
+var babelTransformer = (_babelJest$createTran = babelJest.createTransformer) === null || _babelJest$createTran === void 0 ? void 0 : _babelJest$createTran.call(babelJest, {
+  presets: [[require.resolve('@modern-js/babel-preset-app'), {
+    appDirectory: process.cwd(),
+    modules: 'cjs'
+  }]],
+  configFile: false,
+  babelrc: false
+});
+export default babelTransformer;

package/dist/js/treeshaking/base/hook.js

@@ -0,0 +1,7 @@
+import { createAsyncPipeline, createParallelWorkflow } from '@modern-js/plugin';
+export var jestConfigHook = createAsyncPipeline();
+export var afterTestHook = createParallelWorkflow();
+export var testingHooks = {
+  jestConfig: createAsyncPipeline(),
+  afterTest: createParallelWorkflow()
+};

package/dist/js/treeshaking/base/index.js

@@ -0,0 +1,6 @@
+export { runTest, runJest } from "./runJest";
+export { getModuleNameMapper } from "./utils";
+export { DEFAULT_RESOLVER_PATH } from "./config";
+export { TestConfigOperator } from "./config/testConfigOperator";
+export { testingHooks } from "./hook";
+export * from "./types";

package/dist/js/treeshaking/base/runJest.js

@@ -0,0 +1,194 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+
+/**
+ * @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
+ */
+import yargs from 'yargs/yargs';
+import { runCLI } from 'jest';
+import { chalk } from '@modern-js/utils';
+import { getJestUtils, patchConfig } from "./config";
+import { debug } from "./utils";
+
+var buildArgv = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(rawArgv, config) {
+    var argv, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return yargs(rawArgv).argv;
+
+          case 2:
+            argv = _context.sent;
+            result = {
+              $0: argv.$0,
+              _: argv._.slice(1)
+            };
+            Object.keys(argv).forEach(function (key) {
+              if (key.includes('-') || key === '_') {
+                return;
+              }
+
+              result[key] = argv[key];
+            });
+
+            if (config) {
+              result.config = JSON.stringify(config);
+            }
+
+            return _context.abrupt("return", result);
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function buildArgv(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var readResultsAndExit = function readResultsAndExit(result, globalConfig) {
+  var code = !result || result.success ? 0 : globalConfig.testFailureExitCode; // Only exit if needed
+
+  process.on('exit', function () {
+    if (typeof code === 'number' && code !== 0) {
+      process.exitCode = code;
+    }
+  });
+
+  if (globalConfig.forceExit) {
+    if (!globalConfig.detectOpenHandles) {
+      console.warn("".concat(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(function () {
+      console.warn(chalk.yellow.bold('Jest did not exit one second after the test run has completed.\n\n') + 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
+ */
+
+
+export function runJest(_x3) {
+  return _runJest.apply(this, arguments);
+}
+/**
+ * Node API: run test
+ */
+
+function _runJest() {
+  _runJest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(config) {
+    var pwd,
+        argvConfig,
+        _yield$runCLI,
+        results,
+        globalConfig,
+        _args2 = arguments;
+
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            pwd = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : process.cwd();
+            _context2.prev = 1;
+            _context2.next = 4;
+            return buildArgv(process.argv.slice(2), config);
+
+          case 4:
+            argvConfig = _context2.sent;
+            _context2.next = 7;
+            return runCLI(argvConfig, [pwd]);
+
+          case 7:
+            _yield$runCLI = _context2.sent;
+            results = _yield$runCLI.results;
+            globalConfig = _yield$runCLI.globalConfig;
+            readResultsAndExit(results, globalConfig);
+            _context2.next = 17;
+            break;
+
+          case 13:
+            _context2.prev = 13;
+            _context2.t0 = _context2["catch"](1);
+            console.error(chalk.red((_context2.t0 === null || _context2.t0 === void 0 ? void 0 : _context2.t0.stack) || _context2.t0)); // eslint-disable-next-line no-process-exit
+
+            process.exit(1);
+
+          case 17:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[1, 13]]);
+  }));
+  return _runJest.apply(this, arguments);
+}
+
+export function runTest(_x4, _x5) {
+  return _runTest.apply(this, arguments);
+}
+
+function _runTest() {
+  _runTest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(api, config) {
+    var pwd,
+        jestUtils,
+        hookRunners,
+        testConfigOperator,
+        finalConfig,
+        _args3 = arguments;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            pwd = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : process.cwd();
+            process.env.NODE_ENV = 'test';
+            jestUtils = getJestUtils(config);
+            _context3.next = 5;
+            return patchConfig(jestUtils);
+
+          case 5:
+            // 确保用户设置的配置可以被插件处理，比如设置在 projects 中
+            jestUtils.setJestUserConfig();
+            hookRunners = api.useHookRunners();
+            _context3.next = 9;
+            return hookRunners.jestConfig(jestUtils, {
+              onLast: function onLast(input) {
+                return input;
+              }
+            });
+
+          case 9:
+            testConfigOperator = _context3.sent;
+            finalConfig = testConfigOperator.getFinalConfig();
+            debug('Jest config:', finalConfig);
+            _context3.next = 14;
+            return runJest(finalConfig, pwd);
+
+          case 14:
+            _context3.next = 16;
+            return hookRunners.afterTest();
+
+          case 16:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _runTest.apply(this, arguments);
+}

package/dist/js/treeshaking/base/utils.js

@@ -0,0 +1,60 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import fs from 'fs';
+import path from 'path';
+import { createDebugger } from '@modern-js/utils';
+export var debug = createDebugger('test');
+
+/**
+ * Read `compilerOptions` in the current pwd's tsconfig.json file
+ */
+export var readCompilerOptions = function readCompilerOptions() {
+  var pwd = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : process.cwd();
+  var filename = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'tsconfig.json';
+  var tsConfig = {};
+  var extendedCompilerOptions = {};
+  var tsconfigFile = '';
+
+  try {
+    var maybeTsconfigFile = path.join(pwd, filename);
+
+    if (fs.existsSync(maybeTsconfigFile)) {
+      tsconfigFile = maybeTsconfigFile;
+    } else {
+      tsconfigFile = require.resolve(filename);
+    }
+
+    var _require$parseConfigF = require('typescript').parseConfigFileTextToJson(tsconfigFile, fs.readFileSync(tsconfigFile, 'utf8'));
+
+    tsConfig = _require$parseConfigF.config;
+  } catch (e) {
+    return {};
+  }
+
+  if (tsConfig["extends"]) {
+    extendedCompilerOptions = readCompilerOptions(path.dirname(tsconfigFile), tsConfig["extends"]);
+  }
+
+  return _objectSpread(_objectSpread({}, extendedCompilerOptions), tsConfig.compilerOptions);
+};
+export var getModuleNameMapper = function getModuleNameMapper(alias) {
+  return Object.keys(alias).reduce(function (memo, cur) {
+    var aliasValue = Array.isArray(alias[cur]) ? alias[cur] : [alias[cur]];
+    var isFile = aliasValue.some(function (s) {
+      return 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[".+".concat(cur)] = aliasValue[0];
+      return memo;
+    }
+
+    if (isFile) {
+      memo[cur] = aliasValue[0];
+    }
+
+    var key = "^".concat(cur, "/(.*)$");
+    var value = path.normalize("".concat(aliasValue, "/$1"));
+    memo[key] = value;
+    return memo;
+  }, {});
+};

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

@@ -0,0 +1,47 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { AsyncLocalStorage } from 'async_hooks';
+import { Server } from '@modern-js/server';
+var store = new AsyncLocalStorage();
+export var isInHandler = function isInHandler() {
+  return Boolean(store.getStore());
+};
+
+var createApp = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(pwd, config, plugins, routes) {
+    var server;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            config.output.path = './';
+            server = new Server({
+              apiOnly: true,
+              dev: {
+                watch: false
+              },
+              pwd: pwd,
+              config: config,
+              plugins: plugins,
+              routes: routes
+            });
+            _context.next = 4;
+            return server.init();
+
+          case 4:
+            return _context.abrupt("return", server.getRequestHandler());
+
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function createApp(_x, _x2, _x3, _x4) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+export { createApp };

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

@@ -0,0 +1 @@
+export var bff_info_key = 'modern_bff_info';