Fix codeowners

* run to index

* action.yaml route

* move to dev dep

.github/CODEOWNERS

@@ -1 +1 @@
-* @ds-ms
+* @Azure/aks-atlanta

.github/workflows/TriggerIntegrationTests.sh

@@ -1,33 +0,0 @@
-token=$1
-commit=$2
-repository=$3
-prNumber=$4
-frombranch=$5
-tobranch=$6
-patUser=$7
-
-getPayLoad() {
-    cat <<EOF
-{
-    "event_type": "SetupHelmActionPR", 
-    "client_payload": 
-    {
-        "action": "SetupHelm", 
-        "commit": "$commit", 
-        "repository": "$repository", 
-        "prNumber": "$prNumber", 
-        "tobranch": "$tobranch", 
-        "frombranch": "$frombranch"
-    }
-}
-EOF
-}
-
-response=$(curl -u $patUser:$token -X POST https://api.github.com/repos/Azure/azure-actions-integration-tests/dispatches --data "$(getPayLoad)")
-
-if [ "$response" == "" ]; then
-    echo "Integration tests triggered successfully"
-else
-    echo "Triggering integration tests failed with: '$response'"
-    exit 1
-fi

.github/workflows/defaultLabels.yml

@@ -13,24 +13,23 @@ jobs:
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
-          
       - uses: actions/stale@v3
         name: Setting issue as idle
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-issue-message: 'This issue is idle because it has been open for 14 days with no activity.'
-          stale-issue-label: 'idle'
+          stale-issue-message: "This issue is idle because it has been open for 14 days with no activity."
+          stale-issue-label: "idle"
           days-before-stale: 14
           days-before-close: -1
           operations-per-run: 100
-          exempt-issue-labels: 'backlog'
+          exempt-issue-labels: "backlog"
 
       - uses: actions/stale@v3
         name: Setting PR as idle
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-pr-message: 'This PR is idle because it has been open for 14 days with no activity.'
-          stale-pr-label: 'idle'
+          stale-pr-message: "This PR is idle because it has been open for 14 days with no activity."
+          stale-pr-label: "idle"
           days-before-stale: 14
           days-before-close: -1
           operations-per-run: 100

.github/workflows/integration-tests.yml

@@ -2,18 +2,64 @@ name: "Trigger Integration tests"
 on:
   pull_request:
     branches:
-      - master
-      - 'releases/*'
+      - main
+      - "releases/*"
 jobs:
   trigger-integration-tests:
     name: Trigger Integration tests
     runs-on: ubuntu-latest
+    env:
+      HELM_3_8_0: "v3.8.0"
+      HELM_3_7_2: "v3.7.2"
+      HELM_NO_V: "3.5.0"
+      PR_BASE_REF: ${{ github.event.pull_request.base.ref }}
     steps:
       - name: Check out repository
         uses: actions/checkout@v2
-          with:
-              path: IntegrationTests
-            
-        - name: Trigger Test run
+      - name: npm install and build
+        id: action-npm-build
         run: |
-            bash ./IntegrationTests/.github/workflows/TriggerIntegrationTests.sh ${{ secrets.L2_REPO_TOKEN }} ${{ github.event.pull_request.head.sha }} ${{ github.repository }} ${{ github.event.pull_request.number }} ${{ github.event.pull_request.head.ref }} ${{ github.event.pull_request.base.ref }} ${{ secrets.L2_REPO_USER }}
+          echo $PR_BASE_REF
+          if [[ $PR_BASE_REF != releases/* ]]; then
+            npm install
+            npm run build
+          fi
+      - name: Setup helm
+        uses: ./
+        with:
+          version: ${{ env.HELM_3_8_0 }}
+      - name: Validate helm 3.8.0
+        run: |
+          if [[ $(helm version) != *$HELM_3_8_0* ]]; then
+            echo "HELM VERSION INCORRECT: HELM VERSION DOES NOT CONTAIN v3.8.0"
+            echo "HELM VERSION OUTPUT: $(helm version)"
+            exit 1
+          else
+            echo "HELM VERSION $HELM_3_8_0 INSTALLED SUCCESSFULLY"
+          fi
+      - name: Setup helm 3.7.2
+        uses: ./
+        with:
+          version: ${{ env.HELM_3_7_2 }}
+      - name: Validate 3.7.2
+        run: |
+          if [[ $(helm version) != *$HELM_3_7_2* ]]; then
+            echo "HELM VERSION INCORRECT: HELM VERSION DOES NOT CONTAIN v3.7.2"
+            echo "HELM VERSION OUTPUT: $(helm version)"
+            exit 1
+          else
+            echo "HELM VERSION $HELM_3_7_2 INSTALLED SUCCESSFULLY"
+          fi
+      - name: Setup helm 3.5.0 with no v in version
+        uses: ./
+        with:
+          version: ${{ env.HELM_NO_V }}
+      - name: Validate 3.5.0 without v in version
+        run: |
+          if [[ $(helm version) != *$HELM_NO_V* ]]; then
+            echo "HELM VERSION INCORRECT: HELM VERSION DOES NOT CONTAIN v3.5.0"
+            echo "HELM VERSION OUTPUT: $(helm version)"
+            exit 1
+          else
+            echo "HELM VERSION $HELM_3_5_0 INSTALLED SUCCESSFULLY"
+          fi

.github/workflows/release-pr.yml

@@ -0,0 +1,14 @@
+name: Create release PR
+
+on:
+  workflow_dispatch:
+    inputs:
+      release:
+        description: "Define release version (ex: v1, v2, v3)"
+        required: true
+
+jobs:
+  release-pr:
+    uses: OliverMKing/javascript-release-workflow/.github/workflows/release-pr.yml@main
+    with:
+      release: ${{ github.event.inputs.release }}

.github/workflows/tag-and-draft.yml

@@ -0,0 +1,10 @@
+name: Tag and create release draft
+
+on:
+  push:
+    branches:
+      - releases/*
+
+jobs:
+  tag-and-release:
+    uses: OliverMKing/javascript-release-workflow/.github/workflows/tag-and-release.yml@main

.github/workflows/unit-tests.yml

@@ -2,12 +2,12 @@ name: "Run unit tests."
 on: # rebuild any PRs and main branch changes
   pull_request:
     branches:
-      - master
-      - 'releases/*'
+      - main
+      - "releases/*"
   push:
     branches:
-      - master
-      - 'releases/*'
+      - main
+      - "releases/*"
 
 jobs:
   build: # make sure build/ci works properly

.gitignore

@@ -62,3 +62,6 @@ typings/
 
 node_modules
 coverage
+
+# Transpiled JS
+lib/

README.md

@@ -1,5 +1,6 @@
 # Setup Helm
-#### Install a specific version of helm binary on the runner.
+Install a specific version of helm binary on the runner.
+## Example
 
 Acceptable values are latest or any semantic version string like v2.16.7 Use this action in workflow to define which version of helm will be used.
 

__tests__/run.test.ts

@@ -1,195 +0,0 @@
-import * as run from '../src/run'
-import * as os from 'os';
-import * as toolCache from '@actions/tool-cache';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as core from '@actions/core';
-
-describe('run.ts', () => {
-    test('getExecutableExtension() - return .exe when os is Windows', () => {
-        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
-
-        expect(run.getExecutableExtension()).toBe('.exe');
-        expect(os.type).toBeCalled();         
-    });
-
-    test('getExecutableExtension() - return empty string for non-windows OS', () => {
-        jest.spyOn(os, 'type').mockReturnValue('Darwin');
-
-        expect(run.getExecutableExtension()).toBe('');         
-        expect(os.type).toBeCalled();         
-    });
-
-    test('getHelmDownloadURL() - return the URL to download helm for Linux', () => {
-        jest.spyOn(os, 'type').mockReturnValue('Linux');
-        const kubectlLinuxUrl = 'https://get.helm.sh/helm-v3.2.1-linux-amd64.zip'
-
-        expect(run.getHelmDownloadURL('v3.2.1')).toBe(kubectlLinuxUrl);
-        expect(os.type).toBeCalled();         
-    });
-
-    test('getHelmDownloadURL() - return the URL to download helm for Darwin', () => {
-        jest.spyOn(os, 'type').mockReturnValue('Darwin');
-        const kubectlDarwinUrl = 'https://get.helm.sh/helm-v3.2.1-darwin-amd64.zip'
-
-        expect(run.getHelmDownloadURL('v3.2.1')).toBe(kubectlDarwinUrl);
-        expect(os.type).toBeCalled();         
-    });
-
-    test('getHelmDownloadURL() - return the URL to download helm for Windows', () => {
-        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
-
-        const kubectlWindowsUrl = 'https://get.helm.sh/helm-v3.2.1-windows-amd64.zip'
-        expect(run.getHelmDownloadURL('v3.2.1')).toBe(kubectlWindowsUrl);
-        expect(os.type).toBeCalled();         
-    });
-
-    test('getStableHelmVersion() - download stable version file, read version and return it', async () => {
-        jest.spyOn(toolCache, 'downloadTool').mockResolvedValue('pathToTool');
-        const response = JSON.stringify(
-            [
-                {
-                    'tag_name': 'v4.0.0'
-                }, {
-                    'tag_name': 'v3.0.0'
-                }, {
-                    'tag_name': 'v2.0.0'
-                }
-            ]
-        );
-        jest.spyOn(fs, 'readFileSync').mockReturnValue(response);
-
-        expect(await run.getStableHelmVersion()).toBe('v4.0.0');
-        expect(toolCache.downloadTool).toBeCalled();
-        expect(fs.readFileSync).toBeCalledWith('pathToTool', 'utf8');
-    });
-
-    test('getStableHelmVersion() - return default version if error occurs while getting latest version', async () => {
-        jest.spyOn(toolCache, 'downloadTool').mockRejectedValue('Unable to download');
-        jest.spyOn(core, 'warning').mockImplementation();
-
-        expect(await run.getStableHelmVersion()).toBe('v3.2.1');
-        expect(toolCache.downloadTool).toBeCalled();
-        expect(core.warning).toBeCalledWith("Cannot get the latest Helm info from https://api.github.com/repos/helm/helm/releases. Error Unable to download. Using default Helm version v3.2.1.");
-    });
-
-    test('walkSync() - return path to the all files matching fileToFind in dir', () => {
-        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
-            if (file == 'mainFolder') return ['file1' as unknown as fs.Dirent, 'file2' as unknown as fs.Dirent, 'folder1' as unknown as fs.Dirent, 'folder2' as unknown as fs.Dirent];
-            if (file == path.join('mainFolder', 'folder1')) return ['file11' as unknown as fs.Dirent, 'file12' as unknown as fs.Dirent];
-            if (file == path.join('mainFolder', 'folder2')) return ['file21' as unknown as fs.Dirent, 'file22' as unknown as fs.Dirent];
-        });
-        jest.spyOn(core, 'debug').mockImplementation();
-        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
-            const isDirectory = (file as string).toLowerCase().indexOf('file') == -1 ? true: false
-            return { isDirectory: () => isDirectory } as fs.Stats;
-        });
-
-        expect(run.walkSync('mainFolder', null, 'file21')).toEqual([path.join('mainFolder', 'folder2', 'file21')]);
-        expect(fs.readdirSync).toBeCalledTimes(3);
-        expect(fs.statSync).toBeCalledTimes(8);
-    });
-
-    test('walkSync() - return empty array if no file with name fileToFind exists', () => {
-        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
-            if (file == 'mainFolder') return ['file1' as unknown as fs.Dirent, 'file2' as unknown as fs.Dirent, 'folder1' as unknown as fs.Dirent, 'folder2' as unknown as fs.Dirent];
-            if (file == path.join('mainFolder', 'folder1')) return ['file11' as unknown as fs.Dirent, 'file12' as unknown as fs.Dirent];
-            if (file == path.join('mainFolder', 'folder2')) return ['file21' as unknown as fs.Dirent, 'file22' as unknown as fs.Dirent];
-        });
-        jest.spyOn(core, 'debug').mockImplementation();
-        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
-            const isDirectory = (file as string).toLowerCase().indexOf('file') == -1 ? true: false
-            return { isDirectory: () => isDirectory } as fs.Stats;
-        });
-
-        expect(run.walkSync('mainFolder', null, 'helm.exe')).toEqual([]);
-        expect(fs.readdirSync).toBeCalledTimes(3);
-        expect(fs.statSync).toBeCalledTimes(8);
-    });
-
-    test('findHelm() - change access permissions and find the helm in given directory', () => {
-        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
-        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
-            if (file == 'mainFolder') return ['helm.exe' as unknown as fs.Dirent];
-        });
-        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
-            const isDirectory = (file as string).indexOf('folder') == -1 ? false: true
-            return { isDirectory: () => isDirectory } as fs.Stats;
-        });
-        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
-
-        expect(run.findHelm('mainFolder')).toBe(path.join('mainFolder', 'helm.exe'));
-    });
-
-    test('findHelm() - throw error if executable not found', () => {
-        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
-        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
-            if (file == 'mainFolder') return [];
-        });
-        jest.spyOn(fs, 'statSync').mockImplementation((file) => { return { isDirectory: () => true } as fs.Stats});
-        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
-        expect(() => run.findHelm('mainFolder')).toThrow('Helm executable not found in path mainFolder');
-    });
-
-    test('downloadHelm() - download helm and return path to it', async () => {
-        jest.spyOn(toolCache, 'find').mockReturnValue('');
-        jest.spyOn(toolCache, 'downloadTool').mockResolvedValue('pathToTool');
-        const response = JSON.stringify([{'tag_name': 'v4.0.0'}]);
-        jest.spyOn(fs, 'readFileSync').mockReturnValue(response);
-        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
-        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
-        jest.spyOn(toolCache, 'extractZip').mockResolvedValue('pathToUnzippedHelm');
-        jest.spyOn(toolCache, 'cacheDir').mockResolvedValue('pathToCachedDir');
-        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => ['helm.exe' as unknown as fs.Dirent]);
-        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
-            const isDirectory = (file as string).indexOf('folder') == -1 ? false: true
-            return { isDirectory: () =>  isDirectory } as fs.Stats;
-        });
-
-        expect(await run.downloadHelm(null)).toBe(path.join('pathToCachedDir', 'helm.exe'));
-        expect(toolCache.find).toBeCalledWith('helm', 'v4.0.0');
-        expect(toolCache.downloadTool).toBeCalledWith('https://get.helm.sh/helm-v4.0.0-windows-amd64.zip');
-        expect(fs.chmodSync).toBeCalledWith('pathToTool', '777');
-        expect(toolCache.extractZip).toBeCalledWith('pathToTool');
-        expect(fs.chmodSync).toBeCalledWith(path.join('pathToCachedDir', 'helm.exe'), '777');
-    });
-
-    test('downloadHelm() - throw error if unable to download', async () => {
-        jest.spyOn(toolCache, 'find').mockReturnValue('');
-        jest.spyOn(toolCache, 'downloadTool').mockImplementation(async () => { throw 'Unable to download'});
-        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
-
-        await expect(run.downloadHelm('v3.2.1')).rejects.toThrow('Failed to download Helm from location https://get.helm.sh/helm-v3.2.1-windows-amd64.zip');
-        expect(toolCache.find).toBeCalledWith('helm', 'v3.2.1');
-        expect(toolCache.downloadTool).toBeCalledWith('https://get.helm.sh/helm-v3.2.1-windows-amd64.zip');
-    });
-
-    test('downloadHelm() - return path to helm tool with same version from toolCache', async () => {
-        jest.spyOn(toolCache, 'find').mockReturnValue('pathToCachedDir');
-        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
-
-        expect(await run.downloadHelm('v3.2.1')).toBe(path.join('pathToCachedDir', 'helm.exe'));
-        expect(toolCache.find).toBeCalledWith('helm', 'v3.2.1');
-        expect(fs.chmodSync).toBeCalledWith(path.join('pathToCachedDir', 'helm.exe'), '777');
-    });
-
-    test('downloadHelm() - throw error is helm is not found in path', async () => {
-        jest.spyOn(toolCache, 'find').mockReturnValue('');
-        jest.spyOn(toolCache, 'downloadTool').mockResolvedValue('pathToTool');
-        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
-        jest.spyOn(fs, 'chmodSync').mockImplementation();
-        jest.spyOn(toolCache, 'extractZip').mockResolvedValue('pathToUnzippedHelm');
-        jest.spyOn(toolCache, 'cacheDir').mockResolvedValue('pathToCachedDir');
-        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => []);
-        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
-            const isDirectory = (file as string).indexOf('folder') == -1 ? false: true
-            return { isDirectory: () =>  isDirectory } as fs.Stats;
-        });
-
-        await expect(run.downloadHelm('v3.2.1')).rejects.toThrow('Helm executable not found in path pathToCachedDir');
-        expect(toolCache.find).toBeCalledWith('helm', 'v3.2.1');
-        expect(toolCache.downloadTool).toBeCalledWith('https://get.helm.sh/helm-v3.2.1-windows-amd64.zip');
-        expect(fs.chmodSync).toBeCalledWith('pathToTool', '777');
-        expect(toolCache.extractZip).toBeCalledWith('pathToTool');
-    });
-});  

action.yml

@@ -1,19 +1,15 @@
-name: 'Helm tool installer'
-description: 'Install a specific version of helm binary. Acceptable values are latest or any semantic version string like 1.15.0'
+name: "Helm tool installer"
+description: "Install a specific version of helm binary. Acceptable values are latest or any semantic version string like 1.15.0"
 inputs:
   version:
-    description: 'Version of helm'
-    required: true
-    default: 'latest'
-  token:
-    description: 'Github token'
-    default: ${{ github.token }}
+    description: "Version of helm"
     required: true
+    default: "latest"
 outputs:
   helm-path:
-    description: 'Path to the cached helm binary'
+    description: "Path to the cached helm binary"
 branding:
-  color: 'blue'
+  color: "blue"
 runs:
-  using: 'node12'
-  main: 'lib/run.js'
+  using: "node12"
+  main: "lib/index.js"

lib/run.js

@@ -1,222 +0,0 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStableHelmVersion = void 0;
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const util = __importStar(require("util"));
-const fs = __importStar(require("fs"));
-const semver = __importStar(require("semver"));
-const toolCache = __importStar(require("@actions/tool-cache"));
-const core = __importStar(require("@actions/core"));
-const graphql_1 = require("@octokit/graphql");
-const helmToolName = 'helm';
-const stableHelmVersion = 'v3.2.1';
-const stableHelm3Version = 'v3.5.3';
-const stableHelm2Version = 'v2.17.0';
-const LATEST_HELM2_VERSION = '2.*';
-const LATEST_HELM3_VERSION = '3.*';
-const helmAllReleasesUrl = 'https://api.github.com/repos/helm/helm/releases';
-function getExecutableExtension() {
-    if (os.type().match(/^Win/)) {
-        return '.exe';
-    }
-    return '';
-}
-function getHelmDownloadURL(version) {
-    switch (os.type()) {
-        case 'Linux':
-            return util.format('https://get.helm.sh/helm-%s-linux-amd64.zip', version);
-        case 'Darwin':
-            return util.format('https://get.helm.sh/helm-%s-darwin-amd64.zip', version);
-        case 'Windows_NT':
-        default:
-            return util.format('https://get.helm.sh/helm-%s-windows-amd64.zip', version);
-    }
-}
-function getStableHelmVersion() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const downloadPath = yield toolCache.downloadTool(helmAllReleasesUrl);
-            const responseArray = JSON.parse(fs.readFileSync(downloadPath, 'utf8').toString().trim());
-            let latestHelmVersion = semver.clean(stableHelmVersion);
-            responseArray.forEach(response => {
-                if (response && response.tag_name) {
-                    let currentHelmVerison = semver.clean(response.tag_name.toString());
-                    if (currentHelmVerison) {
-                        if (currentHelmVerison.toString().indexOf('rc') == -1 && semver.gt(currentHelmVerison, latestHelmVersion)) {
-                            //If current helm version is not a pre release and is greater than latest helm version
-                            latestHelmVersion = currentHelmVerison;
-                        }
-                    }
-                }
-            });
-            latestHelmVersion = "v" + latestHelmVersion;
-            return latestHelmVersion;
-        }
-        catch (error) {
-            core.warning(util.format("Cannot get the latest Helm info from %s. Error %s. Using default Helm version %s.", helmAllReleasesUrl, error, stableHelmVersion));
-        }
-        return stableHelmVersion;
-    });
-}
-exports.getStableHelmVersion = getStableHelmVersion;
-var walkSync = function (dir, filelist, fileToFind) {
-    var files = fs.readdirSync(dir);
-    filelist = filelist || [];
-    files.forEach(function (file) {
-        if (fs.statSync(path.join(dir, file)).isDirectory()) {
-            filelist = walkSync(path.join(dir, file), filelist, fileToFind);
-        }
-        else {
-            core.debug(file);
-            if (file == fileToFind) {
-                filelist.push(path.join(dir, file));
-            }
-        }
-    });
-    return filelist;
-};
-function downloadHelm(version) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!version) {
-            version = yield getLatestHelmVersionFor("v3");
-        }
-        let cachedToolpath = toolCache.find(helmToolName, version);
-        if (!cachedToolpath) {
-            let helmDownloadPath;
-            try {
-                helmDownloadPath = yield toolCache.downloadTool(getHelmDownloadURL(version));
-            }
-            catch (exception) {
-                throw new Error(util.format("Failed to download Helm from location ", getHelmDownloadURL(version)));
-            }
-            fs.chmodSync(helmDownloadPath, '777');
-            const unzipedHelmPath = yield toolCache.extractZip(helmDownloadPath);
-            cachedToolpath = yield toolCache.cacheDir(unzipedHelmPath, helmToolName, version);
-        }
-        const helmpath = findHelm(cachedToolpath);
-        if (!helmpath) {
-            throw new Error(util.format("Helm executable not found in path ", cachedToolpath));
-        }
-        fs.chmodSync(helmpath, '777');
-        return helmpath;
-    });
-}
-function getLatestHelmVersionFor(type) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const token = core.getInput('token', { 'required': true });
-        try {
-            const { repository } = yield graphql_1.graphql(`{
-                repository(name: "helm", owner: "helm") {
-                    releases(last: 100)  {
-                        nodes {
-                            tagName
-                        }
-                    }
-                }
-            }`, {
-                headers: {
-                    authorization: `token ${token}`
-                }
-            });
-            const releases = repository.releases.nodes.reverse();
-            let latestValidRelease = releases.find(release => isValidVersion(release.tagName, type));
-            if (latestValidRelease)
-                return latestValidRelease.tagName;
-        }
-        catch (err) {
-            core.warning(util.format("Error while fetching the latest Helm %s release. Error: %s. Using default Helm version %s.", type, err.toString(), getStableHelmVersionFor(type)));
-            return getStableHelmVersionFor(type);
-        }
-        core.warning(util.format("Could not find stable release for Helm %s. Using default Helm version %s.", type, getStableHelmVersionFor(type)));
-        return getStableHelmVersionFor(type);
-    });
-}
-function getStableHelmVersionFor(type) {
-    return type === "v2" ? stableHelm2Version : stableHelm3Version;
-}
-// isValidVersion checks if verison matches the specified type and is a stable release
-function isValidVersion(version, type) {
-    if (!version.toLocaleLowerCase().startsWith(type))
-        return false;
-    return version.indexOf('rc') == -1;
-}
-function findHelm(rootFolder) {
-    fs.chmodSync(rootFolder, '777');
-    var filelist = [];
-    walkSync(rootFolder, filelist, helmToolName + getExecutableExtension());
-    if (!filelist) {
-        throw new Error(util.format("Helm executable not found in path ", rootFolder));
-    }
-    else {
-        return filelist[0];
-    }
-}
-function run() {
-    return __awaiter(this, void 0, void 0, function* () {
-        let version = core.getInput('version', { 'required': true });
-        if (process.env['HELM_INSTALLER_LEGACY_VERSIONING'] == 'true') {
-            if (version.toLocaleLowerCase() === 'latest') {
-                version = yield getStableHelmVersion();
-            }
-            else if (!version.toLocaleLowerCase().startsWith('v')) {
-                version = 'v' + version;
-            }
-        }
-        else {
-            if (version.toLocaleLowerCase() === 'latest' || version === LATEST_HELM3_VERSION) {
-                version = yield getLatestHelmVersionFor("v3");
-            }
-            else if (version === LATEST_HELM2_VERSION) {
-                version = yield getLatestHelmVersionFor("v2");
-            }
-            else if (!version.toLocaleLowerCase().startsWith('v')) {
-                version = 'v' + version;
-            }
-        }
-        core.debug(util.format("Downloading %s", version));
-        let cachedPath = yield downloadHelm(version);
-        try {
-            if (!process.env['PATH'].startsWith(path.dirname(cachedPath))) {
-                core.addPath(path.dirname(cachedPath));
-            }
-        }
-        catch (_a) {
-            //do nothing, set as output variable
-        }
-        console.log(`Helm tool version: '${version}' has been cached at ${cachedPath}`);
-        core.setOutput('helm-path', cachedPath);
-    });
-}
-run().catch(core.setFailed);

package.json

@@ -13,17 +13,18 @@
         "@octokit/graphql": "^4.6.1",
         "semver": "^6.1.0"
     },
-    "main": "lib/run.js",
+    "main": "lib/index.js",
     "scripts": {
-        "build": "tsc --outDir ./lib --rootDir ./src",
+        "build": "ncc build src/run.ts -o lib",
         "test": "jest",
         "test-coverage": "jest --coverage"
     },
     "devDependencies": {
-        "@types/node": "^12.0.10",
-        "typescript": "^3.5.2",
-        "jest": "^26.0.1",
         "@types/jest": "^25.2.2",
-        "ts-jest": "^25.5.1"
+        "@types/node": "^12.0.10",
+        "@vercel/ncc": "^0.33.1",
+        "jest": "^26.0.1",
+        "ts-jest": "^25.5.1",
+        "typescript": "^3.5.2"
     }
 }

src/run.test.ts

@@ -0,0 +1,268 @@
+import * as run from "./run";
+import * as os from "os";
+import * as toolCache from "@actions/tool-cache";
+import * as fs from "fs";
+import * as path from "path";
+import * as core from "@actions/core";
+
+describe("run.ts", () => {
+  test("getExecutableExtension() - return .exe when os is Windows", () => {
+    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
+
+    expect(run.getExecutableExtension()).toBe(".exe");
+    expect(os.type).toBeCalled();
+  });
+
+  test("getExecutableExtension() - return empty string for non-windows OS", () => {
+    jest.spyOn(os, "type").mockReturnValue("Darwin");
+
+    expect(run.getExecutableExtension()).toBe("");
+    expect(os.type).toBeCalled();
+  });
+
+  test("getHelmDownloadURL() - return the URL to download helm for Linux", () => {
+    jest.spyOn(os, "type").mockReturnValue("Linux");
+    jest.spyOn(os, "arch").mockReturnValueOnce("unknown");
+    const kubectlLinuxUrl = "https://get.helm.sh/helm-v3.8.0-linux-amd64.zip";
+
+    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlLinuxUrl);
+    expect(os.type).toBeCalled();
+    expect(os.arch).toBeCalled();
+
+    // arm64
+    jest.spyOn(os, "type").mockReturnValue("Linux");
+    jest.spyOn(os, "arch").mockReturnValueOnce("arm64");
+    const kubectlLinuxArm64Url =
+      "https://get.helm.sh/helm-v3.8.0-linux-arm64.zip";
+
+    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlLinuxArm64Url);
+    expect(os.type).toBeCalled();
+    expect(os.arch).toBeCalled();
+  });
+
+  test("getHelmDownloadURL() - return the URL to download helm for Darwin", () => {
+    jest.spyOn(os, "type").mockReturnValue("Darwin");
+    jest.spyOn(os, "arch").mockReturnValueOnce("unknown");
+    const kubectlDarwinUrl = "https://get.helm.sh/helm-v3.8.0-darwin-amd64.zip";
+
+    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlDarwinUrl);
+    expect(os.type).toBeCalled();
+    expect(os.arch).toBeCalled();
+
+    // arm64
+    jest.spyOn(os, "type").mockReturnValue("Darwin");
+    jest.spyOn(os, "arch").mockReturnValueOnce("arm64");
+    const kubectlDarwinArm64Url =
+      "https://get.helm.sh/helm-v3.8.0-darwin-arm64.zip";
+
+    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlDarwinArm64Url);
+    expect(os.type).toBeCalled();
+    expect(os.arch).toBeCalled();
+  });
+
+  test("getValidVersion() - return version with v prepended", () => {
+      expect(run.getValidVersion("3.8.0")).toBe("v3.8.0");
+  });
+  
+  test("getHelmDownloadURL() - return the URL to download helm for Windows", () => {
+    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
+
+    const kubectlWindowsUrl =
+      "https://get.helm.sh/helm-v3.8.0-windows-amd64.zip";
+    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlWindowsUrl);
+    expect(os.type).toBeCalled();
+  });
+
+  test("getLatestHelmVersion() - return the latest version of HELM", async () => {
+    try {
+      expect(await run.getLatestHelmVersion()).toBe("v3.8.0");
+    } catch (e) {
+      return e;
+    }
+  });
+
+  test("walkSync() - return path to the all files matching fileToFind in dir", () => {
+    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
+      if (file == "mainFolder")
+        return [
+          "file1" as unknown as fs.Dirent,
+          "file2" as unknown as fs.Dirent,
+          "folder1" as unknown as fs.Dirent,
+          "folder2" as unknown as fs.Dirent,
+        ];
+      if (file == path.join("mainFolder", "folder1"))
+        return [
+          "file11" as unknown as fs.Dirent,
+          "file12" as unknown as fs.Dirent,
+        ];
+      if (file == path.join("mainFolder", "folder2"))
+        return [
+          "file21" as unknown as fs.Dirent,
+          "file22" as unknown as fs.Dirent,
+        ];
+    });
+    jest.spyOn(core, "debug").mockImplementation();
+    jest.spyOn(fs, "statSync").mockImplementation((file) => {
+      const isDirectory =
+        (file as string).toLowerCase().indexOf("file") == -1 ? true : false;
+      return { isDirectory: () => isDirectory } as fs.Stats;
+    });
+
+    expect(run.walkSync("mainFolder", null, "file21")).toEqual([
+      path.join("mainFolder", "folder2", "file21"),
+    ]);
+    expect(fs.readdirSync).toBeCalledTimes(3);
+    expect(fs.statSync).toBeCalledTimes(8);
+  });
+
+  test("walkSync() - return empty array if no file with name fileToFind exists", () => {
+    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
+      if (file == "mainFolder")
+        return [
+          "file1" as unknown as fs.Dirent,
+          "file2" as unknown as fs.Dirent,
+          "folder1" as unknown as fs.Dirent,
+          "folder2" as unknown as fs.Dirent,
+        ];
+      if (file == path.join("mainFolder", "folder1"))
+        return [
+          "file11" as unknown as fs.Dirent,
+          "file12" as unknown as fs.Dirent,
+        ];
+      if (file == path.join("mainFolder", "folder2"))
+        return [
+          "file21" as unknown as fs.Dirent,
+          "file22" as unknown as fs.Dirent,
+        ];
+    });
+    jest.spyOn(core, "debug").mockImplementation();
+    jest.spyOn(fs, "statSync").mockImplementation((file) => {
+      const isDirectory =
+        (file as string).toLowerCase().indexOf("file") == -1 ? true : false;
+      return { isDirectory: () => isDirectory } as fs.Stats;
+    });
+
+    expect(run.walkSync("mainFolder", null, "helm.exe")).toEqual([]);
+    expect(fs.readdirSync).toBeCalledTimes(3);
+    expect(fs.statSync).toBeCalledTimes(8);
+  });
+
+  test("findHelm() - change access permissions and find the helm in given directory", () => {
+    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
+    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
+      if (file == "mainFolder") return ["helm.exe" as unknown as fs.Dirent];
+    });
+    jest.spyOn(fs, "statSync").mockImplementation((file) => {
+      const isDirectory =
+        (file as string).indexOf("folder") == -1 ? false : true;
+      return { isDirectory: () => isDirectory } as fs.Stats;
+    });
+    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
+
+    expect(run.findHelm("mainFolder")).toBe(
+      path.join("mainFolder", "helm.exe")
+    );
+  });
+
+  test("findHelm() - throw error if executable not found", () => {
+    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
+    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
+      if (file == "mainFolder") return [];
+    });
+    jest.spyOn(fs, "statSync").mockImplementation((file) => {
+      return { isDirectory: () => true } as fs.Stats;
+    });
+    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
+    expect(() => run.findHelm("mainFolder")).toThrow(
+      "Helm executable not found in path mainFolder"
+    );
+  });
+
+  test("downloadHelm() - download helm and return path to it", async () => {
+    jest.spyOn(toolCache, "find").mockReturnValue("");
+    jest.spyOn(toolCache, "downloadTool").mockResolvedValue("pathToTool");
+    const response = JSON.stringify([{ tag_name: "v4.0.0" }]);
+    jest.spyOn(fs, "readFileSync").mockReturnValue(response);
+    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
+    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
+    jest.spyOn(toolCache, "extractZip").mockResolvedValue("pathToUnzippedHelm");
+    jest.spyOn(toolCache, "cacheDir").mockResolvedValue("pathToCachedDir");
+    jest
+      .spyOn(fs, "readdirSync")
+      .mockImplementation((file, _) => ["helm.exe" as unknown as fs.Dirent]);
+    jest.spyOn(fs, "statSync").mockImplementation((file) => {
+      const isDirectory =
+        (file as string).indexOf("folder") == -1 ? false : true;
+      return { isDirectory: () => isDirectory } as fs.Stats;
+    });
+
+    expect(await run.downloadHelm("v4.0.0")).toBe(
+      path.join("pathToCachedDir", "helm.exe")
+    );
+    expect(toolCache.find).toBeCalledWith("helm", "v4.0.0");
+    expect(toolCache.downloadTool).toBeCalledWith(
+      "https://get.helm.sh/helm-v4.0.0-windows-amd64.zip"
+    );
+    expect(fs.chmodSync).toBeCalledWith("pathToTool", "777");
+    expect(toolCache.extractZip).toBeCalledWith("pathToTool");
+    expect(fs.chmodSync).toBeCalledWith(
+      path.join("pathToCachedDir", "helm.exe"),
+      "777"
+    );
+  });
+
+  test("downloadHelm() - throw error if unable to download", async () => {
+    jest.spyOn(toolCache, "find").mockReturnValue("");
+    jest.spyOn(toolCache, "downloadTool").mockImplementation(async () => {
+      throw "Unable to download";
+    });
+    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
+
+    await expect(run.downloadHelm("v3.2.1")).rejects.toThrow(
+      "Failed to download Helm from location https://get.helm.sh/helm-v3.2.1-windows-amd64.zip"
+    );
+    expect(toolCache.find).toBeCalledWith("helm", "v3.2.1");
+    expect(toolCache.downloadTool).toBeCalledWith(
+      "https://get.helm.sh/helm-v3.2.1-windows-amd64.zip"
+    );
+  });
+
+  test("downloadHelm() - return path to helm tool with same version from toolCache", async () => {
+    jest.spyOn(toolCache, "find").mockReturnValue("pathToCachedDir");
+    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
+
+    expect(await run.downloadHelm("v3.2.1")).toBe(
+      path.join("pathToCachedDir", "helm.exe")
+    );
+    expect(toolCache.find).toBeCalledWith("helm", "v3.2.1");
+    expect(fs.chmodSync).toBeCalledWith(
+      path.join("pathToCachedDir", "helm.exe"),
+      "777"
+    );
+  });
+
+  test("downloadHelm() - throw error is helm is not found in path", async () => {
+    jest.spyOn(toolCache, "find").mockReturnValue("");
+    jest.spyOn(toolCache, "downloadTool").mockResolvedValue("pathToTool");
+    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
+    jest.spyOn(fs, "chmodSync").mockImplementation();
+    jest.spyOn(toolCache, "extractZip").mockResolvedValue("pathToUnzippedHelm");
+    jest.spyOn(toolCache, "cacheDir").mockResolvedValue("pathToCachedDir");
+    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => []);
+    jest.spyOn(fs, "statSync").mockImplementation((file) => {
+      const isDirectory =
+        (file as string).indexOf("folder") == -1 ? false : true;
+      return { isDirectory: () => isDirectory } as fs.Stats;
+    });
+
+    await expect(run.downloadHelm("v3.2.1")).rejects.toThrow(
+      "Helm executable not found in path pathToCachedDir"
+    );
+    expect(toolCache.find).toBeCalledWith("helm", "v3.2.1");
+    expect(toolCache.downloadTool).toBeCalledWith(
+      "https://get.helm.sh/helm-v3.2.1-windows-amd64.zip"
+    );
+    expect(fs.chmodSync).toBeCalledWith("pathToTool", "777");
+    expect(toolCache.extractZip).toBeCalledWith("pathToTool");
+  });
+});

src/run.ts

@@ -2,78 +2,186 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import * as os from 'os';
-import * as path from 'path';
-import * as util from 'util';
-import * as fs from 'fs';
-import * as semver from 'semver';
+import * as os from "os";
+import * as path from "path";
+import * as util from "util";
+import * as fs from "fs";
 
-import * as toolCache from '@actions/tool-cache';
-import * as core from '@actions/core';
-import { graphql } from '@octokit/graphql';
+import * as toolCache from "@actions/tool-cache";
+import * as core from "@actions/core";
 
-const helmToolName = 'helm';
-const stableHelmVersion = 'v3.2.1';
-const stableHelm3Version = 'v3.5.3';
-const stableHelm2Version = 'v2.17.0';
-const LATEST_HELM2_VERSION = '2.*';
-const LATEST_HELM3_VERSION = '3.*';
-const helmAllReleasesUrl = 'https://api.github.com/repos/helm/helm/releases';
+const helmToolName = "helm";
+const stableHelmVersion = "v3.8.0";
+const helmAllReleasesUrl = "https://api.github.com/repos/helm/helm/releases";
 
-export function getExecutableExtension(): string {
-    if (os.type().match(/^Win/)) {
-        return '.exe';
+export async function run() {
+  let version = core.getInput("version", { required: true });
+
+  if(version !== "latest" && version[0] !== "v"){
+      version = getValidVersion(version);
   }
-    return '';
-}
-
-export function getHelmDownloadURL(version: string): string {
-    switch (os.type()) {
-        case 'Linux':
-            return util.format('https://get.helm.sh/helm-%s-linux-amd64.zip', version);
-
-        case 'Darwin':
-            return util.format('https://get.helm.sh/helm-%s-darwin-amd64.zip', version);
-
-        case 'Windows_NT':
-        default:
-            return util.format('https://get.helm.sh/helm-%s-windows-amd64.zip', version);
+  if (version.toLocaleLowerCase() === "latest") {
+    version = await getLatestHelmVersion();
   }
-}
 
-export async function getStableHelmVersion(): Promise<string> {
+  core.debug(util.format("Downloading %s", version));
+  let cachedPath = await downloadHelm(version);
+
   try {
-        const downloadPath = await toolCache.downloadTool(helmAllReleasesUrl);
-        const responseArray = JSON.parse(fs.readFileSync(downloadPath, 'utf8').toString().trim());
-        let latestHelmVersion = semver.clean(stableHelmVersion);
-        responseArray.forEach(response => {
-            if (response && response.tag_name) {
-                let currentHelmVerison = semver.clean(response.tag_name.toString());
-                if (currentHelmVerison) {
-                    if (currentHelmVerison.toString().indexOf('rc') == -1 && semver.gt(currentHelmVerison, latestHelmVersion)) {
-                        //If current helm version is not a pre release and is greater than latest helm version
-                        latestHelmVersion = currentHelmVerison;
+    if (!process.env["PATH"].startsWith(path.dirname(cachedPath))) {
+      core.addPath(path.dirname(cachedPath));
+    }
+  } catch {
+    //do nothing, set as output variable
+  }
+
+  console.log(
+    `Helm tool version: '${version}' has been cached at ${cachedPath}`
+  );
+  core.setOutput("helm-path", cachedPath);
+}
+
+//Returns version with proper v before it
+export function getValidVersion(version: string): string {
+    return "v" + version;
+} 
+
+// Downloads the helm releases JSON and parses all the recent versions of helm from it.
+// Defaults to sending stable helm version if none are valid or if it fails
+
+export async function getLatestHelmVersion(): Promise<string> {
+  const helmJSONPath: string = await toolCache.downloadTool(helmAllReleasesUrl);
+
+  try {
+    const helmJSON = JSON.parse(fs.readFileSync(helmJSONPath, "utf-8"));
+    for (let i in helmJSON) {
+      if (isValidVersion(helmJSON[i].tag_name)) {
+        return helmJSON[i].tag_name;
       }
     }
-            }
-        });
-        latestHelmVersion = "v" + latestHelmVersion;
-        return latestHelmVersion;
-    } catch (error) {
-        core.warning(util.format("Cannot get the latest Helm info from %s. Error %s. Using default Helm version %s.", helmAllReleasesUrl, error, stableHelmVersion));
+  } catch (err) {
+    core.warning(
+      util.format(
+        "Error while fetching the latest Helm release. Error: %s. Using default Helm version %s",
+        err.toString(),
+        stableHelmVersion
+      )
+    );
+    return stableHelmVersion;
   }
 
   return stableHelmVersion;
 }
 
+// isValidVersion checks if verison is a stable release
+function isValidVersion(version: string): boolean {
+  return version.indexOf("rc") == -1;
+}
+
+export function getExecutableExtension(): string {
+  if (os.type().match(/^Win/)) {
+    return ".exe";
+  }
+  return "";
+}
+
+const LINUX = "Linux";
+const MAC_OS = "Darwin";
+const WINDOWS = "Windows_NT";
+const ARM64 = "arm64";
+export function getHelmDownloadURL(version: string): string {
+  const arch = os.arch();
+  const operatingSystem = os.type();
+
+  switch (true) {
+    case operatingSystem == LINUX && arch == ARM64:
+      return util.format(
+        "https://get.helm.sh/helm-%s-linux-arm64.zip",
+        version
+      );
+    case operatingSystem == LINUX:
+      return util.format(
+        "https://get.helm.sh/helm-%s-linux-amd64.zip",
+        version
+      );
+
+    case operatingSystem == MAC_OS && arch == ARM64:
+      return util.format(
+        "https://get.helm.sh/helm-%s-darwin-arm64.zip",
+        version
+      );
+    case operatingSystem == MAC_OS:
+      return util.format(
+        "https://get.helm.sh/helm-%s-darwin-amd64.zip",
+        version
+      );
+
+    case operatingSystem == WINDOWS:
+    default:
+      return util.format(
+        "https://get.helm.sh/helm-%s-windows-amd64.zip",
+        version
+      );
+  }
+}
+
+export async function downloadHelm(version: string): Promise<string> {
+  let cachedToolpath = toolCache.find(helmToolName, version);
+  if (!cachedToolpath) {
+    let helmDownloadPath;
+    try {
+      helmDownloadPath = await toolCache.downloadTool(
+        getHelmDownloadURL(version)
+      );
+    } catch (exception) {
+      throw new Error(
+        util.format(
+          "Failed to download Helm from location",
+          getHelmDownloadURL(version)
+        )
+      );
+    }
+
+    fs.chmodSync(helmDownloadPath, "777");
+    const unzipedHelmPath = await toolCache.extractZip(helmDownloadPath);
+    cachedToolpath = await toolCache.cacheDir(
+      unzipedHelmPath,
+      helmToolName,
+      version
+    );
+  }
+
+  const helmpath = findHelm(cachedToolpath);
+  if (!helmpath) {
+    throw new Error(
+      util.format("Helm executable not found in path", cachedToolpath)
+    );
+  }
+
+  fs.chmodSync(helmpath, "777");
+  return helmpath;
+}
+
+export function findHelm(rootFolder: string): string {
+  fs.chmodSync(rootFolder, "777");
+  var filelist: string[] = [];
+  walkSync(rootFolder, filelist, helmToolName + getExecutableExtension());
+  if (!filelist || filelist.length == 0) {
+    throw new Error(
+      util.format("Helm executable not found in path", rootFolder)
+    );
+  } else {
+    return filelist[0];
+  }
+}
+
 export var walkSync = function (dir, filelist, fileToFind) {
   var files = fs.readdirSync(dir);
   filelist = filelist || [];
   files.forEach(function (file) {
     if (fs.statSync(path.join(dir, file)).isDirectory()) {
       filelist = walkSync(path.join(dir, file), filelist, fileToFind);
-        }
-        else {
+    } else {
       core.debug(file);
       if (file == fileToFind) {
         filelist.push(path.join(dir, file));
@@ -83,120 +191,4 @@ export var walkSync = function (dir, filelist, fileToFind) {
   return filelist;
 };
 
-export async function downloadHelm(version: string): Promise<string> {
-    if (!version) { version = await getStableHelmVersion(); }
-    let cachedToolpath = toolCache.find(helmToolName, version);
-    if (!cachedToolpath) {
-        let helmDownloadPath;
-        try {
-            helmDownloadPath = await toolCache.downloadTool(getHelmDownloadURL(version));
-        } catch (exception) {
-            throw new Error(util.format("Failed to download Helm from location", getHelmDownloadURL(version)));
-        }
-
-        fs.chmodSync(helmDownloadPath, '777');
-        const unzipedHelmPath = await toolCache.extractZip(helmDownloadPath);
-        cachedToolpath = await toolCache.cacheDir(unzipedHelmPath, helmToolName, version);
-    }
-
-    const helmpath = findHelm(cachedToolpath);
-    if (!helmpath) {
-        throw new Error(util.format("Helm executable not found in path", cachedToolpath));
-    }
-
-    fs.chmodSync(helmpath, '777');
-    return helmpath;
-}
-
-async function getLatestHelmVersionFor(type: string): Promise<string> {
-    const token = core.getInput('token', { 'required': true });
-    try {
-        const { repository } = await graphql(
-            `{
-                repository(name: "helm", owner: "helm") {
-                    releases(last: 100)  {
-                        nodes {
-                            tagName
-                        }
-                    }
-                }
-            }`,
-            {
-                headers: {
-                    authorization: `token ${token}`
-                }
-            }
-        );
-
-        const releases = repository.releases.nodes.reverse();
-        let latestValidRelease = releases.find(release => isValidVersion(release.tagName, type));
-        if (latestValidRelease)
-            return latestValidRelease.tagName;
-    } catch (err) {
-        core.warning(util.format("Error while fetching the latest Helm %s release. Error: %s. Using default Helm version %s.", type, err.toString(), getStableHelmVersionFor(type)));
-        return getStableHelmVersionFor(type);
-    }
-    core.warning(util.format("Could not find stable release for Helm %s. Using default Helm version %s.", type, getStableHelmVersionFor(type)));
-    return getStableHelmVersionFor(type);
-}
-
-function getStableHelmVersionFor(type: string) {
-    return type === "v2" ? stableHelm2Version : stableHelm3Version;
-}
-
-// isValidVersion checks if verison matches the specified type and is a stable release
-function isValidVersion(version: string, type: string): boolean {
-    if (!version.toLocaleLowerCase().startsWith(type))
-        return false;
-    return version.indexOf('rc') == -1;
-}
-
-export function findHelm(rootFolder: string): string {
-    fs.chmodSync(rootFolder, '777');
-    var filelist: string[] = [];
-    walkSync(rootFolder, filelist, helmToolName + getExecutableExtension());
-    if (!filelist || filelist.length == 0) {
-        throw new Error(util.format("Helm executable not found in path", rootFolder));
-    }
-    else {
-        return filelist[0];
-    }
-}
-
-export async function run() {
-    let version = core.getInput('version', { 'required': true });
-
-    if (process.env['HELM_INSTALLER_LEGACY_VERSIONING'] == 'true') {
-        if (version.toLocaleLowerCase() === 'latest') {
-            version = await getStableHelmVersion();
-        } else if (!version.toLocaleLowerCase().startsWith('v')) {
-            version = 'v' + version;
-        }
-    } else {
-        if (version.toLocaleLowerCase() === 'latest' || version === LATEST_HELM3_VERSION) {
-            version = await getLatestHelmVersionFor("v3");
-        } else if (version === LATEST_HELM2_VERSION) {
-            version = await getLatestHelmVersionFor("v2");
-        } else if (!version.toLocaleLowerCase().startsWith('v')) {
-            version = 'v' + version;
-        }
-    }
-
-    core.debug(util.format("Downloading %s", version));
-    let cachedPath = await downloadHelm(version);
-
-    try {
-
-        if (!process.env['PATH'].startsWith(path.dirname(cachedPath))) {
-            core.addPath(path.dirname(cachedPath));
-        }
-    }
-    catch {
-        //do nothing, set as output variable
-    }
-
-    console.log(`Helm tool version: '${version}' has been cached at ${cachedPath}`);
-    core.setOutput('helm-path', cachedPath);
-}
-
 run().catch(core.setFailed);