@modern-js/plugin-testing 2.21.0 → 2.21.2-alpha.0

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

@@ -0,0 +1,4 @@
+var filemock_default = "test-file-stub";
+export {
+  filemock_default as default
+};

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

@@ -0,0 +1,34 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { patchTransformer } from "./transformer";
+import { patchAssetsModule } from "./assetsModule";
+const _applyPatches = (patches2, testOperator) => __async(void 0, null, function* () {
+  for (const patch of patches2) {
+    yield patch(testOperator);
+  }
+});
+const patches = [patchTransformer, patchAssetsModule];
+const applyPatches = (testConfig) => __async(void 0, null, function* () {
+  yield _applyPatches(patches, testConfig);
+});
+export {
+  applyPatches
+};

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

@@ -0,0 +1,38 @@
+import { readCompilerOptions } from "../../utils";
+const resolveTsCompilerOptions = () => {
+  const tsCompilerOptions = readCompilerOptions() || {};
+  const { jsx } = tsCompilerOptions;
+  if (!jsx) {
+    return null;
+  }
+  tsCompilerOptions.jsx = "react-jsx";
+  return tsCompilerOptions;
+};
+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
+        }
+      }
+    });
+  }
+};
+export {
+  patchTransformer
+};

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

@@ -0,0 +1,21 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+import enhanceResolve from "enhanced-resolve";
+var require_resolver = __commonJS({
+  "src/base/config/resolver.ts"(exports, module) {
+    const resolver = enhanceResolve.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);
+    };
+  }
+});
+export default require_resolver();

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

@@ -0,0 +1,69 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { merge } from "@modern-js/utils/lodash";
+class TestConfigOperator {
+  constructor(testConfig) {
+    this.defaultTestConfig = {
+      transformer: "babel-jest"
+    };
+    this._testConfig = testConfig;
+    this._jestConfig = {};
+    this.userJestConfig = testConfig.jest;
+    this.initial();
+  }
+  initial() {
+    this._testConfig = merge({}, this.defaultTestConfig, this.testConfig);
+  }
+  get jestConfig() {
+    return this._jestConfig;
+  }
+  get testConfig() {
+    return this._testConfig;
+  }
+  mergeJestConfig(sourceConfig) {
+    this._jestConfig = 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 = __spreadValues(__spreadValues({}, this._jestConfig), sourceConfig);
+  }
+  getFinalConfig() {
+    const { userJestConfig } = this;
+    if (!userJestConfig) {
+      return this._jestConfig;
+    }
+    if (typeof userJestConfig === "function") {
+      return userJestConfig(this._jestConfig);
+    }
+    return this.jestConfig;
+  }
+}
+export {
+  TestConfigOperator
+};

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

@@ -0,0 +1,19 @@
+var _a, _b;
+import babelJest from "babel-jest";
+const babelTransformer = (_b = (_a = babelJest).createTransformer) == null ? void 0 : _b.call(_a, {
+  presets: [
+    [
+      require.resolve("@modern-js/babel-preset-app"),
+      {
+        appDirectory: process.cwd(),
+        modules: "cjs"
+      }
+    ]
+  ],
+  configFile: false,
+  babelrc: false
+});
+var babelTransformer_default = babelTransformer;
+export {
+  babelTransformer_default as default
+};

package/dist/js/modern/base/hook.js

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

package/dist/js/modern/base/index.js

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

package/dist/js/modern/base/runJest.js

@@ -0,0 +1,102 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import yargs from "yargs/yargs";
+import { runCLI } from "jest";
+import { chalk } from "@modern-js/utils";
+import { getJestUtils, patchConfig } from "./config";
+import { debug } from "./utils";
+const buildArgv = (rawArgv, config) => __async(void 0, null, function* () {
+  const argv = yield yargs(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;
+  process.on("exit", () => {
+    if (typeof code === "number" && code !== 0) {
+      process.exitCode = code;
+    }
+  });
+  if (globalConfig.forceExit) {
+    if (!globalConfig.detectOpenHandles) {
+      console.warn(
+        `${chalk.bold(
+          "Force exiting Jest: "
+        )}Have you considered using \`--detectOpenHandles\` to detect async operations that kept running after all tests finished?`
+      );
+    }
+    process.exit(code);
+  } else if (!globalConfig.detectOpenHandles) {
+    setTimeout(() => {
+      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."
+        )
+      );
+    }, 1e3).unref();
+  }
+};
+function runJest(_0) {
+  return __async(this, arguments, function* (config, pwd = process.cwd()) {
+    try {
+      const argvConfig = yield buildArgv(process.argv.slice(2), config);
+      const { results, globalConfig } = yield runCLI(argvConfig, [pwd]);
+      readResultsAndExit(results, globalConfig);
+    } catch (e) {
+      console.error(chalk.red((e == null ? void 0 : e.stack) || e));
+      process.exit(1);
+    }
+  });
+}
+function runTest(_0, _1) {
+  return __async(this, arguments, function* (api, config, pwd = process.cwd()) {
+    process.env.NODE_ENV = "test";
+    const jestUtils = getJestUtils(config);
+    yield patchConfig(jestUtils);
+    jestUtils.setJestUserConfig();
+    const hookRunners = api.useHookRunners();
+    const testConfigOperator = yield hookRunners.jestConfig(jestUtils, {
+      onLast: (input) => input
+    });
+    const finalConfig = testConfigOperator.getFinalConfig();
+    debug("Jest config:", finalConfig);
+    yield runJest(finalConfig, pwd);
+    yield hookRunners.afterTest();
+  });
+}
+export {
+  runJest,
+  runTest
+};

