Merge pull request #4829 from jeffyoung/users/jeyou/jenkins-download-artifacts

Users/jeyou/jenkins download artifacts

Author: Jeff Young

Tasks/JenkinsDownloadArtifacts/Tests/L0.ts

@@ -0,0 +1,86 @@
+// npm install mocha --save-dev
+// typings install dt~mocha --save --global
+
+import assert = require('assert');
+import path = require('path');
+import os = require('os');
+import process = require('process');
+import fs = require('fs');
+
+import * as ttm from 'vsts-task-lib/mock-test';
+
+describe('JenkinsDownloadArtifacts L0 Suite', function () {
+    this.timeout(20000);
+
+    before((done) => {
+        process.env['ENDPOINT_AUTH_ID1'] = '{\"scheme\":\"UsernamePassword\", \"parameters\": {\"username\": \"uname\", \"password\": \"pword\"}}';
+        process.env['ENDPOINT_URL_ID1'] = 'bogusURL';
+
+        done();
+    });
+
+    /* tslint:disable:no-empty */
+    after(function () { });
+    /* tslint:enable:no-empty */
+
+    it('run JenkinsDownloadArtifacts with no server endpoint', (done) => {
+        const tp: string = path.join(__dirname, 'L0NoServerEndpoint.js');
+        const tr: ttm.MockTestRunner = new ttm.MockTestRunner(tp);
+
+        try {
+            tr.run();
+
+            assert(tr.stderr.indexOf('Input required: serverEndpoint') !== -1, 'should have written to stderr');
+            assert(tr.failed, 'task should have failed');
+            done();
+
+            //assert(tr.ran(gradleWrapper + ' build'), 'it should have run gradlew build');
+            //assert(tr.invokedToolCount === 1, 'should have only run gradle 1 time');
+            //assert(tr.stderr.length === 0, 'should not have written to stderr');
+            //assert(tr.succeeded, 'task should have succeeded');
+            //assert(tr.stdout.indexOf('GRADLE_OPTS is now set to -Xmx2048m') > 0);
+        } catch (err) {
+            console.log(tr.stdout);
+            console.log(tr.stderr);
+            console.log(err);
+            done(err);
+        }
+    });
+
+    it('run JenkinsDownloadArtifacts with no save to', (done) => {
+        const tp: string = path.join(__dirname, 'L0NoSaveTo.js');
+        const tr: ttm.MockTestRunner = new ttm.MockTestRunner(tp);
+
+        try {
+            tr.run();
+
+            assert(tr.stderr.indexOf('Input required: saveTo') !== -1, 'should have written to stderr');
+            assert(tr.failed, 'task should have failed');
+            done();
+        } catch (err) {
+            console.log(tr.stdout);
+            console.log(tr.stderr);
+            console.log(err);
+            done(err);
+        }
+    });
+
+    it('run JenkinsDownloadArtifacts with no job name', (done) => {
+        const tp: string = path.join(__dirname, 'L0NoJobName.js');
+        const tr: ttm.MockTestRunner = new ttm.MockTestRunner(tp);
+
+        try {
+            tr.run();
+
+            assert(tr.stderr.indexOf('Input required: jobName') !== -1, 'should have written to stderr');
+            assert(tr.failed, 'task should have failed');
+            done();
+        } catch (err) {
+            console.log(tr.stdout);
+            console.log(tr.stderr);
+            console.log(err);
+            done(err);
+        }
+    });
+
+});

Tasks/JenkinsDownloadArtifacts/Tests/L0NoJobName.ts

@@ -0,0 +1,22 @@
+import ma = require('vsts-task-lib/mock-answer');
+import tmrm = require('vsts-task-lib/mock-run');
+import path = require('path');
+
+const taskPath = path.join(__dirname, '..', 'jenkinsdownloadartifacts.js');
+const tr: tmrm.TaskMockRunner = new tmrm.TaskMockRunner(taskPath);
+
+tr.setInput('serverEndpoint', 'ID1');
+//tr.setInput('jobName', 'SomeJobName');
+tr.setInput('saveTo', path.join(__dirname, '..', 'tmp/'));
+tr.setInput('jenkinsBuild', 'LastSuccessfulBuild'); //BuildNumber
+
+// provide answers for task mock
+const a: ma.TaskLibAnswers = <ma.TaskLibAnswers>{
+    'checkPath': {
+        'gradlew': true,
+        'gradlew.bat': true
+    }
+};
+tr.setAnswers(a);
+
+tr.run();

