azure-pipelines-task-lib 4.4.0 → 5.0.0-preview.0

package/lib-mocker.d.ts

@@ -0,0 +1,17 @@
+export interface MockOptions {
+    useCleanCache?: boolean;
+    warnOnReplace?: boolean;
+    warnOnUnregistered?: boolean;
+}
+export declare function enable(opts: MockOptions): void;
+export declare function disable(): void;
+export declare function resetCache(): void;
+export declare function warnOnReplace(enable: boolean): void;
+export declare function warnOnUnregistered(enable: boolean): void;
+export declare function registerMock(mod: string, mock: any): void;
+export declare function deregisterMock(mod: string): void;
+export declare function deregisterAll(): void;
+export declare function registerAllowable(mod: string): void;
+export declare function registerAllowables(mods: string[]): void;
+export declare function deregisterAllowable(mod: string): void;
+export declare function deregisterAllowables(mods: any): void;

package/lib-mocker.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deregisterAllowables = exports.deregisterAllowable = exports.registerAllowables = exports.registerAllowable = exports.deregisterAll = exports.deregisterMock = exports.registerMock = exports.warnOnUnregistered = exports.warnOnReplace = exports.resetCache = exports.disable = exports.enable = void 0;
+var m = require('module');
+;
+var registeredMocks = {};
+var registeredAllowables = new Set();
+var originalLoader = null;
+var originalCache = {};
+var options = {};
+var defaultOptions = {
+    useCleanCache: false,
+    warnOnReplace: true,
+    warnOnUnregistered: true
+};
+function _getEffectiveOptions(opts) {
+    var options = {};
+    Object.keys(defaultOptions).forEach(function (key) {
+        if (opts && opts.hasOwnProperty(key)) {
+            options[key] = opts[key];
+        }
+        else {
+            options[key] = defaultOptions[key];
+        }
+    });
+    return options;
+}
+/*
+ * Loader function that used when hooking is enabled.
+ * if the requested module is registered as a mock, return the mock.
+ * otherwise, invoke the original loader + put warning in the output.
+ */
+function _hookedLoader(request, parent, isMain) {
+    if (!originalLoader) {
+        throw new Error("Loader has not been hooked");
+    }
+    if (registeredMocks.hasOwnProperty(request)) {
+        return registeredMocks[request];
+    }
+    if (!registeredAllowables.has(request) && options.warnOnUnregistered) {
+        console.warn("WARNING: loading non-allowed module: " + request);
+    }
+    return originalLoader(request, parent, isMain);
+}
+/**
+ * Remove references to modules in the cache from
+ * their parents' children.
+ */
+function _removeParentReferences() {
+    Object.keys(m._cache).forEach(function (k) {
+        var _a;
+        if (k.indexOf('\.node') === -1) {
+            // don't touch native modules, because they're special
+            var mod = m._cache[k];
+            var idx = (_a = mod === null || mod === void 0 ? void 0 : mod.parent) === null || _a === void 0 ? void 0 : _a.children.indexOf(mod);
+            if (idx > -1) {
+                mod.parent.children.splice(idx, 1);
+            }
+        }
+    });
+}
+/*
+ * Starting in node 0.12 node won't reload native modules
+ * The reason is that native modules can register themselves to be loaded automatically
+ * This will re-populate the cache with the native modules that have not been mocked
+ */
+function _repopulateNative() {
+    Object.keys(originalCache).forEach(function (k) {
+        if (k.indexOf('\.node') > -1 && !m._cache[k]) {
+            m._cache[k] = originalCache[k];
+        }
+    });
+}
+/*
+ * Enable function, hooking the Node loader with options.
+ */
+function enable(opts) {
+    if (originalLoader) {
+        // Already hooked
+        return;
+    }
+    options = _getEffectiveOptions(opts);
+    if (options.useCleanCache) {
+        originalCache = m._cache;
+        m._cache = {};
+        _repopulateNative();
+    }
+    originalLoader = m._load;
+    m._load = _hookedLoader;
+}
+exports.enable = enable;
+/*
+ * Disables mock loading, reverting to normal 'require' behaviour.
+ */
+function disable() {
+    if (!originalLoader)
+        return;
+    if (options.useCleanCache) {
+        Object.keys(m._cache).forEach(function (k) {
+            if (k.indexOf('\.node') > -1 && !originalCache[k]) {
+                originalCache[k] = m._cache[k];
+            }
+        });
+        _removeParentReferences();
+        m._cache = originalCache;
+        originalCache = {};
+    }
+    m._load = originalLoader;
+    originalLoader = null;
+}
+exports.disable = disable;
+/*
+* If the clean cache option is in effect, reset the module cache to an empty
+* state. Calling this function when the clean cache option is not in effect
+* will have no ill effects, but will do nothing.
+*/
+function resetCache() {
+    if (options.useCleanCache && originalCache) {
+        _removeParentReferences();
+        m._cache = {};
+        _repopulateNative();
+    }
+}
+exports.resetCache = resetCache;
+/*
+ * Enable or disable warnings to the console when previously registered mocks are replaced.
+ */
+function warnOnReplace(enable) {
+    options.warnOnReplace = enable;
+}
+exports.warnOnReplace = warnOnReplace;
+/*
+ * Enable or disable warnings to the console when modules are loaded that have
+ * not been registered as a mock.
+ */
+function warnOnUnregistered(enable) {
+    options.warnOnUnregistered = enable;
+}
+exports.warnOnUnregistered = warnOnUnregistered;
+/*
+ * Register a mock object for the specified module.
+ */
+function registerMock(mod, mock) {
+    if (options.warnOnReplace && registeredMocks.hasOwnProperty(mod)) {
+        console.warn("WARNING: Replacing existing mock for module: " + mod);
+    }
+    registeredMocks[mod] = mock;
+}
+exports.registerMock = registerMock;
+/*
+ * Deregister a mock object for the specified module.
+ */
+function deregisterMock(mod) {
+    if (registeredMocks.hasOwnProperty(mod)) {
+        delete registeredMocks[mod];
+    }
+}
+exports.deregisterMock = deregisterMock;
+/*
+ * Deregister all mocks.
+ */
+function deregisterAll() {
+    registeredMocks = {};
+    registeredAllowables = new Set();
+}
+exports.deregisterAll = deregisterAll;
+/*
+   Register a module as 'allowed'.
+   This will allow the module to be loaded without mock otherwise a warning would be thrown.
+ */
+function registerAllowable(mod) {
+    registeredAllowables.add(mod);
+}
+exports.registerAllowable = registerAllowable;
+/*
+ * Register an array of 'allowed' modules.
+ */
+function registerAllowables(mods) {
+    mods.forEach(function (mod) { return registerAllowable(mod); });
+}
+exports.registerAllowables = registerAllowables;
+/*
+ * Deregister a module as 'allowed'.
+ */
+function deregisterAllowable(mod) {
+    if (registeredAllowables.hasOwnProperty(mod)) {
+        registeredAllowables.delete(mod);
+    }
+}
+exports.deregisterAllowable = deregisterAllowable;
+/*
+ * Deregister an array of modules as 'allowed'.
+ */
+function deregisterAllowables(mods) {
+    mods.forEach(function (mod) {
+        deregisterAllowable(mod);
+    });
+}
+exports.deregisterAllowables = deregisterAllowables;

