VSTS Mocking question

downloader.ts

/// <reference path="typings/globals/node/index.d.ts" />
"use strict"

import tl = require('vsts-task-lib/task');
import path = require('path');
import { KubectlCommand } from './kubectl.js';
import fs = require('fs');
import { ToolRunner } from 'vsts-task-lib/toolrunner';
let hasIstio: boolean = (tl.getInput('hasIstio') == 'true');
let istioVersion: string = tl.getInput('IstioVersion');
let hasHelm: boolean = (tl.getInput('hasHelm') == 'true');
let helmVersion: string = tl.getInput('helmVersion');

let kubectl: KubectlCommand = new KubectlCommand();

function downloadIstioctl()  {
        downloader(`https://github.com/istio/istio/releases/download/${istioVersion}/istio-${istioVersion}-linux.tar.gz`,
                    "istioctl",
                    "**/*/istioctl");
}

function downloadHelm() {
        downloader(`https://storage.googleapis.com/kubernetes-helm/helm-v${helmVersion}-linux-amd64.tar.gz`,
                    "helm",
                    "**/helm");
}

function downloader(downloadURL:string, binaryName:string, copyTarget:string)  {
        tl.debug("downloader:**********start");
        let binaryDir = process.env['SYSTEM_DEFAULTWORKINGDIRECTORY'] + "/.vstsbin";
        let bash = new ToolRunner(tl.which('bash', true));
        tl.debug("downloader:**********second");
        let downloader = "curl -L " + downloadURL + " | tar xz" + "\n" + "cp " + copyTarget + " " + binaryDir;
        let fileName = path.join('.', `.${binaryName}downloader.sh`);
        tl.debug("downloader:************:" + fileName);
        try {
            tl.debug(`downloader:writeFileSync:********${fileName}:${downloader}:`);
            tl.writeFile(fileName, downloader);
        } catch(err) {
            tl.setResult(tl.TaskResult.Failed, err);
            throw `Failed to create the ${fileName}.`
        }
        bash.arg(fileName);
        try {
            bash.execSync();
        } catch(err) {
            tl.setResult(tl.TaskResult.Failed, err);
            throw `Failed to exec the .${binaryName}downloader.sh which is ${binaryName} downloader.`
        }
}

kubectl.init().then(
    function() {
        if (hasIstio) {
            downloadIstioctl();
        }
        if (hasHelm) {
            downloadHelm();
        }
    }
);

L2.ts

/// <reference path="../typings/globals/chai/index.d.ts" />
/// <reference path="../typings/globals/mocha/index.d.ts" />
/// <reference path="../typings/globals/node/index.d.ts" />


import * as path from 'path';
import * as ttm from 'vsts-task-lib/mock-test';
import * as tl from 'vsts-task-lib/task';


let chai = require('chai');
let fst = require('fs');



let parent_dir = path.normalize(path.join(__dirname, '..'));
tl.debug("parent_dir: " + parent_dir);
let config_file_path = "./kubeconfig";

function isExistFile(file) {
    try {
        fst.statSync(file);
        return true;
    } catch (err) {
        if (err.code == 'ENOENT') return false;
    }
}

describe('Kubernetes download Task', function () {
    before(() => {

    });

    after(() => {

    });

    it("download istio", (done: MochaDone) => {

        let tp = path.join(__dirname, 'test-download-istio.js');
        tl.debug('tp: ' + tp);
        let tr: ttm.MockTestRunner = new ttm.MockTestRunner(tp);
        tr.run();
        chai.expect(tr.succeeded).to.equal(true);
        let downloadFile = path.join(".", ".istioctldownloader.sh");
        tl.debug('*************:' + downloadFile);
        chai.expect(isExistFile(downloadFile)).to.be.true;
        done();
    });

});

test-download-istio.ts

/// <reference path="../typings/globals/node/index.d.ts" />

import ma = require('vsts-task-lib/mock-answer');
import tmrm = require('vsts-task-lib/mock-run');
import path = require('path');


let taskPath = path.join(__dirname, '..', 'downloader.js');
let tr: tmrm.TaskMockRunner = new tmrm.TaskMockRunner(taskPath);

tr.setInput('kubectlBinary', process.cwd());
tr.setInput('k8sService', 'k8sendpoint');
tr.setInput('hasIstio', 'true');
tr.setInput('IstioVersion', "0.1.6");
tr.setInput('hasHelm', 'true');
tr.setInput('helmVersion', '2.4.2')

process.env['SYSTEM_DEFAULTWORKINGDIRECTORY'] = '/opt/vsts/work/r1/a'
process.env['ENDPOINT_AUTH_PARAMETER_K8SENDPOINT_KUBECONFIG'] = `

---
apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: "XXXXXXXXXXXXXXXX"
    server: https://xxxxxxxxmgmt.japanwest.cloudapp.azure.com
  name: "xxxxxxxxmgmt"
contexts:
- context:
    cluster: "xxxxxxxxmgmt"
    user: "xxxxxxxxmgmt-admin"
  name: "xxxxxxxxmgmt"
current-context: "xxxxxxxxmgmt"
kind: Config
users:
- name: "xxxxxxxxmgmt-admin"
  user:
    client-certificate-data: "XXXXXXXXXX"
    client-key-data: "XXXXXXXXXXXXXXXXXX"


`;

let a: ma.TaskLibAnswers = <ma.TaskLibAnswers> {
    "which": {
        "bash":  "/bin/bash"
    },
    "checkPath": {
        "./Tests/my-nginx.yml": true,
        "/opt/vsts/work/r1/a/.vstsbin/kubectl.vSomeVersion": true,
        "./kubeconfig": true,
        "/bin/bash": true,
    },
    "cwd": {
        "cwd": process.cwd(),
    },
    "osType": {
        "osType": "Linux",
    },
    "exec": {
        "curl -L https://storage.googleapis.com/kubernetes-release/release/stable.txt": {
          "code": 0,
          "stdout": "vSomeVersion"  
       },
        "curl -L -o /opt/vsts/work/r1/a/.vstsbin/kubectl.vSomeVersion https://storage.googleapis.com/kubernetes-release/release/vSomeVersion/bin/linux/amd64/kubectl": {
          "code": 0,
          "stdout": ""  
       },
        "chmod 777 /opt/vsts/work/r1/a/.vstsbin/kubectl.vSomeVersion": {
          "code": 0,
          "stdout": ""  
       },
        "cp /opt/vsts/work/r1/a/.vstsbin/kubectl.vSomeVersion /opt/vsts/work/r1/a/.vstsbin/kubectl": {
          "code": 0,
          "stdiout": ""
       },
       "mkdir -p /opt/vsts/work/r1/a/.vstsbin": {
          "code": 0,
          "stdiout": ""
        },
        "/bin/bash ./.istioctldownloader.sh": {
            "code": 0,
            "stdiout": ""
        },
        "/bin/bash ./.helmdownloader.sh": {
            "code": 0,
            "stdiout": ""
        }
    }
}

tr.setAnswers(a);
tr.registerMock(
    'vsts-task-lib/task', {
        writeFile: function (file, data) {
            console.log("writeFile called *********: " + data);
    }
    });

tr.run();