Tasks/JenkinsDownloadArtifacts/Tests/L0NoSaveTo.ts

@@ -0,0 +1,22 @@
+import ma = require('vsts-task-lib/mock-answer');
+import tmrm = require('vsts-task-lib/mock-run');
+import path = require('path');
+
+const taskPath = path.join(__dirname, '..', 'jenkinsdownloadartifacts.js');
+const tr: tmrm.TaskMockRunner = new tmrm.TaskMockRunner(taskPath);
+
+tr.setInput('serverEndpoint', 'ID1');
+tr.setInput('jobName', 'SomeJobName');
+//tr.setInput('saveTo', path.join(__dirname, '..'));
+tr.setInput('jenkinsBuild', 'LastSuccessfulBuild'); //BuildNumber
+
+// provide answers for task mock
+const a: ma.TaskLibAnswers = <ma.TaskLibAnswers>{
+    'checkPath': {
+        'gradlew': true,
+        'gradlew.bat': true
+    }
+};
+tr.setAnswers(a);
+
+tr.run();

Tasks/JenkinsDownloadArtifacts/Tests/L0NoServerEndpoint.ts

@@ -0,0 +1,24 @@
+import ma = require('vsts-task-lib/mock-answer');
+import tmrm = require('vsts-task-lib/mock-run');
+import path = require('path');
+
+const taskPath = path.join(__dirname, '..', 'jenkinsdownloadartifacts.js');
+const tr: tmrm.TaskMockRunner = new tmrm.TaskMockRunner(taskPath);
+
+tr.setInput('jobName', 'SomeJobName');
+tr.setInput('saveTo', path.join(__dirname, '..'));
+tr.setInput('jenkinsBuild', 'LastSuccessfulBuild'); //BuildNumber
+//tr.setInput('jenkinsBuildNumber', '42');
+
+// tr.setInput('serverEndpoint', 'ID1');
+
+// provide answers for task mock
+const a: ma.TaskLibAnswers = <ma.TaskLibAnswers>{
+    'checkPath': {
+        'gradlew': true,
+        'gradlew.bat': true
+    }
+};
+tr.setAnswers(a);
+
+tr.run();

Tasks/JenkinsDownloadArtifacts/jenkinsdownloadartifacts.ts

@@ -6,8 +6,7 @@ import fs = require('fs');
 import path = require('path');
 import shell = require('shelljs');
 import Q = require('q');
