@eggjs/mock 7.0.0-beta.20 → 7.0.0-beta.21

package/dist/lib/cluster.js

@@ -1,7 +1,340 @@
-import "../mock_http_server-De0r07gr.js";
-import "../utils-MhP_Krx1.js";
-import "../supertest-Cg412Los.js";
-import "../format_options-LRnReKde.js";
-import { ClusterApplication, createCluster, restore } from "../cluster-CA_hr9eV.js";
-
-export { ClusterApplication, createCluster, restore };
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import os from 'node:os';
+import childProcess from 'node:child_process';
+import { once } from 'node:events';
+import { existsSync } from 'node:fs';
+import { Coffee } from 'coffee';
+import { Ready } from 'get-ready';
+import { request as supertestRequest } from "./supertest.js";
+import { sleep, rimrafSync } from "./utils.js";
+import { formatOptions } from "./format_options.js";
+const debug = debuglog('egg/mock/lib/cluster');
+const clusters = new Map();
+globalThis.eggMockMasterPort = 17000 + (process.pid % 1000);
+let serverBin = path.join(import.meta.dirname, 'start-cluster.js');
+if (!existsSync(serverBin)) {
+    serverBin = path.join(import.meta.dirname, 'start-cluster.ts');
+}
+let requestCallFunctionFile = path.join(import.meta.dirname, 'request_call_function.js');
+if (!existsSync(requestCallFunctionFile)) {
+    requestCallFunctionFile = path.join(import.meta.dirname, 'request_call_function.ts');
+}
+/**
+ * A cluster version of egg.Application, you can test with supertest
+ * @example
+ * ```js
+ * const mm = require('mm');
+ * const request = require('supertest');
+ *
+ * describe('ClusterApplication', () => {
+ *   let app;
+ *   before(function (done) {
+ *     app = mm.cluster({ baseDir });
+ *     app.ready(done);
+ *   });
+ *
+ *   after(function () {
+ *     app.close();
+ *   });
+ *
+ *   it('should 200', function (done) {
+ *     request(app.callback())
+ *     .get('/')
+ *     .expect(200, done);
+ *   });
+ * });
+ */
+export class ClusterApplication extends Coffee {
+    options;
+    port;
+    baseDir;
+    closed;
+    _address;
+    /**
+     * @class
+     * @param {Object} options
+     * - {String} baseDir - The directory of the application
+     * - {Object} plugins - Custom you plugins
+     * - {String} framework - The directory of the egg framework
+     * - {Boolean} [cache=true] - Cache application based on baseDir
+     * - {Boolean} [coverage=true] - Switch on process coverage, but it'll be slower
+     * - {Boolean} [clean=true] - Remove $baseDir/logs
+     * - {Object}  [opt] - opt pass to coffee, such as { execArgv: ['--debug'] }
+     * ```
+     */
+    constructor(options) {
+        const opt = options.opt;
+        delete options.opt;
+        // incremental port
+        options.port = options.port ?? ++globalThis.eggMockMasterPort;
+        // Set 1 worker when test
+        if (!options.workers) {
+            options.workers = 1;
+        }
+        const args = [JSON.stringify(options)];
+        debug('fork %s, args: %s, opt: %j', serverBin, args.join(' '), opt);
+        super({
+            method: 'fork',
+            cmd: serverBin,
+            args,
+            opt,
+        });
+        Ready.mixin(this);
+        this.port = options.port;
+        this.baseDir = options.baseDir;
+        // print stdout and stderr when DEBUG, otherwise stderr.
+        this.debug(process.env.DEBUG ? 0 : 2);
+        // disable coverage
+        if (options.coverage === false) {
+            this.coverage(false);
+        }
+        process.nextTick(() => {
+            this.proc.on('message', (msg) => {
+                // 'egg-ready' and { action: 'egg-ready' }
+                const action = msg && msg.action ? msg.action : msg;
+                switch (action) {
+                    case 'egg-ready':
+                        // data: { port: 17703, address: 'http://127.0.0.1:17703', protocol: 'http' }
+                        debug('on message egg-ready %o', msg);
+                        this._address = msg.data.address;
+                        this.emit('close', 0);
+                        break;
+                    case 'app-worker-died':
+                    case 'agent-worker-died':
+                        this.emit('close', 1);
+                        break;
+                    default:
+                        // ignore it
+                        break;
+                }
+            });
+        });
+        this.end(() => this.ready(true));
+    }
+    /**
+     * the process that forked
+     * @member {ChildProcess}
+     */
+    get process() {
+        return this.proc;
+    }
+    /**
+     * Compatible API for supertest
+     */
+    callback() {
+        return this;
+    }
+    /**
+     * Compatible API for supertest
+     * @member {String} url
+     * @private
+     */
+    get url() {
+        if (this._address) {
+            return this._address;
+        }
+        return 'http://127.0.0.1:' + this.port;
+    }
+    /**
+     * Compatible API for supertest
+     */
+    address() {
+        return {
+            port: this.port,
+            address: this._address,
+        };
+    }
+    /**
+     * Compatible API for supertest
+     */
+    listen() {
+        return this;
+    }
+    /**
+     * kill the process
+     */
+    async close() {
+        this.closed = true;
+        const proc = this.proc;
+        const baseDir = this.baseDir;
+        if (proc?.connected) {
+            proc.kill('SIGTERM');
+            await once(proc, 'exit');
+        }
+        clusters.delete(baseDir);
+        debug('delete cluster cache %s, remain %s', baseDir, [...clusters.keys()]);
+        if (os.platform() === 'win32') {
+            await sleep(1000);
+        }
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    // mock app.router.pathFor(name) api
+    get router() {
+        const self = this;
+        return {
+            pathFor(url) {
+                return self._callFunctionOnAppWorker('pathFor', [url], 'router', true);
+            },
+        };
+    }
+    /**
+     * get app[property] value in app worker
+     */
+    getAppInstanceProperty(property) {
+        return this._callFunctionOnAppWorker('__getter__', [], property, true);
+    }
+    /**
+     * collection logger message, then can be use on `expectLog()`
+     * it's different from `app.expectLog()`, only support string params.
+     *
+     * @param {String} [logger] - logger instance name, default is `logger`
+     * @function ClusterApplication#expectLog
+     */
+    mockLog(logger) {
+        logger = logger ?? 'logger';
+        this._callFunctionOnAppWorker('mockLog', [logger], null, true);
+    }
+    /**
+     * expect str in the logger
+     * it's different from `app.expectLog()`, only support string params.
+     *
+     * @param {String} str - test str
+     * @param {String} [logger] - logger instance name, default is `logger`
+     * @function ClusterApplication#expectLog
+     */
+    expectLog(str, logger) {
+        logger = logger ?? 'logger';
+        this._callFunctionOnAppWorker('expectLog', [str, logger], null, true);
+    }
+    /**
+     * not expect str in the logger
+     * it's different from `app.notExpectLog()`, only support string params.
+     *
+     * @param {String} str - test str
+     * @param {String} [logger] - logger instance name, default is `logger`
+     * @function ClusterApplication#notExpectLog
+     */
+    notExpectLog(str, logger) {
+        logger = logger ?? 'logger';
+        this._callFunctionOnAppWorker('notExpectLog', [str, logger], null, true);
+    }
+    httpRequest() {
+        return supertestRequest(this);
+    }
+    _callFunctionOnAppWorker(method, args = [], property = undefined, needResult = false) {
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (typeof arg === 'function') {
+                args[i] = {
+                    __egg_mock_type: 'function',
+                    value: arg.toString(),
+                };
+            }
+            else if (arg instanceof Error) {
+                const errObject = {
+                    __egg_mock_type: 'error',
+                    name: arg.name,
+                    message: arg.message,
+                    stack: arg.stack,
+                };
+                for (const key in arg) {
+                    if (key !== 'name' && key !== 'message' && key !== 'stack') {
+                        errObject[key] = arg[key];
+                    }
+                }
+                args[i] = errObject;
+            }
+        }
+        const data = {
+            port: this.port,
+            method,
+            args,
+            property,
+            needResult,
+        };
+        const child = childProcess.spawnSync(process.execPath, [requestCallFunctionFile, JSON.stringify(data)], {
+            stdio: 'pipe',
+        });
+        // if (child.stderr && child.stderr.length > 0) {
+        //   console.error(child.stderr.toString());
+        // }
+        let result;
+        if (child.stdout && child.stdout.length > 0) {
+            if (needResult) {
+                result = JSON.parse(child.stdout.toString());
+            }
+            else {
+                console.error(child.stdout.toString());
+            }
+        }
+        if (child.status !== 0) {
+            throw new Error(child.stderr.toString());
+        }
+        if (child.error) {
+            throw child.error;
+        }
+        return result;
+    }
+}
+export function createCluster(initOptions) {
+    const options = formatOptions(initOptions);
+    if (options.cache && clusters.has(options.baseDir)) {
+        const clusterApp = clusters.get(options.baseDir);
+        // return cache when it hasn't been killed
+        if (!clusterApp.isClosed) {
+            return clusterApp;
+        }
+        // delete the cache when it's closed
+        clusters.delete(options.baseDir);
+    }
+    if (options.clean !== false) {
+        const logDir = path.join(options.baseDir, 'logs');
+        try {
+            rimrafSync(logDir);
+        }
+        catch (err) {
+            console.error(`remove log dir ${logDir} failed: ${err.stack}`);
+        }
+        const runDir = path.join(options.baseDir, 'run');
+        try {
+            rimrafSync(runDir);
+        }
+        catch (err) {
+            console.error(`remove run dir ${runDir} failed: ${err.stack}`);
+        }
+    }
+    let clusterApp = new ClusterApplication(options);
+    clusterApp = new Proxy(clusterApp, {
+        get(target, prop) {
+            debug('proxy handler.get %s', prop);
+            // proxy mockXXX function to app worker
+            const method = prop;
+            if (typeof method === 'string' && /^mock\w+$/.test(method) && target[method] === undefined) {
+                return function mockProxy(...args) {
+                    return target._callFunctionOnAppWorker(method, args, null, true);
+                };
+            }
+            return target[prop];
+        },
+    });
+    clusters.set(options.baseDir, clusterApp);
+    return clusterApp;
+}
+// export to let mm.restore() worked
+export async function restore() {
+    for (const clusterApp of clusters.values()) {
+        // will proxy to app.mockRestore()
+        await clusterApp.mockRestore();
+    }
+}
+// ensure to close App process on test exit.
+process.on('exit', () => {
+    for (const clusterApp of clusters.values()) {
+        debug('on exit close clusterApp, port: %s', clusterApp.port);
+        clusterApp.close();
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"","sources":["../../src/lib/cluster.ts"],"names":[],"mappings":"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"}

package/dist/lib/context.d.ts

@@ -1,4 +1 @@
-//#region src/lib/context.d.ts
-declare const context: any;
-//#endregion
-export { context };
+export declare const context: any;

package/dist/lib/context.js

@@ -1,3 +1,11 @@
-import { context } from "../context-BIduDy1M.js";
-
-export { context };
+export const context = {
+    runInBackground(scope) {
+        const taskName = scope._name || scope.name;
+        if (taskName) {
+            scope._name = taskName;
+        }
+        const promise = this._runInBackground(scope);
+        this.app._backgroundTasks.push(promise);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWIvY29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUc7SUFDckIsZUFBZSxDQUFDLEtBQVU7UUFDeEIsTUFBTSxRQUFRLEdBQUcsS0FBSyxDQUFDLEtBQUssSUFBSSxLQUFLLENBQUMsSUFBSSxDQUFDO1FBQzNDLElBQUksUUFBUSxFQUFFLENBQUM7WUFDYixLQUFLLENBQUMsS0FBSyxHQUFHLFFBQVEsQ0FBQztRQUN6QixDQUFDO1FBRUQsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzdDLElBQUksQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzFDLENBQUM7Q0FDSyxDQUFDIn0=

package/dist/lib/format_options.d.ts

@@ -1,10 +1,5 @@
-import "../mock_httpclient-1EgQkMxi.js";
-import { MockApplicationOptions, MockOptions } from "../types-CjZ-JeCo.js";
-
-//#region src/lib/format_options.d.ts
+import type { MockOptions, MockApplicationOptions } from './types.ts';
 /**
  * format the options
  */
-declare function formatOptions(initOptions?: MockOptions): MockApplicationOptions;
-//#endregion
-export { formatOptions };
+export declare function formatOptions(initOptions?: MockOptions): MockApplicationOptions;

package/dist/lib/format_options.js

@@ -1,4 +1,93 @@
-import "../utils-MhP_Krx1.js";
-import { formatOptions } from "../format_options-LRnReKde.js";
-
-export { formatOptions };
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import { mm, isMocked } from 'mm';
+import { getFrameworkPath } from '@eggjs/utils';
+import { readJSONSync } from 'utility';
+import { getSourceDirname } from "./utils.js";
+const debug = debuglog('egg/mock/lib/format_options');
+/**
+ * format the options
+ */
+export function formatOptions(initOptions) {
+    const options = {
+        baseDir: process.cwd(),
+        cache: true,
+        coverage: true,
+        clean: true,
+        ...initOptions,
+    };
+    // relative path to test/fixtures
+    // ```js
+    // formatOptions({ baseDir: 'app' }); // baseDir => $PWD/test/fixtures/app
+    // ```
+    if (!path.isAbsolute(options.baseDir)) {
+        options.baseDir = path.join(process.cwd(), 'test/fixtures', options.baseDir);
+    }
+    let framework = initOptions?.framework ?? initOptions?.customEgg;
+    // test for framework
+    if (framework === true) {
+        framework = process.cwd();
+        // disable plugin test when framework test
+        options.plugin = false;
+    }
+    else {
+        if (!framework) {
+            framework = '';
+        }
+        // it will throw when framework is not found
+        framework = getFrameworkPath({ framework, baseDir: options.baseDir });
+    }
+    options.framework = options.customEgg = framework;
+    const plugins = (options.plugins = options.plugins || {});
+    // add self as a plugin
+    let pluginPath = path.join(getSourceDirname(), '..');
+    // for dist directory
+    // convert `/eggjs/mock/dist` to `/eggjs/mock`
+    if (pluginPath.endsWith('/dist') || pluginPath.endsWith('\\dist')) {
+        pluginPath = path.join(pluginPath, '..');
+    }
+    plugins['egg-mock'] = {
+        enable: true,
+        path: pluginPath,
+    };
+    // test for plugin
+    if (options.plugin !== false) {
+        // add self to plugin list
+        const pluginPath = process.cwd();
+        const pkgPath = path.join(pluginPath, 'package.json');
+        const pluginName = getPluginName(pkgPath);
+        if (options.plugin && !pluginName) {
+            throw new Error(`should set "eggPlugin" property in ${pkgPath}`);
+        }
+        if (pluginName) {
+            plugins[pluginName] = {
+                enable: true,
+                path: pluginPath,
+            };
+        }
+    }
+    // mock HOME as baseDir, but ignore if it has been mocked
+    const env = process.env.EGG_SERVER_ENV;
+    if (!isMocked(process.env, 'HOME') && (env === 'default' || env === 'test' || env === 'prod')) {
+        mm(process.env, 'HOME', options.baseDir);
+    }
+    // disable cache after call mm.env(),
+    // otherwise it will use cache and won't load again.
+    if (process.env.EGG_MOCK_SERVER_ENV) {
+        options.cache = false;
+    }
+    debug('[formatOptions] options: %j', options);
+    return options;
+}
+function getPluginName(pkgPath) {
+    try {
+        const pkg = readJSONSync(pkgPath);
+        if (pkg.eggPlugin?.name) {
+            return pkg.eggPlugin.name;
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/inject_context.d.ts

@@ -1,9 +1,6 @@
-//#region src/lib/inject_context.d.ts
 /**
  * Monkey patch the mocha instance with egg context.
  *
  * @param {Function} mocha - the module of mocha
  */
-declare function injectContext(mocha: any): void;
-//#endregion
-export { injectContext };
+export declare function injectContext(mocha: any): void;