@modern-js/plugin-testing 1.0.0-rc.2

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = resolvePlugins;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 allowedFeatures = ['router', 'state'];
+
+function resolvePlugins(features) {
+  const plugins = [];
+
+  if (!features) {
+    return plugins;
+  }
+
+  Object.keys(features).forEach(feature => {
+    if (allowedFeatures.includes(feature)) {
+      const curPluginRes = require(`@modern-js/runtime/plugins`)[feature](_objectSpread({}, features[feature]));
+
+      plugins.push(curPluginRes);
+    }
+  });
+  return plugins;
+}

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

@@ -0,0 +1,54 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+import path from 'path';
+import { createPlugin, useAppContext } from '@modern-js/core';
+import { createRuntimeExportsUtils, PLUGIN_SCHEMAS } from '@modern-js/utils';
+import test from "./test";
+export default createPlugin(function () {
+  var testingExportsUtils;
+  return {
+    commands: function commands(_ref) {
+      var program = _ref.program;
+      program.command('test').allowUnknownOption().usage('[options]').action( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return test();
+
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      })));
+    },
+    validateSchema: function validateSchema() {
+      return PLUGIN_SCHEMAS['@modern-js/plugin-testing'];
+    },
+    config: function config() {
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      var _useAppContext = useAppContext(),
+          appContext = _useAppContext.value;
+
+      testingExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, 'testing');
+      return {
+        source: {
+          alias: {
+            '@modern-js/runtime/testing': testingExportsUtils.getPath()
+          }
+        }
+      };
+    },
+    addRuntimeExports: function addRuntimeExports() {
+      var testingPath = path.resolve(__dirname, '../');
+      testingExportsUtils.addExport("export * from '".concat(testingPath, "'"));
+    }
+  };
+}, {
+  name: '@modern-js/plugin-testing'
+});

package/dist/js/treeshaking/cli/plugins/modern.js

@@ -0,0 +1,47 @@
+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 { createPlugin } from '@modern-js/testing';
+import { modernjs_config_key } from "../../constant";
+
+var getModuleNameMapper = function getModuleNameMapper(config) {
+  var _config$resolve$alias = config.resolve.alias,
+      alias = _config$resolve$alias === void 0 ? {} : _config$resolve$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');
+    });
+
+    if (isFile) {
+      memo[cur] = aliasValue[0];
+    }
+
+    var key = "^".concat(cur, "/(.*)$");
+    var value = path.normalize("".concat(aliasValue, "/$1"));
+    memo[key] = value;
+    return memo;
+  }, {});
+};
+
+export default (function (webpackConfig, userConfig, pwd) {
+  return createPlugin(function () {
+    return {
+      jestConfig: function jestConfig(utils, next) {
+        utils.mergeJestConfig({
+          globals: _defineProperty({}, modernjs_config_key, userConfig),
+          moduleNameMapper: getModuleNameMapper(webpackConfig),
+          testEnvironment: 'jsdom',
+          resolver: require.resolve("../resolver")
+        });
+        utils.setJestConfig({
+          // todo: diffrent test root for diffrent solutions
+          testMatch: ["".concat(pwd || process.cwd(), "/(src|tests|api)/**/*.test.[jt]s?(x)")]
+        });
+        return next(utils);
+      }
+    };
+  }, {
+    name: '@modern-js/testing-plugin-modern'
+  });
+});

package/dist/js/treeshaking/cli/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/cli/test.js