package/dist/js/modern/base/utils.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import fs from "fs";
+import path from "path";
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger("test");
+const readCompilerOptions = (pwd = process.cwd(), filename = "tsconfig.json") => {
+  let tsConfig = {};
+  let extendedCompilerOptions = {};
+  let tsconfigFile = "";
+  try {
+    const maybeTsconfigFile = path.join(pwd, filename);
+    if (fs.existsSync(maybeTsconfigFile)) {
+      tsconfigFile = maybeTsconfigFile;
+    } else {
+      tsconfigFile = require.resolve(filename);
+    }
+    ({ config: tsConfig } = require("typescript").parseConfigFileTextToJson(
+      tsconfigFile,
+      fs.readFileSync(tsconfigFile, "utf8")
+    ));
+  } catch (e) {
+    return {};
+  }
+  if (tsConfig.extends) {
+    extendedCompilerOptions = readCompilerOptions(
+      path.dirname(tsconfigFile),
+      tsConfig.extends
+    );
+  }
+  return __spreadValues(__spreadValues({}, extendedCompilerOptions), tsConfig.compilerOptions);
+};
+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"));
+  if (cur === "@modern-js/runtime$") {
+    memo[`.+${cur}`] = aliasValue[0];
+    return memo;
+  }
+  if (isFile) {
+    memo[cur] = aliasValue[0];
+  }
+  const key = `^${cur}/(.*)$`;
+  const value = path.normalize(`${aliasValue}/$1`);
+  memo[key] = value;
+  return memo;
+}, {});
+export {
+  debug,
+  getModuleNameMapper,
+  readCompilerOptions
+};

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

@@ -0,0 +1,58 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { AsyncLocalStorage } from "async_hooks";
+import { Server } from "@modern-js/prod-server";
+const store = new AsyncLocalStorage();
+const isInHandler = () => Boolean(store.getStore());
+let server = null;
+const createApp = (pwd, config, plugins, routes) => __async(void 0, null, function* () {
+  if (!server) {
+    config.output.path = "./";
+    server = new Server({
+      apiOnly: true,
+      pwd,
+      config,
+      internalPlugins: plugins,
+      routes
+    });
+    yield server.init();
+  }
+  const app = server.getRequestHandler();
+  return app;
+});
+const getApp = () => {
+  if (!server) {
+    throw new Error("please createApp first");
+  }
+  return server.getRequestHandler();
+};
+const closeServer = () => __async(void 0, null, function* () {
+  if (!server) {
+    throw new Error("please createApp first");
+  }
+  yield server.close();
+});
+export {
+  closeServer,
+  createApp,
+  getApp,
+  isInHandler
+};

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

@@ -0,0 +1,4 @@
+const bff_info_key = "modern_bff_info";
+export {
+  bff_info_key
+};

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

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+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";
+const setJestConfigForBFF = (_0) => __async(void 0, [_0], function* ({
+  pwd,
+  userConfig,
+  plugins,
+  routes,
+  utils
+}) {
+  var _a;
+  const bffConfig = {
+    rootDir: path.join(pwd, "./api"),
+    setupFilesAfterEnv: [require.resolve("./setup")],
+    testEnvironment: "node",
+    testMatch: [`**/api/**/*.test.[jt]s`],
+    globals: {
+      "ts-jest": {
+        diagnostics: {
+          warnOnly: true
+        }
+      },
+      [bff_info_key]: {
+        appDir: pwd,
+        modernUserConfig: userConfig,
+        plugins,
+        routes
+      }
+    }
+  };
+  const { jestConfig } = utils;
+  const alias = ((_a = userConfig == null ? void 0 : userConfig.source) == null ? void 0 : _a.alias) || {};
+  const aliasMapper = getModuleNameMapper(alias);
+  const { moduleNameMapper } = jestConfig;
+  const transform = {
+    "\\.[jt]sx?$": require.resolve("ts-jest")
+  };
+  const apiOnly = yield isApiOnly(pwd);
+  const mergedModuleNameMapper = __spreadValues(__spreadValues({}, moduleNameMapper), aliasMapper);
+  const resolver = jestConfig.resolver || DEFAULT_RESOLVER_PATH;
+  const configFields = ["coverage", "collectCoverage", "testTimeout"];
+  const commonConfig = configFields.reduce((obj, field) => {
+    if (jestConfig.hasOwnProperty(field)) {
+      obj[field] = jestConfig[field];
+    }
+    return obj;
+  }, {});
+  if (!apiOnly) {
+    utils.setJestConfig(
+      {
+        projects: [
+          __spreadValues({}, jestConfig),
+          __spreadValues({
+            transform,
+            moduleNameMapper: mergedModuleNameMapper,
+            resolver
+          }, bffConfig)
+        ]
+      },
+      {
+        force: true
+      }
+    );
+  } else {
+    utils.setJestConfig(
+      {
+        projects: [
+          __spreadValues({
+            transform,
+            moduleNameMapper: mergedModuleNameMapper,
+            resolver
+          }, bffConfig)
+        ]
+      },
+      {
+        force: true
+      }
+    );
+  }
+  utils.setJestConfig(commonConfig);
+});
+var bff_default = () => ({
+  name: "@modern-js/testing-plugin-bff",
+  setup(api) {
+    return {
+      jestConfig: (utils, next) => __async(this, null, function* () {
+        const appContext = api.useAppContext();
+        const pwd = appContext.appDirectory;
+        if (!isBFFProject(pwd)) {
+          return next(utils);
+        }
+        const userConfig = api.useResolvedConfigContext();
+        yield setJestConfigForBFF({
+          pwd,
+          userConfig,
+          routes: appContext.serverRoutes,
+          plugins: appContext.serverInternalPlugins,
+          utils
+        });
+        return next(utils);
+      })
+    };
+  }
+});
+export {
+  bff_default as default,
+  setJestConfigForBFF
+};