-
-var request = require('request');
+import request = require('request');
 
 class Credential {
     mUsername: string;
@@ -20,140 +19,137 @@ class Credential {
 }
 
 function getRequest(url: string, cred: Credential, strictSSL: boolean): Q.Promise<any> {
-    let defer = Q.defer<any>();
-
-    request
-        .get({url: url, strictSSL: strictSSL}, (err, res, body) => {
-            if (res && body && res.statusCode === 200)  {
-                defer.resolve(JSON.parse(body));
-            } else {
-                if (res && res.statusCode) {
-                   tl.debug(tl.loc('ServerCallErrorCode', res.statusCode)); 
+    const defer = Q.defer<any>();
+
+    request.get({url: url, strictSSL: strictSSL}, (err, res, body) => {
+                if (res && body && res.statusCode === 200)  {
+                    defer.resolve(JSON.parse(body));
+                } else {
+                    if (res && res.statusCode) {
+                        tl.debug(tl.loc('ServerCallErrorCode', res.statusCode));
+                    }
+                    if (body) {
+                        tl.debug(body);
+                    }
+                    defer.reject(new Error(tl.loc('ServerCallFailed')));
                 }
-                if (body) {
-                    tl.debug(body);
-                }
-                defer.reject(new Error(tl.loc('ServerCallFailed')));
-            }
-        })
-        .auth(cred.mUsername, cred.mPassword, true)
-        .on('error', err => {
-            defer.reject(new Error(err));
-        });
+            })
+            .auth(cred.mUsername, cred.mPassword, true)
+            .on('error', (err) => {
+                //TODO: Do we even need an 'error' handler here if we're just re-throwing?
+                defer.reject(new Error(err.message));
+            });
 
-        return defer.promise;
+    return defer.promise;
 }
 
 function getLastSuccessful(serverEndpointUrl: string, jobName: string, cred: Credential, strictSSL: boolean): Q.Promise<number> {
-    let defer = Q.defer<number>();
-    let lastSuccessfulUrl = `${serverEndpointUrl}/job/${jobName}/api/json?tree=lastSuccessfulBuild[id,displayname]`;
-
-    getRequest(lastSuccessfulUrl, cred, strictSSL)
-    .then( result => {
-        if (result && result['lastSuccessfulBuild']) {
-            let lastSuccessfulBuildId = result['lastSuccessfulBuild']['id'];
-            if (lastSuccessfulBuildId) {
-                defer.resolve(lastSuccessfulBuildId);
+    const defer = Q.defer<number>();
+    const lastSuccessfulUrl: string = `${serverEndpointUrl}/job/${jobName}/api/json?tree=lastSuccessfulBuild[id,displayname]`;
+
+    getRequest(lastSuccessfulUrl, cred, strictSSL).then((result) => {
+            if (result && result['lastSuccessfulBuild']) {
+                const lastSuccessfulBuildId = result['lastSuccessfulBuild']['id'];
+                if (lastSuccessfulBuildId) {
+                    defer.resolve(lastSuccessfulBuildId);
+                } else {
+                    defer.reject(new Error(tl.loc('CouldNotGetLastSuccessfuilBuildNumber')));
+                }
             } else {
                 defer.reject(new Error(tl.loc('CouldNotGetLastSuccessfuilBuildNumber')));
             }
-        } else {
-            defer.reject(new Error(tl.loc('CouldNotGetLastSuccessfuilBuildNumber')));
-        }
-    })
-    .fail(err => {defer.reject(err)});
+        })
+        .fail((err) => { defer.reject(err); });
 
     return defer.promise;
 }
 
-function getArtifactsRelativePaths(serverEndpointUrl: string, jobName: string, jobBuildId: number, 
-        cred: Credential, strictSSL: boolean): Q.Promise<string[]> {
-    let defer = Q.defer<string[]>();
-    let artifactQueryUrl = `${serverEndpointUrl}/job/${jobName}/${jobBuildId}/api/json?tree=artifacts[*]`;
-
-    getRequest(artifactQueryUrl, cred, strictSSL)
-    .then(result => { 
-        if (result && result['artifacts']) {
-            let artifacts = result['artifacts'];
-            if (artifacts.length === 0) {
-                defer.reject(new Error(tl.loc('CouldNotFindArtifacts', jobName, jobBuildId)));
+function getArtifactsRelativePaths(serverEndpointUrl: string, jobName: string, jobBuildId: number, cred: Credential, strictSSL: boolean): Q.Promise<string[]> {
+    const defer = Q.defer<string[]>();
+    const artifactQueryUrl: string = `${serverEndpointUrl}/job/${jobName}/${jobBuildId}/api/json?tree=artifacts[*]`;
+
+    getRequest(artifactQueryUrl, cred, strictSSL).then((result) => {
+            if (result && result['artifacts']) {
+                const artifacts = result['artifacts'];
+                if (artifacts.length === 0) {
+                    defer.reject(new Error(tl.loc('CouldNotFindArtifacts', jobName, jobBuildId)));
+                } else {
+                    const artifactsRelativePaths = result['artifacts'].map((artifact) => {
+                        return artifact['relativePath'];
+                    });
+                    defer.resolve(artifactsRelativePaths);
+                }
             } else {
-                let artifactsRelativePaths = result['artifacts'].map(artifact => {
-                    return artifact['relativePath'];
-                });
-                defer.resolve(artifactsRelativePaths);
+                // no artifacts for this job
+                defer.reject(new Error(tl.loc('CouldNotFindArtifacts', jobName, jobBuildId)));
             }
-        } else {
-            // no artifacts for this job
-            defer.reject(new Error(tl.loc('CouldNotFindArtifacts', jobName, jobBuildId)));
-        }
-    })
-    .fail(err => {defer.reject(err)});
+        })
+        .fail((err) => { defer.reject(err); });
 
-    return defer.promise
+    return defer.promise;
 }
 
-async function download(url: string, localFile: string, cred: Credential, strictSSL: boolean) {
-    tl.debug(tl.loc("DownloadFileTo", url, localFile));
+async function download(url: string, localFile: string, cred: Credential, strictSSL: boolean): Promise<void> {
+    tl.debug(tl.loc('DownloadFileTo', url, localFile));
     await request.get( {url: url, strictSSL: strictSSL} )
         .auth(cred.mUsername, cred.mPassword, true)
-        .on('error', err => {
-            throw new Error(err);
+        .on('error', (err) => {
+            //TODO: Do we even need an 'error' handler here if we're just re-throwing?
+            throw new Error(err.message);
         })
         .pipe(fs.createWriteStream(localFile));
 
-    tl.debug(tl.loc("FileSuccessfullyDownloaded", localFile));
+    tl.debug(tl.loc('FileSuccessfullyDownloaded', localFile));
 }
 
-function getArtifactUrl(serverEndpointUrl: string, jobName: string, jobBuildId: number, relativePath: string) {
+function getArtifactUrl(serverEndpointUrl: string, jobName: string, jobBuildId: number, relativePath: string): string {
     return `${serverEndpointUrl}/job/${jobName}/${jobBuildId}/artifact/${relativePath}`;
 }
 
 async function doWork() {
     try {
         tl.setResourcePath(path.join( __dirname, 'task.json'));
 
-        let serverEndpoint: string = tl.getInput('serverEndpoint', true);
-        let serverEndpointUrl: string = tl.getEndpointUrl(serverEndpoint, false);
+        const serverEndpoint: string = tl.getInput('serverEndpoint', true);
+        const serverEndpointUrl: string = tl.getEndpointUrl(serverEndpoint, false);
 
-        let serverEndpointAuth: tl.EndpointAuthorization = tl.getEndpointAuthorization(serverEndpoint, false);
-        let username: string = serverEndpointAuth['parameters']['username'];
-        let password: string = serverEndpointAuth['parameters']['password'];
-        let cred: Credential = (username && password) ? new Credential(username, password) : new Credential("", "");
+        const serverEndpointAuth: tl.EndpointAuthorization = tl.getEndpointAuthorization(serverEndpoint, false);
+        const username: string = serverEndpointAuth['parameters']['username'];
+        const password: string = serverEndpointAuth['parameters']['password'];
+        const cred: Credential = (username && password) ? new Credential(username, password) : new Credential('', '');
 
-        let jobName: string = tl.getInput('jobName', true);
-        let localPathRoot: string = tl.getPathInput('saveTo', true);
+        const jobName: string = tl.getInput('jobName', true);
+        const localPathRoot: string = tl.getPathInput('saveTo', true);
 
-        let strictSSL: boolean = ("true" !== tl.getEndpointDataParameter(serverEndpoint, "acceptUntrustedCerts", true));
+        const strictSSL: boolean = ('true' !== tl.getEndpointDataParameter(serverEndpoint, 'acceptUntrustedCerts', true));
 
-        let jenkinsBuild: string = tl.getInput("jenkinsBuild", true);
+        const jenkinsBuild: string = tl.getInput('jenkinsBuild', true);
         let buildId: number;
-        if (jenkinsBuild === "LastSuccessfulBuild") {
+        if (jenkinsBuild === 'LastSuccessfulBuild') {
             tl.debug(tl.loc('GetArtifactsFromLastSuccessfulBuild', jobName));
             buildId = await getLastSuccessful(serverEndpointUrl, jobName, cred, strictSSL);
         } else {
-            let buildIdStr = tl.getInput("jenkinsBuildNumber");
+            const buildIdStr: string = tl.getInput('jenkinsBuildNumber');
             buildId = parseInt(buildIdStr);
         }
         tl.debug(tl.loc('GetArtifactsFromBuildNumber', buildId, jobName));
 
-        let artifactsRelativePaths = await getArtifactsRelativePaths(serverEndpointUrl, jobName,
-                buildId, cred, strictSSL);
-        artifactsRelativePaths.forEach(relativePath => {
-            let localPath = path.resolve(localPathRoot, relativePath);
-            let dir = path.dirname(localPath);
+        const artifactsRelativePaths: string[] = await getArtifactsRelativePaths(serverEndpointUrl, jobName, buildId, cred, strictSSL);
+        artifactsRelativePaths.forEach((relativePath) => {
+            const localPath: string = path.resolve(localPathRoot, relativePath);
+            const dir: string = path.dirname(localPath);
             if (!tl.exist(dir)) {
                 tl.mkdirP(dir);
             }
 
-            let artifactUrl = getArtifactUrl(serverEndpointUrl, jobName, buildId, relativePath);
+            const artifactUrl: string = getArtifactUrl(serverEndpointUrl, jobName, buildId, relativePath);
+            //Q: Are we supposed to await on this download call?
             download(artifactUrl, localPath, cred, strictSSL);
         });
-
-    } catch (e) {
-        tl.debug(e.message);
-        tl._writeError(e);
-        tl.setResult(tl.TaskResult.Failed, e.message);
+    } catch (err) {
+        tl.debug(err.message);
+        tl._writeError(err);
+        tl.setResult(tl.TaskResult.Failed, err.message);
     }
 }