@@ -0,0 +1,78 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+import path from 'path';
+import { compiler } from '@modern-js/babel-compiler';
+import { useAppContext, useResolvedConfigContext } from '@modern-js/core';
+import { runTest } from '@modern-js/testing';
+import { getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack'; // import testingBffPlugin from '@modern-js/testing-plugin-bff';
+
+import modernTestPlugin from "./plugins/modern";
+
+var test = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+    var _useResolvedConfigCon, userConfig, _useAppContext, config, webpackConfigs, runtimeExportsPath;
+
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            // eslint-disable-next-line react-hooks/rules-of-hooks
+            _useResolvedConfigCon = useResolvedConfigContext(), userConfig = _useResolvedConfigCon.value; // eslint-disable-next-line react-hooks/rules-of-hooks
+
+            _useAppContext = useAppContext(), config = _useAppContext.value; // todo: consider lib-tools ...
+
+            webpackConfigs = getWebpackConfig(WebpackConfigTarget.CLIENT);
+            userConfig.testing = userConfig.testing || {};
+            userConfig.testing.jest = userConfig.testing.jest || userConfig.tools.jest;
+            userConfig.testing.plugins = [].concat(_toConsumableArray(userConfig.testing.plugins || []), [modernTestPlugin(webpackConfigs, userConfig, config.appDirectory) // testingBffPlugin({
+            //   pwd: config.appDirectory,
+            //   userConfig: userConfig,
+            //   plugins: config.plugins.map(p => p.server).filter(Boolean),
+            //   routes: (config as any).serverRoutes
+            // }),
+            ]);
+            runtimeExportsPath = path.join(config.internalDirectory, '.runtime-exports');
+            _context.next = 9;
+            return compiler({
+              sourceDir: runtimeExportsPath,
+              rootDir: runtimeExportsPath,
+              distDir: runtimeExportsPath,
+              quiet: true
+            }, {
+              presets: [[require.resolve('@babel/preset-env'), {
+                modules: 'cjs'
+              }]]
+            });
+
+          case 9:
+            _context.next = 11;
+            return runTest(userConfig.testing);
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function test() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+export default test;

package/dist/js/treeshaking/constant.js

@@ -0,0 +1 @@
+export var modernjs_config_key = '__modernjs_config__';

package/dist/js/treeshaking/index.js

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom/extend-expect';
+export * from "./runtime-testing";

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

@@ -0,0 +1,64 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+import { createApp as _createApp } from '@modern-js/runtime-core';
+import resolvePlugins from "./resolvePlugins";
+import { modernjs_config_key } from "../constant";
+
+var ModernRuntime = /*#__PURE__*/function () {
+  function ModernRuntime(options) {
+    _classCallCheck(this, ModernRuntime);
+
+    this.options = void 0;
+    this.options = options;
+  }
+
+  _createClass(ModernRuntime, [{
+    key: "init",
+    value: function init(options) {
+      this.options = options;
+    }
+  }, {
+    key: "createApp",
+    value: function createApp(props) {
+      var _this$options;
+
+      var _ref = props || {},
+          entry = _ref.entry,
+          children = _ref.children;
+
+      var runtimeFeatures = (_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.runtime;
+
+      if (entry) {
+        var _this$options$runtime;
+
+        runtimeFeatures = _objectSpread(_objectSpread({}, runtimeFeatures || {}), (_this$options$runtime = this.options.runtimeByEntries) === null || _this$options$runtime === void 0 ? void 0 : _this$options$runtime[entry]);
+      }
+
+      var Component = function Component() {
+        if (!children) {
+          return null;
+        }
+
+        return children;
+      };
+
+      return _createApp({
+        plugins: resolvePlugins(runtimeFeatures || {})
+      })(Component);
+    }
+  }]);
+
+  return ModernRuntime;
+}();
+
+export default new ModernRuntime(global[modernjs_config_key] || {});

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

@@ -0,0 +1,21 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 React from 'react';
+import { render } from '@testing-library/react';
+import app from "./app";
+
+var WrapModernProviders = function WrapModernProviders(props) {
+  return /*#__PURE__*/React.createElement(app.createApp(props));
+};
+
+var customRender = function customRender(ui, options) {
+  return render(ui, _objectSpread({
+    wrapper: WrapModernProviders
+  }, options));
+};
+
+export default customRender;

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

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

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

@@ -0,0 +1,23 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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; }
+
+var allowedFeatures = ['router', 'state'];
+export default function resolvePlugins(features) {
+  var plugins = [];
+
+  if (!features) {
+    return plugins;
+  }
+
+  Object.keys(features).forEach(function (feature) {
+    if (allowedFeatures.includes(feature)) {
+      var curPluginRes = require("@modern-js/runtime/plugins")[feature](_objectSpread({}, features[feature]));
+
+      plugins.push(curPluginRes);
+    }
+  });
+  return plugins;
+}

package/dist/types/cli/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+
+export default _default;

package/dist/types/cli/plugins/modern.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (webpackConfig: any, userConfig: any, pwd: string) => any;
+
+export default _default;

package/dist/types/cli/resolver.d.ts

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

package/dist/types/cli/test.d.ts

@@ -0,0 +1,8 @@
+import { TestConfig } from '@modern-js/testing';
+declare module '@modern-js/core' {
+  interface UserConfig {
+    testing: TestConfig;
+  }
+}
+declare const test: () => Promise<void>;
+export default test;

package/dist/types/constant.d.ts

@@ -0,0 +1 @@
+export declare const modernjs_config_key = "__modernjs_config__";

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom/extend-expect';
+export * from './runtime-testing';

package/dist/types/runtime-testing/app.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { UserConfig } from '@modern-js/core';
+interface CreateAppProps {
+  entry?: string;
+  children?: React.ReactElement;
+}
+
+declare class ModernRuntime {
+  private options;
+  constructor(options: UserConfig);
+  init(options: UserConfig): void;
+  createApp(props?: CreateAppProps): React.ComponentType<any>;
+}
+
+declare const _default: ModernRuntime;
+
+export default _default;

package/dist/types/runtime-testing/customRender.d.ts

@@ -0,0 +1,5 @@
+import { render } from '@testing-library/react';
+
+declare const _default: typeof render;
+
+export default _default;

package/dist/types/runtime-testing/index.d.ts

@@ -0,0 +1,2 @@
+export { default as renderApp } from './customRender';
+export * from '@testing-library/react';

package/dist/types/runtime-testing/resolvePlugins.d.ts

@@ -0,0 +1,2 @@
+import { NormalizedConfig } from '@modern-js/core';
+export default function resolvePlugins(features: NormalizedConfig['runtime']): any[];

package/modern.config.js

@@ -0,0 +1,2 @@
+/** @type {import('@modern-js/module-tools').UserConfig} */
+module.exports = {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@modern-js/plugin-testing",
+  "version": "1.0.0-rc.2",
+  "jsnext:source": "./src/index.ts",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/js/node/index.js",
+  "module": "./dist/js/treeshaking/index.js",
+  "jsnext:modern": "./dist/js/modern/index.js",
+  "exports": {
+    "./cli": "./dist/js/node/cli/index.js"
+  },
+  "dependencies": {
+    "@babel/preset-env": "^7.15.6",
+    "@babel/runtime": "^7",
+    "@modern-js/babel-compiler": "^1.0.0-rc.2",
+    "@modern-js/core": "^1.0.0-rc.2",
+    "@modern-js/testing": "^1.0.0-rc.2",
+    "@modern-js/utils": "^1.0.0-rc.2",
+    "@modern-js/webpack": "^1.0.0-rc.2",
+    "@testing-library/jest-dom": "^5.14.1",
+    "@testing-library/react": "^12.0.0",
+    "enhanced-resolve": "^5.8.2"
+  },
+  "peerDependencies": {
+    "@modern-js/runtime-core": "^1.0.0-rc.2"
+  },
+  "devDependencies": {
+    "@modern-js/runtime-core": "^1.0.0-rc.2",
+    "@types/jest": "^26",
+    "@types/node": "^14",
+    "@types/react": "^17",
+    "@types/react-dom": "^17",
+    "typescript": "^4",
+    "@modern-js/plugin-testing": "^1.0.0-rc.2",
+    "@modern-js/module-tools": "^1.0.0-rc.2"
+  },
+  "sideEffects": false,
+  "modernConfig": {},
+  "scripts": {
+    "new": "modern new",
+    "build": "modern build",
+    "test": "modern test --passWithNoTests"
+  }
+}

package/src/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["@modern-js"]
+}

