build

Release v4.2.0 (#134 )
* Update CHANGELOG.md * Update package.json * Update README.md
2024-04-15 19:42:43 +00:00 · 2024-04-15 15:41:59 -04:00 · 2024-04-12 16:23:04 -04:00 · 2024-04-12 15:46:47 -04:00 · 2024-03-08 13:33:11 -05:00
8 changed files with 397 additions and 204 deletions
--- a/.github/workflows/release-pr.yml
+++ b/.github/workflows/release-pr.yml
@ -13,6 +13,6 @@ jobs:
      permissions:
         actions: read
         contents: write
-      uses: Azure/action-release-workflows/.github/workflows/release_js_project.yaml@a705b2ab6a3ee889f2b0d925ad0bd2f9eb733ce6
+      uses: Azure/action-release-workflows/.github/workflows/release_js_project.yaml@v1
      with:
         changelogPath: ./CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,5 +1,9 @@
 # Change Log

+## [4.2.0] - 2024-04-15
+
+-  #124 Fix OS detection and download OS-native archive extension
+
 ## [4.1.0] - 2024-03-01

 -  #130 switches to use Helm published file to read latest version instead of using GitHub releases
--- a/README.md
+++ b/README.md
@ -7,7 +7,7 @@ Install a specific version of helm binary on the runner.
 Acceptable values are latest or any semantic version string like v3.5.0 Use this action in workflow to define which version of helm will be used. v2+ of this action only support Helm3.

 ```yaml
- uses: azure/setup-helm@v4.1.0
+- uses: azure/setup-helm@v4.2.0
  with:
     version: '<version>' # default is latest (stable)
  id: install
--- a/lib/index.js
+++ b/lib/index.js
@ -12308,6 +12308,132 @@ function onConnectTimeout (socket) {
 module.exports = buildConnector


+/***/ }),
+
+/***/ 4462:
+/***/ ((module) => {
+
+"use strict";
+
+
+/** @type {Record<string, string | undefined>} */
+const headerNameLowerCasedRecord = {}
+
+// https://developer.mozilla.org/docs/Web/HTTP/Headers
+const wellknownHeaderNames = [
+  'Accept',
+  'Accept-Encoding',
+  'Accept-Language',
+  'Accept-Ranges',
+  'Access-Control-Allow-Credentials',
+  'Access-Control-Allow-Headers',
+  'Access-Control-Allow-Methods',
+  'Access-Control-Allow-Origin',
+  'Access-Control-Expose-Headers',
+  'Access-Control-Max-Age',
+  'Access-Control-Request-Headers',
+  'Access-Control-Request-Method',
+  'Age',
+  'Allow',
+  'Alt-Svc',
+  'Alt-Used',
+  'Authorization',
+  'Cache-Control',
+  'Clear-Site-Data',
+  'Connection',
+  'Content-Disposition',
+  'Content-Encoding',
+  'Content-Language',
+  'Content-Length',
+  'Content-Location',
+  'Content-Range',
+  'Content-Security-Policy',
+  'Content-Security-Policy-Report-Only',
+  'Content-Type',
+  'Cookie',
+  'Cross-Origin-Embedder-Policy',
+  'Cross-Origin-Opener-Policy',
+  'Cross-Origin-Resource-Policy',
+  'Date',
+  'Device-Memory',
+  'Downlink',
+  'ECT',
+  'ETag',
+  'Expect',
+  'Expect-CT',
+  'Expires',
+  'Forwarded',
+  'From',
+  'Host',
+  'If-Match',
+  'If-Modified-Since',
+  'If-None-Match',
+  'If-Range',
+  'If-Unmodified-Since',
+  'Keep-Alive',
+  'Last-Modified',
+  'Link',
+  'Location',
+  'Max-Forwards',
+  'Origin',
+  'Permissions-Policy',
+  'Pragma',
+  'Proxy-Authenticate',
+  'Proxy-Authorization',
+  'RTT',
+  'Range',
+  'Referer',
+  'Referrer-Policy',
+  'Refresh',
+  'Retry-After',
+  'Sec-WebSocket-Accept',
+  'Sec-WebSocket-Extensions',
+  'Sec-WebSocket-Key',
+  'Sec-WebSocket-Protocol',
+  'Sec-WebSocket-Version',
+  'Server',
+  'Server-Timing',
+  'Service-Worker-Allowed',
+  'Service-Worker-Navigation-Preload',
+  'Set-Cookie',
+  'SourceMap',
+  'Strict-Transport-Security',
+  'Supports-Loading-Mode',
+  'TE',
+  'Timing-Allow-Origin',
+  'Trailer',
+  'Transfer-Encoding',
+  'Upgrade',
+  'Upgrade-Insecure-Requests',
+  'User-Agent',
+  'Vary',
+  'Via',
+  'WWW-Authenticate',
+  'X-Content-Type-Options',
+  'X-DNS-Prefetch-Control',
+  'X-Frame-Options',
+  'X-Permitted-Cross-Domain-Policies',
+  'X-Powered-By',
+  'X-Requested-With',
+  'X-XSS-Protection'
+]
+
+for (let i = 0; i < wellknownHeaderNames.length; ++i) {
+  const key = wellknownHeaderNames[i]
+  const lowerCasedKey = key.toLowerCase()
+  headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] =
+    lowerCasedKey
+}
+
+// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(headerNameLowerCasedRecord, null)
+
+module.exports = {
+  wellknownHeaderNames,
+  headerNameLowerCasedRecord
+}
+
+
 /***/ }),

 /***/ 8045:
@ -13140,6 +13266,7 @@ const { InvalidArgumentError } = __nccwpck_require__(8045)
 const { Blob } = __nccwpck_require__(4300)
 const nodeUtil = __nccwpck_require__(3837)
 const { stringify } = __nccwpck_require__(3477)
+const { headerNameLowerCasedRecord } = __nccwpck_require__(4462)

 const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))

@ -13349,6 +13476,15 @@ function parseKeepAliveTimeout (val) {
  return m ? parseInt(m[1], 10) * 1000 : null
 }

+/**
+ * Retrieves a header name and returns its lowercase value.
+ * @param {string | Buffer} value Header name
+ * @returns {string}
+ */
+function headerNameToString (value) {
+  return headerNameLowerCasedRecord[value] || value.toLowerCase()
+}
+
 function parseHeaders (headers, obj = {}) {
  // For H2 support
  if (!Array.isArray(headers)) return headers
@ -13620,6 +13756,7 @@ module.exports = {
  isIterable,
  isAsyncIterable,
  isDestroyed,
+  headerNameToString,
  parseRawHeaders,
  parseHeaders,
  parseKeepAliveTimeout,
@ -17756,6 +17893,9 @@ function httpRedirectFetch (fetchParams, response) {
    // https://fetch.spec.whatwg.org/#cors-non-wildcard-request-header-name
    request.headersList.delete('authorization')

+    // https://fetch.spec.whatwg.org/#authentication-entries
+    request.headersList.delete('proxy-authorization', true)
+
    // "Cookie" and "Host" are forbidden request-headers, which undici doesn't implement.
    request.headersList.delete('cookie')
    request.headersList.delete('host')
@ -20264,14 +20404,18 @@ const { isBlobLike, toUSVString, ReadableStreamFrom } = __nccwpck_require__(3983
 const assert = __nccwpck_require__(9491)
 const { isUint8Array } = __nccwpck_require__(9830)

+let supportedHashes = []
+
 // https://nodejs.org/api/crypto.html#determining-if-crypto-support-is-unavailable
 /** @type {import('crypto')|undefined} */
 let crypto

 try {
  crypto = __nccwpck_require__(6113)
+  const possibleRelevantHashes = ['sha256', 'sha384', 'sha512']
+  supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash))
+/* c8 ignore next 3 */
 } catch {
-
 }

 function responseURL (response) {
@ -20799,66 +20943,56 @@ function bytesMatch (bytes, metadataList) {
    return true
  }

-  // 3. If parsedMetadata is the empty set, return true.
+  // 3. If response is not eligible for integrity validation, return false.
+  // TODO
+
+  // 4. If parsedMetadata is the empty set, return true.
  if (parsedMetadata.length === 0) {
    return true
  }

-  // 4. Let metadata be the result of getting the strongest
+  // 5. Let metadata be the result of getting the strongest
  //    metadata from parsedMetadata.
-  const list = parsedMetadata.sort((c, d) => d.algo.localeCompare(c.algo))
-  // get the strongest algorithm
-  const strongest = list[0].algo
-  // get all entries that use the strongest algorithm; ignore weaker
-  const metadata = list.filter((item) => item.algo === strongest)
+  const strongest = getStrongestMetadata(parsedMetadata)
+  const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest)

-  // 5. For each item in metadata:
+  // 6. For each item in metadata:
  for (const item of metadata) {
    // 1. Let algorithm be the alg component of item.
    const algorithm = item.algo

    // 2. Let expectedValue be the val component of item.
-    let expectedValue = item.hash
+    const expectedValue = item.hash

    // See https://github.com/web-platform-tests/wpt/commit/e4c5cc7a5e48093220528dfdd1c4012dc3837a0e
    // "be liberal with padding". This is annoying, and it's not even in the spec.

-    if (expectedValue.endsWith('==')) {
-      expectedValue = expectedValue.slice(0, -2)
-    }
-
    // 3. Let actualValue be the result of applying algorithm to bytes.
    let actualValue = crypto.createHash(algorithm).update(bytes).digest('base64')

-    if (actualValue.endsWith('==')) {
-      actualValue = actualValue.slice(0, -2)
+    if (actualValue[actualValue.length - 1] === '=') {
+      if (actualValue[actualValue.length - 2] === '=') {
+        actualValue = actualValue.slice(0, -2)
+      } else {
+        actualValue = actualValue.slice(0, -1)
+      }
    }

    // 4. If actualValue is a case-sensitive match for expectedValue,
    //    return true.
-    if (actualValue === expectedValue) {
-      return true
-    }
-
-    let actualBase64URL = crypto.createHash(algorithm).update(bytes).digest('base64url')
-
-    if (actualBase64URL.endsWith('==')) {
-      actualBase64URL = actualBase64URL.slice(0, -2)
-    }
-
-    if (actualBase64URL === expectedValue) {
+    if (compareBase64Mixed(actualValue, expectedValue)) {
      return true
    }
  }

-  // 6. Return false.
+  // 7. Return false.
  return false
 }

 // https://w3c.github.io/webappsec-subresource-integrity/#grammardef-hash-with-options
 // https://www.w3.org/TR/CSP2/#source-list-syntax
 // https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1
-const parseHashWithOptions = /((?<algo>sha256|sha384|sha512)-(?<hash>[A-z0-9+/]{1}.*={0,2}))( +[\x21-\x7e]?)?/i
+const parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i

 /**
 * @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
@ -20872,8 +21006,6 @@ function parseMetadata (metadata) {
  // 2. Let empty be equal to true.
  let empty = true

-  const supportedHashes = crypto.getHashes()
-
  // 3. For each token returned by splitting metadata on spaces:
  for (const token of metadata.split(' ')) {
    // 1. Set empty to false.
@ -20883,7 +21015,11 @@ function parseMetadata (metadata) {
    const parsedToken = parseHashWithOptions.exec(token)

    // 3. If token does not parse, continue to the next token.
-    if (parsedToken === null || parsedToken.groups === undefined) {
+    if (
+      parsedToken === null ||
+      parsedToken.groups === undefined ||
+      parsedToken.groups.algo === undefined
+    ) {
      // Note: Chromium blocks the request at this point, but Firefox
      // gives a warning that an invalid integrity was given. The
      // correct behavior is to ignore these, and subsequently not
@ -20892,11 +21028,11 @@ function parseMetadata (metadata) {
    }

    // 4. Let algorithm be the hash-algo component of token.
-    const algorithm = parsedToken.groups.algo
+    const algorithm = parsedToken.groups.algo.toLowerCase()

    // 5. If algorithm is a hash function recognized by the user
    //    agent, add the parsed token to result.
-    if (supportedHashes.includes(algorithm.toLowerCase())) {
+    if (supportedHashes.includes(algorithm)) {
      result.push(parsedToken.groups)
    }
  }
@ -20909,6 +21045,82 @@ function parseMetadata (metadata) {
  return result
 }

+/**
+ * @param {{ algo: 'sha256' | 'sha384' | 'sha512' }[]} metadataList
+ */
+function getStrongestMetadata (metadataList) {
+  // Let algorithm be the algo component of the first item in metadataList.
+  // Can be sha256
+  let algorithm = metadataList[0].algo
+  // If the algorithm is sha512, then it is the strongest
+  // and we can return immediately
+  if (algorithm[3] === '5') {
+    return algorithm
+  }
+
+  for (let i = 1; i < metadataList.length; ++i) {
+    const metadata = metadataList[i]
+    // If the algorithm is sha512, then it is the strongest
+    // and we can break the loop immediately
+    if (metadata.algo[3] === '5') {
+      algorithm = 'sha512'
+      break
+    // If the algorithm is sha384, then a potential sha256 or sha384 is ignored
+    } else if (algorithm[3] === '3') {
+      continue
+    // algorithm is sha256, check if algorithm is sha384 and if so, set it as
+    // the strongest
+    } else if (metadata.algo[3] === '3') {
+      algorithm = 'sha384'
+    }
+  }
+  return algorithm
+}
+
+function filterMetadataListByAlgorithm (metadataList, algorithm) {
+  if (metadataList.length === 1) {
+    return metadataList
+  }
+
+  let pos = 0
+  for (let i = 0; i < metadataList.length; ++i) {
+    if (metadataList[i].algo === algorithm) {
+      metadataList[pos++] = metadataList[i]
+    }
+  }
+
+  metadataList.length = pos
+
+  return metadataList
+}
+
+/**
+ * Compares two base64 strings, allowing for base64url
+ * in the second string.
+ *
+* @param {string} actualValue always base64
+ * @param {string} expectedValue base64 or base64url
+ * @returns {boolean}
+ */
+function compareBase64Mixed (actualValue, expectedValue) {
+  if (actualValue.length !== expectedValue.length) {
+    return false
+  }
+  for (let i = 0; i < actualValue.length; ++i) {
+    if (actualValue[i] !== expectedValue[i]) {
+      if (
+        (actualValue[i] === '+' && expectedValue[i] === '-') ||
+        (actualValue[i] === '/' && expectedValue[i] === '_')
+      ) {
+        continue
+      }
+      return false
+    }
+  }
+
+  return true
+}
+
 // https://w3c.github.io/webappsec-upgrade-insecure-requests/#upgrade-request
 function tryUpgradeRequestToAPotentiallyTrustworthyURL (request) {
  // TODO
@ -21324,7 +21536,8 @@ module.exports = {
  urlHasHttpsScheme,
  urlIsHttpHttpsScheme,
  readAllBytes,
-  normalizeMethodRecord
+  normalizeMethodRecord,
+  parseMetadata
 }


@ -23411,12 +23624,17 @@ function parseLocation (statusCode, headers) {

 // https://tools.ietf.org/html/rfc7231#section-6.4.4
 function shouldRemoveHeader (header, removeContent, unknownOrigin) {
-  return (
-    (header.length === 4 && header.toString().toLowerCase() === 'host') ||
-    (removeContent && header.toString().toLowerCase().indexOf('content-') === 0) ||
-    (unknownOrigin && header.length === 13 && header.toString().toLowerCase() === 'authorization') ||
-    (unknownOrigin && header.length === 6 && header.toString().toLowerCase() === 'cookie')
-  )
+  if (header.length === 4) {
+    return util.headerNameToString(header) === 'host'
+  }
+  if (removeContent && util.headerNameToString(header).startsWith('content-')) {
+    return true
+  }
+  if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
+    const name = util.headerNameToString(header)
+    return name === 'authorization' || name === 'cookie' || name === 'proxy-authorization'
+  }
+  return false
 }

 // https://tools.ietf.org/html/rfc7231#section-6.4
@ -28582,7 +28800,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
    });
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.walkSync = exports.findHelm = exports.downloadHelm = exports.getHelmDownloadURL = exports.getExecutableExtension = exports.getLatestHelmVersion = exports.getValidVersion = exports.run = void 0;
+exports.walkSync = exports.findHelm = exports.downloadHelm = exports.getHelmDownloadURL = exports.getExecutableExtension = exports.getArchiveExtension = exports.getPlatform = exports.getArch = exports.getLatestHelmVersion = exports.getValidVersion = exports.run = void 0;
 const os = __nccwpck_require__(2037);
 const path = __nccwpck_require__(1017);
 const util = __nccwpck_require__(3837);
@ -28638,38 +28856,24 @@ function getLatestHelmVersion() {
    });
 }
 exports.getLatestHelmVersion = getLatestHelmVersion;
+function getArch() {
+    return os.arch() === 'x64' ? 'amd64' : os.arch();
+}
+exports.getArch = getArch;
+function getPlatform() {
+    return os.platform() === 'win32' ? 'windows' : os.platform();
+}
+exports.getPlatform = getPlatform;
+function getArchiveExtension() {
+    return os.platform() === 'win32' ? 'zip' : 'tar.gz';
+}
+exports.getArchiveExtension = getArchiveExtension;
 function getExecutableExtension() {
-    if (os.type().match(/^Win/)) {
-        return '.exe';
-    }
-    return '';
+    return os.platform() === 'win32' ? '.exe' : '';
 }
 exports.getExecutableExtension = getExecutableExtension;
-const LINUX = 'Linux';
-const MAC_OS = 'Darwin';
-const WINDOWS = 'Windows_NT';
-const ARM64 = 'arm64';
 function getHelmDownloadURL(baseURL, version) {
-    const arch = os.arch();
-    const operatingSystem = os.type();
-    let urlPath = '';
-    switch (true) {
-        case operatingSystem == LINUX && arch == ARM64:
-            urlPath = util.format(`/helm-%s-linux-arm64.zip`, version);
-            break;
-        case operatingSystem == LINUX:
-            urlPath = util.format(`/helm-%s-linux-amd64.zip`, version);
-            break;
-        case operatingSystem == MAC_OS && arch == ARM64:
-            urlPath = util.format(`/helm-%s-darwin-arm64.zip`, version);
-            break;
-        case operatingSystem == MAC_OS:
-            urlPath = util.format(`/helm-%s-darwin-amd64.zip`, version);
-            break;
-        case operatingSystem == WINDOWS:
-        default:
-            urlPath = util.format(`/helm-%s-windows-amd64.zip`, version);
-    }
+    const urlPath = `helm-${version}-${getPlatform()}-${getArch()}.${getArchiveExtension()}`;
    const url = new URL(urlPath, baseURL);
    return url.toString();
 }
@ -28686,8 +28890,10 @@ function downloadHelm(baseURL, version) {
                throw new Error(`Failed to download Helm from location ${getHelmDownloadURL(baseURL, version)}`);
            }
            fs.chmodSync(helmDownloadPath, '777');
-            const unzipedHelmPath = yield toolCache.extractZip(helmDownloadPath);
-            cachedToolpath = yield toolCache.cacheDir(unzipedHelmPath, helmToolName, version);
+            const extractedPath = getPlatform() === 'windows'
+                ? yield toolCache.extractZip(helmDownloadPath)
+                : yield toolCache.extractTar(helmDownloadPath);
+            cachedToolpath = yield toolCache.cacheDir(extractedPath, helmToolName, version);
        }
        const helmpath = findHelm(cachedToolpath);
        if (!helmpath) {
--- a/package-lock.json
+++ b/package-lock.json
@ -1,12 +1,12 @@
 {
   "name": "setuphelm",
-   "version": "4.1.0",
+   "version": "4.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
      "": {
         "name": "setuphelm",
-         "version": "4.1.0",
+         "version": "4.2.0",
         "license": "MIT",
         "dependencies": {
            "@actions/core": "^1.10.0",
@ -1117,12 +1117,9 @@
         }
      },
      "node_modules/@octokit/action/node_modules/undici": {
-         "version": "6.5.0",
-         "resolved": "https://registry.npmjs.org/undici/-/undici-6.5.0.tgz",
-         "integrity": "sha512-/MUmPb2ptTvp1j7lPvdMSofMdqPxcOhAaKZi4k55sqm6XMeKI3n1dZJ5cnD4gLjpt2l7CIlthR1IXM59xKhpxw==",
-         "dependencies": {
-            "@fastify/busboy": "^2.0.0"
-         },
+         "version": "6.11.1",
+         "resolved": "https://registry.npmjs.org/undici/-/undici-6.11.1.tgz",
+         "integrity": "sha512-KyhzaLJnV1qa3BSHdj4AZ2ndqI0QWPxYzaIOio0WzcEJB9gvuysprJSLtpvc2D9mhR9jPDUk7xlJlZbH2KR5iw==",
         "engines": {
            "node": ">=18.0"
         }
@ -3840,9 +3837,9 @@
         "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og=="
      },
      "node_modules/undici": {
-         "version": "5.28.2",
-         "resolved": "https://registry.npmjs.org/undici/-/undici-5.28.2.tgz",
-         "integrity": "sha512-wh1pHJHnUeQV5Xa8/kyQhO7WFa8M34l026L5P/+2TYiakvGy5Rdc8jWZVyG7ieht/0WgJLEd3kcU5gKx+6GC8w==",
+         "version": "5.28.4",
+         "resolved": "https://registry.npmjs.org/undici/-/undici-5.28.4.tgz",
+         "integrity": "sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==",
         "dependencies": {
            "@fastify/busboy": "^2.0.0"
         },
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
   "name": "setuphelm",
-   "version": "4.1.0",
+   "version": "4.2.0",
   "private": true,
   "description": "Setup helm",
   "author": "Anumita Shenoy",
--- a/src/run.test.ts
+++ b/src/run.test.ts
@ -6,84 +6,74 @@ import * as path from 'path'
 import * as core from '@actions/core'

 describe('run.ts', () => {
+   const downloadBaseURL = 'https://test.tld'
+
+   // Cleanup mocks after each test to ensure that subsequent tests are not affected by the mocks.
+   afterEach(() => {
+      jest.restoreAllMocks()
+   })
+
   test('getExecutableExtension() - return .exe when os is Windows', () => {
-      jest.spyOn(os, 'type').mockReturnValue('Windows_NT')
+      jest.spyOn(os, 'platform').mockReturnValue('win32')

      expect(run.getExecutableExtension()).toBe('.exe')
-      expect(os.type).toHaveBeenCalled()
+      expect(os.platform).toHaveBeenCalled()
   })

   test('getExecutableExtension() - return empty string for non-windows OS', () => {
-      jest.spyOn(os, 'type').mockReturnValue('Darwin')
+      jest.spyOn(os, 'platform').mockReturnValue('darwin')

      expect(run.getExecutableExtension()).toBe('')
-      expect(os.type).toHaveBeenCalled()
+      expect(os.platform).toHaveBeenCalled()
   })

-   test('getHelmDownloadURL() - return the URL to download helm for Linux', () => {
-      const downloadBaseURL = 'https://test.tld'
+   test('getHelmDownloadURL() - return the URL to download helm for Linux amd64', () => {
+      jest.spyOn(os, 'platform').mockReturnValue('linux')
+      jest.spyOn(os, 'arch').mockReturnValue('x64')
+      const expected = 'https://test.tld/helm-v3.8.0-linux-amd64.tar.gz'

-      jest.spyOn(os, 'type').mockReturnValue('Linux')
-      jest.spyOn(os, 'arch').mockReturnValueOnce('unknown')
-      const helmLinuxUrl = 'https://test.tld/helm-v3.8.0-linux-amd64.zip'
-
-      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(
-         helmLinuxUrl
-      )
-      expect(os.type).toHaveBeenCalled()
-      expect(os.arch).toHaveBeenCalled()
-
-      // arm64
-      jest.spyOn(os, 'type').mockReturnValue('Linux')
-      jest.spyOn(os, 'arch').mockReturnValueOnce('arm64')
-      const helmLinuxArm64Url = 'https://test.tld/helm-v3.8.0-linux-arm64.zip'
-
-      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(
-         helmLinuxArm64Url
-      )
-      expect(os.type).toHaveBeenCalled()
+      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(expected)
+      expect(os.platform).toHaveBeenCalled()
      expect(os.arch).toHaveBeenCalled()
   })

-   test('getHelmDownloadURL() - return the URL to download helm for Darwin', () => {
-      const downloadBaseURL = 'https://test.tld'
+   test('getHelmDownloadURL() - return the URL to download helm for Linux arm64', () => {
+      jest.spyOn(os, 'platform').mockReturnValue('linux')
+      jest.spyOn(os, 'arch').mockReturnValue('arm64')
+      const expected = 'https://test.tld/helm-v3.8.0-linux-arm64.tar.gz'

-      jest.spyOn(os, 'type').mockReturnValue('Darwin')
-      jest.spyOn(os, 'arch').mockReturnValueOnce('unknown')
-      const helmDarwinUrl = 'https://test.tld/helm-v3.8.0-darwin-amd64.zip'
-
-      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(
-         helmDarwinUrl
-      )
-      expect(os.type).toHaveBeenCalled()
-      expect(os.arch).toHaveBeenCalled()
-
-      // arm64
-      jest.spyOn(os, 'type').mockReturnValue('Darwin')
-      jest.spyOn(os, 'arch').mockReturnValueOnce('arm64')
-      const helmDarwinArm64Url = 'https://test.tld/helm-v3.8.0-darwin-arm64.zip'
-
-      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(
-         helmDarwinArm64Url
-      )
-      expect(os.type).toHaveBeenCalled()
+      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(expected)
+      expect(os.platform).toHaveBeenCalled()
      expect(os.arch).toHaveBeenCalled()
   })

-   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 Darwin x64', () => {
+      jest.spyOn(os, 'platform').mockReturnValue('darwin')
+      jest.spyOn(os, 'arch').mockReturnValue('x64')
+      const expected = 'https://test.tld/helm-v3.8.0-darwin-amd64.tar.gz'
+
+      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(expected)
+      expect(os.platform).toHaveBeenCalled()
+      expect(os.arch).toHaveBeenCalled()
+   })
+
+   test('getHelmDownloadURL() - return the URL to download helm for Darwin arm64', () => {
+      jest.spyOn(os, 'platform').mockReturnValue('darwin')
+      jest.spyOn(os, 'arch').mockReturnValue('arm64')
+      const expected = 'https://test.tld/helm-v3.8.0-darwin-arm64.tar.gz'
+
+      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(expected)
+      expect(os.platform).toHaveBeenCalled()
+      expect(os.arch).toHaveBeenCalled()
   })

   test('getHelmDownloadURL() - return the URL to download helm for Windows', () => {
-      const downloadBaseURL = 'https://test.tld'
+      jest.spyOn(os, 'platform').mockReturnValue('win32')
+      jest.spyOn(os, 'arch').mockReturnValue('x64')

-      jest.spyOn(os, 'type').mockReturnValue('Windows_NT')
-
-      const helmWindowsUrl = 'https://test.tld/helm-v3.8.0-windows-amd64.zip'
-      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(
-         helmWindowsUrl
-      )
-      expect(os.type).toHaveBeenCalled()
+      const expected = 'https://test.tld/helm-v3.8.0-windows-amd64.zip'
+      expect(run.getHelmDownloadURL(downloadBaseURL, 'v3.8.0')).toBe(expected)
+      expect(os.platform).toHaveBeenCalled()
   })

   test('getLatestHelmVersion() - return the latest version of HELM', async () => {
@ -101,6 +91,10 @@ describe('run.ts', () => {
      expect(await run.getLatestHelmVersion()).toBe('v3.13.3')
   })

+   test('getValidVersion() - return version with v prepended', () => {
+      expect(run.getValidVersion('3.8.0')).toBe('v3.8.0')
+   })
+
   test('walkSync() - return path to the all files matching fileToFind in dir', () => {
      jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
         if (file == 'mainFolder')
@ -120,6 +114,7 @@ describe('run.ts', () => {
               'file21' as unknown as fs.Dirent,
               'file22' as unknown as fs.Dirent
            ]
+         return []
      })
      jest.spyOn(core, 'debug').mockImplementation()
      jest.spyOn(fs, 'statSync').mockImplementation((file) => {
@ -154,6 +149,7 @@ describe('run.ts', () => {
               'file21' as unknown as fs.Dirent,
               'file22' as unknown as fs.Dirent
            ]
+         return []
      })
      jest.spyOn(core, 'debug').mockImplementation()
      jest.spyOn(fs, 'statSync').mockImplementation((file) => {
@ -171,13 +167,14 @@ describe('run.ts', () => {
      jest.spyOn(fs, 'chmodSync').mockImplementation(() => {})
      jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
         if (file == 'mainFolder') return ['helm.exe' as unknown as fs.Dirent]
+         return []
      })
      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')
+      jest.spyOn(os, 'platform').mockReturnValue('win32')

      expect(run.findHelm('mainFolder')).toBe(
         path.join('mainFolder', 'helm.exe')
@ -188,11 +185,13 @@ describe('run.ts', () => {
      jest.spyOn(fs, 'chmodSync').mockImplementation(() => {})
      jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
         if (file == 'mainFolder') return []
+         return []
      })
      jest.spyOn(fs, 'statSync').mockImplementation((file) => {
         return {isDirectory: () => true} as fs.Stats
      })
-      jest.spyOn(os, 'type').mockReturnValue('Windows_NT')
+      jest.spyOn(os, 'platform').mockReturnValue('win32')
+
      expect(() => run.findHelm('mainFolder')).toThrow(
         'Helm executable not found in path mainFolder'
      )
@ -203,11 +202,9 @@ describe('run.ts', () => {
      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(os, 'platform').mockReturnValue('win32')
      jest.spyOn(fs, 'chmodSync').mockImplementation(() => {})
-      jest
-         .spyOn(toolCache, 'extractZip')
-         .mockResolvedValue('pathToUnzippedHelm')
+      jest.spyOn(toolCache, 'extractZip').mockResolvedValue('extractedPath')
      jest.spyOn(toolCache, 'cacheDir').mockResolvedValue('pathToCachedDir')
      jest
         .spyOn(fs, 'readdirSync')
@ -218,9 +215,7 @@ describe('run.ts', () => {
         return {isDirectory: () => isDirectory} as fs.Stats
      })

-      const baseURL = 'https://test.tld'
-
-      expect(await run.downloadHelm(baseURL, 'v4.0.0')).toBe(
+      expect(await run.downloadHelm(downloadBaseURL, 'v4.0.0')).toBe(
         path.join('pathToCachedDir', 'helm.exe')
      )
      expect(toolCache.find).toHaveBeenCalledWith('helm', 'v4.0.0')
@ -240,26 +235,33 @@ describe('run.ts', () => {
      jest.spyOn(toolCache, 'downloadTool').mockImplementation(async () => {
         throw 'Unable to download'
      })
-      jest.spyOn(os, 'type').mockReturnValue('Windows_NT')
+      jest.spyOn(os, 'platform').mockReturnValue('win32')

-      const baseURL = 'https://test.tld'
-
-      await expect(run.downloadHelm(baseURL, 'v3.2.1')).rejects.toThrow(
-         'Failed to download Helm from location https://test.tld/helm-v3.2.1-windows-amd64.zip'
+      const downloadUrl = 'https://test.tld/helm-v3.2.1-windows-amd64.zip'
+      await expect(run.downloadHelm(downloadBaseURL, 'v3.2.1')).rejects.toThrow(
+         `Failed to download Helm from location ${downloadUrl}`
      )
      expect(toolCache.find).toHaveBeenCalledWith('helm', 'v3.2.1')
-      expect(toolCache.downloadTool).toHaveBeenCalledWith(
-         'https://test.tld/helm-v3.2.1-windows-amd64.zip'
-      )
+      expect(toolCache.downloadTool).toHaveBeenCalledWith(`${downloadUrl}`)
   })

   test('downloadHelm() - return path to helm tool with same version from toolCache', async () => {
      jest.spyOn(toolCache, 'find').mockReturnValue('pathToCachedDir')
+      jest.spyOn(toolCache, 'cacheDir').mockResolvedValue('pathToCachedDir')
+      jest.spyOn(toolCache, 'downloadTool').mockResolvedValue('pathToTool')
+      jest.spyOn(toolCache, 'extractZip').mockResolvedValue('extractedPath')
+      jest.spyOn(os, 'platform').mockReturnValue('win32')
      jest.spyOn(fs, 'chmodSync').mockImplementation(() => {})
+      jest
+         .spyOn(fs, 'readdirSync')
+         .mockReturnValue(['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
+      })

-      const baseURL = 'https://test.tld'
-
-      expect(await run.downloadHelm(baseURL, 'v3.2.1')).toBe(
+      expect(await run.downloadHelm(downloadBaseURL, 'v3.2.1')).toBe(
         path.join('pathToCachedDir', 'helm.exe')
      )
      expect(toolCache.find).toHaveBeenCalledWith('helm', 'v3.2.1')
@ -272,12 +274,11 @@ describe('run.ts', () => {
   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(toolCache, 'downloadTool').mockResolvedValue('pathToTool')
+      jest.spyOn(toolCache, 'extractZip').mockResolvedValue('extractedPath')
+      jest.spyOn(os, 'platform').mockReturnValue('win32')
+      jest.spyOn(fs, 'chmodSync').mockImplementation()
      jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => [])
      jest.spyOn(fs, 'statSync').mockImplementation((file) => {
         const isDirectory =
@ -285,9 +286,7 @@ describe('run.ts', () => {
         return {isDirectory: () => isDirectory} as fs.Stats
      })

-      const baseURL = 'https://test.tld'
-
-      await expect(run.downloadHelm(baseURL, 'v3.2.1')).rejects.toThrow(
+      await expect(run.downloadHelm(downloadBaseURL, 'v3.2.1')).rejects.toThrow(
         'Helm executable not found in path pathToCachedDir'
      )
      expect(toolCache.find).toHaveBeenCalledWith('helm', 'v3.2.1')
--- a/src/run.ts
+++ b/src/run.ts
@ -61,41 +61,24 @@ export async function getLatestHelmVersion(): Promise<string> {
   }
 }

-export function getExecutableExtension(): string {
-   if (os.type().match(/^Win/)) {
-      return '.exe'
-   }
-   return ''
+export function getArch(): string {
+   return os.arch() === 'x64' ? 'amd64' : os.arch()
+}
+
+export function getPlatform(): string {
+   return os.platform() === 'win32' ? 'windows' : os.platform()
+}
+
+export function getArchiveExtension(): string {
+   return os.platform() === 'win32' ? 'zip' : 'tar.gz'
+}
+
+export function getExecutableExtension(): string {
+   return os.platform() === 'win32' ? '.exe' : ''
 }

-const LINUX = 'Linux'
-const MAC_OS = 'Darwin'
-const WINDOWS = 'Windows_NT'
-const ARM64 = 'arm64'
 export function getHelmDownloadURL(baseURL: string, version: string): string {
-   const arch = os.arch()
-   const operatingSystem = os.type()
-
-   let urlPath = ''
-
-   switch (true) {
-      case operatingSystem == LINUX && arch == ARM64:
-         urlPath = util.format(`/helm-%s-linux-arm64.zip`, version)
-         break
-      case operatingSystem == LINUX:
-         urlPath = util.format(`/helm-%s-linux-amd64.zip`, version)
-         break
-      case operatingSystem == MAC_OS && arch == ARM64:
-         urlPath = util.format(`/helm-%s-darwin-arm64.zip`, version)
-         break
-      case operatingSystem == MAC_OS:
-         urlPath = util.format(`/helm-%s-darwin-amd64.zip`, version)
-         break
-      case operatingSystem == WINDOWS:
-      default:
-         urlPath = util.format(`/helm-%s-windows-amd64.zip`, version)
-   }
-
+   const urlPath = `helm-${version}-${getPlatform()}-${getArch()}.${getArchiveExtension()}`
   const url = new URL(urlPath, baseURL)
   return url.toString()
 }
@ -121,9 +104,13 @@ export async function downloadHelm(
      }

      fs.chmodSync(helmDownloadPath, '777')
-      const unzipedHelmPath = await toolCache.extractZip(helmDownloadPath)
+      const extractedPath =
+         getPlatform() === 'windows'
+            ? await toolCache.extractZip(helmDownloadPath)
+            : await toolCache.extractTar(helmDownloadPath)
+
      cachedToolpath = await toolCache.cacheDir(
-         unzipedHelmPath,
+         extractedPath,
         helmToolName,
         version
      )
Author	SHA1	Message	Date
GitHub Action	fe7b79cd5e	build	2024-04-15 19:42:43 +00:00
David Gamero	df50d879fa	Release v4.2.0 (#134 ) * Update CHANGELOG.md * Update package.json * Update README.md	2024-04-15 15:41:59 -04:00
dependabot[bot]	08d7123a4a	Bump undici from 5.28.2 to 5.28.4 (#133 ) Bumps [undici](https://github.com/nodejs/undici) from 5.28.2 to 5.28.4. - [Release notes](https://github.com/nodejs/undici/releases) - [Commits](https://github.com/nodejs/undici/compare/v5.28.2...v5.28.4) --- updated-dependencies: - dependency-name: undici dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-04-12 16:23:04 -04:00
Dmytro Bondar	0a0c55a4c3	Fix os detection and archive extension (#124 )	2024-04-12 15:46:47 -04:00
David Gamero	d00ce1cb5e	update to release workflow major version tag (#132 )	2024-03-08 13:33:11 -05:00