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

package/mock-test.js

@@ -1,14 +1,49 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockTestRunner = void 0;
 var cp = require("child_process");
 var fs = require("fs");
-var ncp = require("child_process");
 var os = require("os");
 var path = require("path");
 var cmdm = require("./taskcommand");
 var shelljs = require("shelljs");
-var sync_request_1 = require("sync-request");
+var Downloader = require("nodejs-file-downloader");
 var COMMAND_TAG = '[command]';
 var COMMAND_LENGTH = COMMAND_TAG.length;
 var downloadDirectory = path.join(process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE, 'azure-pipelines-task-lib', '_download');
@@ -24,10 +59,42 @@ var MockTestRunner = /** @class */ (function () {
         this.succeeded = false;
         this.errorIssues = [];
         this.warningIssues = [];
+        if (testPath === undefined)
+            return;
         this._taskJsonPath = taskJsonPath || '';
         this._testPath = testPath;
-        this.nodePath = this.getNodePath();
     }
+    MockTestRunner.prototype.LoadAsync = function (testPath, taskJsonPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    if (this.nodePath != '') {
+                                        resolve(this);
+                                        return [2 /*return*/];
+                                    }
+                                    if (testPath) {
+                                        this._testPath = testPath;
+                                    }
+                                    if (taskJsonPath) {
+                                        this._taskJsonPath = taskJsonPath;
+                                    }
+                                    _a = this;
+                                    return [4 /*yield*/, this.getNodePath()];
+                                case 1:
+                                    _a.nodePath = _b.sent();
+                                    resolve(this);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
     Object.defineProperty(MockTestRunner.prototype, "failed", {
         get: function () {
             return !this.succeeded;
@@ -50,103 +117,125 @@ var MockTestRunner = /** @class */ (function () {
     MockTestRunner.prototype.stdErrContained = function (message) {
         return this.stderr.indexOf(message) > 0;
     };
-    MockTestRunner.prototype.run = function (nodeVersion) {
-        var _this = this;
-        this.cmdlines = {};
-        this.invokedToolCount = 0;
-        this.succeeded = true;
-        this.errorIssues = [];
-        this.warningIssues = [];
-        var nodePath = this.nodePath;
-        if (nodeVersion) {
-            nodePath = this.getNodePath(nodeVersion);
-        }
-        var spawn = cp.spawnSync(nodePath, [this._testPath]);
-        // Clean environment
-        Object.keys(process.env)
-            .filter(function (key) { return (key.substr(0, 'INPUT_'.length) === 'INPUT_' ||
-            key.substr(0, 'SECRET_'.length) === 'SECRET_' ||
-            key.substr(0, 'VSTS_TASKVARIABLE_'.length) === 'VSTS_TASKVARIABLE_'); })
-            .forEach(function (key) { return delete process.env[key]; });
-        if (spawn.error) {
-            console.error('Running test failed');
-            console.error(spawn.error.message);
-            return;
-        }
-        this.stdout = spawn.stdout.toString();
-        this.stderr = spawn.stderr.toString();
-        if (process.env['TASK_TEST_TRACE']) {
-            console.log('');
-        }
-        var lines = this.stdout.replace(/\r\n/g, '\n').split('\n');
-        var traceFile = this._testPath + '.log';
-        lines.forEach(function (line) {
-            var ci = line.indexOf('##vso[');
-            var cmd;
-            var cmi = line.indexOf(COMMAND_TAG);
-            if (ci >= 0) {
-                cmd = cmdm.commandFromString(line.substring(ci));
-                if (cmd.command === 'task.complete' && cmd.properties['result'] === 'Failed') {
-                    _this.succeeded = false;
+    MockTestRunner.prototype.runAsync = function (nodeVersion) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nodePath, spawn, lines, traceFile;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.cmdlines = {};
+                        this.invokedToolCount = 0;
+                        this.succeeded = true;
+                        this.errorIssues = [];
+                        this.warningIssues = [];
+                        nodePath = this.nodePath;
+                        if (!nodeVersion) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getNodePath(nodeVersion)];
+                    case 1:
+                        nodePath = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        if (!!nodePath) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.getNodePath()];
+                    case 3:
+                        nodePath = _a.sent();
+                        this.nodePath = nodePath;
+                        _a.label = 4;
+                    case 4:
+                        spawn = cp.spawnSync(nodePath, [this._testPath]);
+                        // Clean environment
+                        Object.keys(process.env)
+                            .filter(function (key) { return (key.substr(0, 'INPUT_'.length) === 'INPUT_' ||
+                            key.substr(0, 'SECRET_'.length) === 'SECRET_' ||
+                            key.substr(0, 'VSTS_TASKVARIABLE_'.length) === 'VSTS_TASKVARIABLE_'); })
+                            .forEach(function (key) { return delete process.env[key]; });
+                        if (spawn.error) {
+                            console.error('Running test failed');
+                            console.error(spawn.error.message);
+                            return [2 /*return*/];
+                        }
+                        this.stdout = spawn.stdout.toString();
+                        this.stderr = spawn.stderr.toString();
+                        if (process.env['TASK_TEST_TRACE']) {
+                            console.log('');
+                        }
+                        lines = this.stdout.replace(/\r\n/g, '\n').split('\n');
+                        traceFile = this._testPath + '.log';
+                        lines.forEach(function (line) {
+                            var ci = line.indexOf('##vso[');
+                            var cmd;
+                            var cmi = line.indexOf(COMMAND_TAG);
+                            if (ci >= 0) {
+                                cmd = cmdm.commandFromString(line.substring(ci));
+                                if (cmd.command === 'task.complete' && cmd.properties['result'] === 'Failed') {
+                                    _this.succeeded = false;
+                                }
+                                if (cmd.command === 'task.issue' && cmd.properties['type'] === 'error') {
+                                    _this.errorIssues.push(cmd.message.trim());
+                                }
+                                if (cmd.command === 'task.issue' && cmd.properties['type'] === 'warning') {
+                                    _this.warningIssues.push(cmd.message.trim());
+                                }
+                            }
+                            else if (cmi == 0 && line.length > COMMAND_LENGTH) {
+                                var cmdline = line.substr(COMMAND_LENGTH).trim();
+                                _this.cmdlines[cmdline] = true;
+                                _this.invokedToolCount++;
+                            }
+                            if (process.env['TASK_TEST_TRACE']) {
+                                fs.appendFileSync(traceFile, line + os.EOL);
+                                if (line && !cmd) {
+                                    console.log(line);
+                                }
+                                // don't print task.debug commands to console - too noisy.
+                                // otherwise omit command details - can interfere during CI.
+                                else if (cmd && cmd.command != 'task.debug') {
+                                    console.log("".concat(cmd.command, " details omitted"));
+                                }
+                            }
+                        });
+                        if (this.stderr && process.env['TASK_TEST_TRACE']) {
+                            console.log('STDERR: ' + this.stderr);
+                            fs.appendFileSync(traceFile, 'STDERR: ' + this.stderr + os.EOL);
+                        }
+                        if (process.env['TASK_TEST_TRACE']) {
+                            console.log('TRACE FILE: ' + traceFile);
+                        }
+                        return [2 /*return*/];
                 }
-                if (cmd.command === 'task.issue' && cmd.properties['type'] === 'error') {
-                    _this.errorIssues.push(cmd.message.trim());
-                }
-                if (cmd.command === 'task.issue' && cmd.properties['type'] === 'warning') {
-                    _this.warningIssues.push(cmd.message.trim());
-                }
-            }
-            else if (cmi == 0 && line.length > COMMAND_LENGTH) {
-                var cmdline = line.substr(COMMAND_LENGTH).trim();
-                _this.cmdlines[cmdline] = true;
-                _this.invokedToolCount++;
-            }
-            if (process.env['TASK_TEST_TRACE']) {
-                fs.appendFileSync(traceFile, line + os.EOL);
-                if (line && !cmd) {
-                    console.log(line);
-                }
-                // don't print task.debug commands to console - too noisy.
-                // otherwise omit command details - can interfere during CI.
-                else if (cmd && cmd.command != 'task.debug') {
-                    console.log(cmd.command + " details omitted");
-                }
-            }
+            });
         });
-        if (this.stderr && process.env['TASK_TEST_TRACE']) {
-            console.log('STDERR: ' + this.stderr);
-            fs.appendFileSync(traceFile, 'STDERR: ' + this.stderr + os.EOL);
-        }
-        if (process.env['TASK_TEST_TRACE']) {
-            console.log('TRACE FILE: ' + traceFile);
-        }
     };
     // Returns a path to node.exe with the correct version for this task (based on if its node10 or node)
     MockTestRunner.prototype.getNodePath = function (nodeVersion) {
-        var version = nodeVersion || this.getNodeVersion();
-        var downloadVersion;
-        switch (version) {
-            case 6:
-                downloadVersion = 'v6.17.1';
-                break;
-            case 10:
-                downloadVersion = 'v10.21.0';
-                break;
-            case 16:
-                downloadVersion = 'v16.13.0';
-                break;
-            default:
-                throw new Error('Invalid node version, must be 6, 10, or 16 (received ' + version + ')');
-        }
-        // Install node in home directory if it isn't already there.
-        var downloadDestination = path.join(downloadDirectory, 'node' + version);
-        var pathToExe = this.getPathToNodeExe(downloadVersion, downloadDestination);
-        if (pathToExe) {
-            return pathToExe;
-        }
-        else {
-            return this.downloadNode(downloadVersion, downloadDestination);
-        }
+        return __awaiter(this, void 0, void 0, function () {
+            var version, versions, downloadVersion, downloadDestination, pathToExe, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        version = nodeVersion || this.getNodeVersion();
+                        versions = {
+                            20: 'v20.13.1',
+                            16: 'v16.20.2',
+                            10: 'v10.24.1',
+                            6: 'v6.17.1',
+                        };
+                        downloadVersion = versions[version];
+                        if (!downloadVersion) {
+                            throw new Error('Invalid node version, must be 6, 10, 16 or 20 (received ' + version + ')');
+                        }
+                        downloadDestination = path.join(downloadDirectory, 'node' + version);
+                        pathToExe = this.getPathToNodeExe(downloadVersion, downloadDestination);
+                        if (!pathToExe) return [3 /*break*/, 1];
+                        return [2 /*return*/, pathToExe];
+                    case 1: return [4 /*yield*/, this.downloadNode(downloadVersion, downloadDestination)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
     };
     // Determines the correct version of node to use based on the contents of the task's task.json. Defaults to Node 16.
     MockTestRunner.prototype.getNodeVersion = function () {
@@ -157,29 +246,27 @@ var MockTestRunner = /** @class */ (function () {
         }
         var taskJsonContents = fs.readFileSync(taskJsonPath, { encoding: 'utf-8' });
         var taskJson = JSON.parse(taskJsonContents);
-        var nodeVersionFound = false;
-        var execution = (taskJson['execution']
-            || taskJson['prejobexecution']
-            || taskJson['postjobexecution']);
-        var keys = Object.keys(execution);
-        for (var i = 0; i < keys.length; i++) {
-            if (keys[i].toLowerCase() == 'node16') {
-                // Prefer node 16 and return immediately.
-                return 16;
-            }
-            else if (keys[i].toLowerCase() == 'node10') {
-                // Prefer node 10 and return immediately.
-                return 10;
-            }
-            else if (keys[i].toLowerCase() == 'node') {
-                nodeVersionFound = true;
+        var nodeVersion = 0;
+        var executors = ['execution', 'prejobexecution', 'postjobexecution'];
+        for (var _i = 0, executors_1 = executors; _i < executors_1.length; _i++) {
+            var executor = executors_1[_i];
+            if (!taskJson[executor])
+                continue;
+            for (var _a = 0, _b = Object.keys(taskJson[executor]); _a < _b.length; _a++) {
+                var key = _b[_a];
+                var currExecutor = key.toLocaleLowerCase();
+                if (!currExecutor.startsWith('node'))
+                    continue;
+                var version = currExecutor.replace('node', '');
+                var intVersion = parseInt(version) || 6; // node handler is node v6 by default
+                nodeVersion = Math.max(intVersion, nodeVersion);
             }
         }
-        if (!nodeVersionFound) {
+        if (nodeVersion === 0) {
             console.warn('Unable to determine execution type from task.json, defaulting to use Node 16');
             return 16;
         }
-        return 6;
+        return nodeVersion;
     };
     // Returns the path to the task.json for the task being tested. Returns null if unable to find it.
     // Searches by moving up the directory structure from the initial starting point and checking at each level.
@@ -201,65 +288,108 @@ var MockTestRunner = /** @class */ (function () {
     };
     // Downloads the specified node version to the download destination. Returns a path to node.exe
     MockTestRunner.prototype.downloadNode = function (nodeVersion, downloadDestination) {
-        shelljs.rm('-rf', downloadDestination);
-        var nodeUrl = process.env['TASK_NODE_URL'] || 'https://nodejs.org/dist';
-        nodeUrl = nodeUrl.replace(/\/$/, ''); // ensure there is no trailing slash on the base URL
-        var downloadPath = '';
-        switch (this.getPlatform()) {
-            case 'darwin':
-                this.downloadTarGz(nodeUrl + '/' + nodeVersion + '/node-' + nodeVersion + '-darwin-x64.tar.gz', downloadDestination);
-                downloadPath = path.join(downloadDestination, 'node-' + nodeVersion + '-darwin-x64', 'bin', 'node');
-                break;
-            case 'linux':
-                this.downloadTarGz(nodeUrl + '/' + nodeVersion + '/node-' + nodeVersion + '-linux-x64.tar.gz', downloadDestination);
-                downloadPath = path.join(downloadDestination, 'node-' + nodeVersion + '-linux-x64', 'bin', 'node');
-                break;
-            case 'win32':
-                this.downloadFile(nodeUrl + '/' + nodeVersion + '/win-x64/node.exe', downloadDestination, 'node.exe');
-                this.downloadFile(nodeUrl + '/' + nodeVersion + '/win-x64/node.lib', downloadDestination, 'node.lib');
-                downloadPath = path.join(downloadDestination, 'node.exe');
-        }
-        // Write marker to indicate download completed.
-        var marker = downloadDestination + '.completed';
-        fs.writeFileSync(marker, '');
-        return downloadPath;
+        return __awaiter(this, void 0, void 0, function () {
+            var nodeUrl, downloadPath, _a, marker;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        shelljs.rm('-rf', downloadDestination);
+                        nodeUrl = process.env['TASK_NODE_URL'] || 'https://nodejs.org/dist';
+                        nodeUrl = nodeUrl.replace(/\/$/, ''); // ensure there is no trailing slash on the base URL
+                        downloadPath = '';
+                        _a = this.getPlatform();
+                        switch (_a) {
+                            case 'darwin': return [3 /*break*/, 1];
+                            case 'linux': return [3 /*break*/, 3];
+                            case 'win32': return [3 /*break*/, 5];
+                        }
+                        return [3 /*break*/, 8];
+                    case 1: return [4 /*yield*/, this.downloadTarGz(nodeUrl + '/' + nodeVersion + '/node-' + nodeVersion + '-darwin-x64.tar.gz', downloadDestination)];
+                    case 2:
+                        _b.sent();
+                        downloadPath = path.join(downloadDestination, 'node-' + nodeVersion + '-darwin-x64', 'bin', 'node');
+                        return [3 /*break*/, 8];
+                    case 3: return [4 /*yield*/, this.downloadTarGz(nodeUrl + '/' + nodeVersion + '/node-' + nodeVersion + '-linux-x64.tar.gz', downloadDestination)];
+                    case 4:
+                        _b.sent();
+                        downloadPath = path.join(downloadDestination, 'node-' + nodeVersion + '-linux-x64', 'bin', 'node');
+                        return [3 /*break*/, 8];
+                    case 5: return [4 /*yield*/, this.downloadFile(nodeUrl + '/' + nodeVersion + '/win-x64/node.exe', downloadDestination, 'node.exe')];
+                    case 6:
+                        _b.sent();
+                        return [4 /*yield*/, this.downloadFile(nodeUrl + '/' + nodeVersion + '/win-x64/node.lib', downloadDestination, 'node.lib')];
+                    case 7:
+                        _b.sent();
+                        downloadPath = path.join(downloadDestination, 'node.exe');
+                        _b.label = 8;
+                    case 8:
+                        marker = downloadDestination + '.completed';
+                        fs.writeFileSync(marker, '');
+                        return [2 /*return*/, downloadPath];
+                }
+            });
+        });
     };
     // Downloads file to the downloadDestination, making any necessary folders along the way.
     MockTestRunner.prototype.downloadFile = function (url, downloadDestination, fileName) {
-        var filePath = path.join(downloadDestination, fileName);
-        if (!url) {
-            throw new Error('Parameter "url" must be set.');
-        }
-        if (!downloadDestination) {
-            throw new Error('Parameter "downloadDestination" must be set.');
-        }
-        console.log('Downloading file:', url);
-        shelljs.mkdir('-p', downloadDestination);
-        var result = sync_request_1.default('GET', url);
-        fs.writeFileSync(filePath, result.getBody());
+        return __awaiter(this, void 0, void 0, function () {
+            var downloader;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!url) {
+                            throw new Error('Parameter "url" must be set.');
+                        }
+                        if (!downloadDestination) {
+                            throw new Error('Parameter "downloadDestination" must be set.');
+                        }
+                        console.log('Downloading file:', url);
+                        shelljs.mkdir('-p', downloadDestination);
+                        downloader = new Downloader({
+                            url: url,
+                            directory: downloadDestination,
+                            fileName: fileName
+                        });
+                        return [4 /*yield*/, downloader.download()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     // Downloads tarGz to the download destination, making any necessary folders along the way.
     MockTestRunner.prototype.downloadTarGz = function (url, downloadDestination) {
-        if (!url) {
-            throw new Error('Parameter "url" must be set.');
-        }
-        if (!downloadDestination) {
-            throw new Error('Parameter "downloadDestination" must be set.');
-        }
-        var tarGzName = 'node.tar.gz';
-        this.downloadFile(url, downloadDestination, tarGzName);
-        // Extract file
-        var originalCwd = process.cwd();
-        process.chdir(downloadDestination);
-        try {
-            ncp.execSync("tar -xzf \"" + path.join(downloadDestination, tarGzName) + "\"");
-        }
-        catch (_a) {
-            throw new Error('Failed to unzip node tar.gz from ' + url);
-        }
-        finally {
-            process.chdir(originalCwd);
-        }
+        return __awaiter(this, void 0, void 0, function () {
+            var tarGzName, originalCwd;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!url) {
+                            throw new Error('Parameter "url" must be set.');
+                        }
+                        if (!downloadDestination) {
+                            throw new Error('Parameter "downloadDestination" must be set.');
+                        }
+                        tarGzName = 'node.tar.gz';
+                        return [4 /*yield*/, this.downloadFile(url, downloadDestination, tarGzName)];
+                    case 1:
+                        _a.sent();
+                        originalCwd = process.cwd();
+                        process.chdir(downloadDestination);
+                        try {
+                            cp.execSync("tar -xzf \"".concat(path.join(downloadDestination, tarGzName), "\""));
+                        }
+                        catch (_b) {
+                            throw new Error('Failed to unzip node tar.gz from ' + url);
+                        }
+                        finally {
+                            process.chdir(originalCwd);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     // Checks if node is installed at downloadDestination. If it is, returns a path to node.exe, otherwise returns null.
     MockTestRunner.prototype.getPathToNodeExe = function (nodeVersion, downloadDestination) {

package/mock-toolrunner.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import Q = require('q');
 import events = require('events');
 import ma = require('./mock-answer');
@@ -36,6 +37,12 @@ export declare class ToolRunner extends events.EventEmitter {
     line(val: string): ToolRunner;
     pipeExecOutputToTool(tool: ToolRunner): ToolRunner;
     private ignoreTempPath;
+    execAsync(options?: IExecOptions): Promise<number>;
+    /**
+     * Exec - use for long running tools where you need to stream live output as it runs
+     * @deprecated use `execAsync` instead
+     * @returns a promise with return code.
+     */
     exec(options?: IExecOptions): Q.Promise<number>;
     execSync(options?: IExecSyncOptions): IExecSyncResult;
 }