package/src/cli/index.ts

@@ -0,0 +1,48 @@
+import path from 'path';
+import { createPlugin, useAppContext } from '@modern-js/core';
+import { createRuntimeExportsUtils, PLUGIN_SCHEMAS } from '@modern-js/utils';
+import test from './test';
+
+export default createPlugin(
+  () => {
+    let testingExportsUtils: ReturnType<typeof createRuntimeExportsUtils>;
+
+    return {
+      commands: ({ program }: any) => {
+        program
+          .command('test')
+          .allowUnknownOption()
+          .usage('[options]')
+          .action(async () => {
+            await test();
+          });
+      },
+      validateSchema() {
+        return PLUGIN_SCHEMAS['@modern-js/plugin-testing'];
+      },
+      config() {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const { value: appContext } = useAppContext();
+
+        testingExportsUtils = createRuntimeExportsUtils(
+          appContext.internalDirectory,
+          'testing',
+        );
+
+        return {
+          source: {
+            alias: {
+              '@modern-js/runtime/testing': testingExportsUtils.getPath(),
+            },
+          },
+        };
+      },
+      addRuntimeExports() {
+        const testingPath = path.resolve(__dirname, '../');
+
+        testingExportsUtils.addExport(`export * from '${testingPath}'`);
+      },
+    };
+  },
+  { name: '@modern-js/plugin-testing' },
+) as any;