package/mock-run.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskMockRunner = void 0;
-var mockery = require("mockery");
 var im = require("./internal");
+var mocker = require("./lib-mocker");
 var TaskMockRunner = /** @class */ (function () {
     function TaskMockRunner(taskPath) {
         this._exports = {};
@@ -40,7 +40,7 @@ var TaskMockRunner = /** @class */ (function () {
     */
     TaskMockRunner.prototype.registerMock = function (modName, mod) {
         this._moduleCount++;
-        mockery.registerMock(modName, mod);
+        mocker.registerMock(modName, mod);
     };
     /**
     * Registers an override for a specific function on the mock "azure-pipelines-task-lib/task" instance.
@@ -62,9 +62,9 @@ var TaskMockRunner = /** @class */ (function () {
     */
     TaskMockRunner.prototype.run = function (noMockTask) {
         var _this = this;
-        // determine whether to enable mockery
+        // determine whether to enable mocker
         if (!noMockTask || this._moduleCount) {
-            mockery.enable({ warnOnUnregistered: false });
+            mocker.enable({ warnOnUnregistered: false });
         }
         // answers and exports not compatible with "noMockTask" mode
         if (noMockTask) {
@@ -82,7 +82,7 @@ var TaskMockRunner = /** @class */ (function () {
                 .forEach(function (key) {
                 tlm[key] = _this._exports[key];
             });
-            mockery.registerMock('azure-pipelines-task-lib/task', tlm);
+            mocker.registerMock('azure-pipelines-task-lib/task', tlm);
         }
         // run it
         require(this._taskPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azure-pipelines-task-lib",
-  "version": "4.4.0",
+  "version": "5.0.0-preview.0",
   "description": "Azure Pipelines Task SDK",
   "main": "./task.js",
   "typings": "./task.d.ts",
@@ -28,7 +28,6 @@
   "homepage": "https://github.com/Microsoft/azure-pipelines-task-lib",
   "dependencies": {
     "minimatch": "3.0.5",
-    "mockery": "^2.1.0",
     "q": "^1.5.1",
     "semver": "^5.1.0",
     "shelljs": "^0.8.5",
@@ -38,7 +37,6 @@
   "devDependencies": {
     "@types/minimatch": "3.0.3",
     "@types/mocha": "^9.1.1",
-    "@types/mockery": "^1.4.29",
     "@types/node": "^16.11.39",
     "@types/q": "^1.5.4",
     "@types/semver": "^7.3.4",

package/task.d.ts

@@ -58,7 +58,8 @@ export declare const setErrStream: typeof im._setErrStream;
  *                  from agent version 2.142.0 or higher (otherwise will no-op).
  * @returns         void
  */
-export declare function setResult(result: TaskResult, message: string, done?: boolean): void;
+export declare function setResult(result: TaskResult.Succeeded, message?: string, done?: boolean): void;
+export declare function setResult(result: Exclude<TaskResult, 'Succeeded'>, message: string, done?: boolean): void;
 export declare const setResourcePath: typeof im._setResourcePath;
 export declare const loc: typeof im._loc;
 export declare const getVariable: typeof im._getVariable;

package/task.js

@@ -63,22 +63,6 @@ var AgentHostedMode;
 //-----------------------------------------------------
 exports.setStdStream = im._setStdStream;
 exports.setErrStream = im._setErrStream;
-//-----------------------------------------------------
-// Results
-//-----------------------------------------------------
-/**
- * Sets the result of the task.
- * Execution will continue.
- * If not set, task will be Succeeded.
- * If multiple calls are made to setResult the most pessimistic call wins (Failed) regardless of the order of calls.
- *
- * @param result    TaskResult enum of Succeeded, SucceededWithIssues, Failed, Cancelled or Skipped.
- * @param message   A message which will be logged as an error issue if the result is Failed.
- * @param done      Optional. Instructs the agent the task is done. This is helpful when child processes
- *                  may still be running and prevent node from fully exiting. This argument is supported
- *                  from agent version 2.142.0 or higher (otherwise will no-op).
- * @returns         void
- */
 function setResult(result, message, done) {
     exports.debug('task result: ' + TaskResult[result]);
     // add an error issue