package/src/cli/plugins/modern.ts

@@ -0,0 +1,50 @@
+import path from 'path';
+import { createPlugin } from '@modern-js/testing';
+import { modernjs_config_key } from '@/constant';
+
+const getModuleNameMapper = (config: any) => {
+  const {
+    resolve: { alias = {} },
+  } = config;
+
+  return Object.keys(alias).reduce((memo, cur) => {
+    const aliasValue = Array.isArray(alias[cur]) ? alias[cur] : [alias[cur]];
+
+    const isFile = aliasValue.some((s: string) => s.endsWith('.js'));
+
+    if (isFile) {
+      memo[cur] = aliasValue[0];
+    }
+
+    const key = `^${cur}/(.*)$`;
+    const value = path.normalize(`${aliasValue}/$1`);
+    memo[key] = value;
+    return memo;
+  }, {} as any);
+};
+
+export default (webpackConfig: any, userConfig: any, pwd: string) =>
+  createPlugin(
+    () => ({
+      jestConfig: (utils: any, next: any) => {
+        utils.mergeJestConfig({
+          globals: {
+            [modernjs_config_key]: userConfig,
+          },
+          moduleNameMapper: getModuleNameMapper(webpackConfig),
+          testEnvironment: 'jsdom',
+          resolver: require.resolve('../resolver'),
+        });
+
+        utils.setJestConfig({
+          // todo: diffrent test root for diffrent solutions
+          testMatch: [`${pwd || process.cwd()}/(src|tests|api)/**/*.test.[jt]s?(x)`],
+        });
+
+        return next(utils);
+      },
+    }),
+    {
+      name: '@modern-js/testing-plugin-modern',
+    },
+  ) as any;

package/src/cli/resolver.ts

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

package/src/cli/test.ts

@@ -0,0 +1,66 @@
+import path from 'path';
+import { compiler } from '@modern-js/babel-compiler';
+import { useAppContext, useResolvedConfigContext } from '@modern-js/core';
+import { TestConfig, runTest } from '@modern-js/testing';
+import { getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack';
+// import testingBffPlugin from '@modern-js/testing-plugin-bff';
+import modernTestPlugin from './plugins/modern';
+
+declare module '@modern-js/core' {
+  interface UserConfig {
+    testing: TestConfig;
+  }
+}
+
+const test = async () => {
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const { value: userConfig } = useResolvedConfigContext();
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const { value: config } = useAppContext();
+
+  // todo: consider lib-tools ...
+  const webpackConfigs = getWebpackConfig(WebpackConfigTarget.CLIENT);
+
+  userConfig.testing = userConfig.testing || {};
+  userConfig.testing.jest =
+    userConfig.testing.jest || (userConfig.tools as any).jest;
+
+  userConfig.testing.plugins = [
+    ...(userConfig.testing.plugins || []),
+    modernTestPlugin(webpackConfigs, userConfig, config.appDirectory),
+    // testingBffPlugin({
+    //   pwd: config.appDirectory,
+    //   userConfig: userConfig,
+    //   plugins: config.plugins.map(p => p.server).filter(Boolean),
+    //   routes: (config as any).serverRoutes
+    // }),
+  ];
+
+  const runtimeExportsPath = path.join(
+    config.internalDirectory,
+    '.runtime-exports',
+  );
+
+  await compiler(
+    {
+      sourceDir: runtimeExportsPath,
+      rootDir: runtimeExportsPath,
+      distDir: runtimeExportsPath,
+      quiet: true,
+    },
+    {
+      presets: [
+        [
+          require.resolve('@babel/preset-env'),
+          {
+            modules: 'cjs',
+          },
+        ],
+      ],
+    },
+  );
+
+  await runTest(userConfig.testing);
+};
+
+export default test;

package/src/constant.ts

@@ -0,0 +1 @@
+export const modernjs_config_key = '__modernjs_config__';