chore: bump version to 6.5.0 in package.json and package-lock.json (#762)

* chore: bump version to 6.5.0 in package.json and package-lock.json

* chore: update README.md for improved clarity and structure

* License update

.eslintignore

@@ -0,0 +1,6 @@
+# Ignore list
+/*
+
+# Do not ignore these folders:
+!__tests__/
+!src/

.eslintrc.js

@@ -0,0 +1,51 @@
+// This is a reusable configuration file copied from https://github.com/actions/reusable-workflows/tree/main/reusable-configurations. Please don't make changes to this file as it's the subject of an automatic update.
+module.exports = {
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:eslint-plugin-jest/recommended',
+    'eslint-config-prettier'
+  ],
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint', 'eslint-plugin-node', 'eslint-plugin-jest'],
+  rules: {
+    '@typescript-eslint/no-require-imports': 'error',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-empty-function': 'off',
+    '@typescript-eslint/ban-ts-comment': [
+      'error',
+      {
+        'ts-ignore': 'allow-with-description'
+      }
+    ],
+    'no-console': 'error',
+    'yoda': 'error',
+    'prefer-const': [
+      'error',
+      {
+        destructuring: 'all'
+      }
+    ],
+    'no-control-regex': 'off',
+    'no-constant-condition': ['error', {checkLoops: false}],
+    'node/no-extraneous-import': 'error'
+  },
+  overrides: [
+    {
+      files: ['**/*{test,spec}.ts'],
+      rules: {
+        '@typescript-eslint/no-unused-vars': 'off',
+        'jest/no-standalone-expect': 'off',
+        'jest/no-conditional-expect': 'off',
+        'no-console': 'off',
+
+      }
+    }
+  ],
+  env: {
+    node: true,
+    es6: true,
+    'jest/globals': true
+  }
+};

.gitattributes

@@ -1,2 +1,2 @@
-* text=auto
+* text=auto eol=lf
 .licenses/** -diff linguist-generated=true

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,7 +7,7 @@ assignees: ''
 
 ---
 
-<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.com/orgs/community/discussions/categories/actions --->
 <!--- Before opening up a new bug report, please make sure to check for similar existing issues -->
 
 **Description:**

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +1 @@
-blank_issues_enabled: false
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -5,7 +5,7 @@ title: ''
 labels: feature request, needs triage
 assignees: ''
 ---
-<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.com/orgs/community/discussions/categories/actions --->
 <!--- Before opening up a new feature request, please make sure to check for similar existing issues and pull requests -->
 
 **Description:**

.github/dependabot.yml

@@ -0,0 +1,22 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  # Enable version updates for npm
+  - package-ecosystem: 'npm'
+    # Look for `package.json` and `lock` files in the `root` directory
+    directory: '/'
+    # Check the npm registry for updates every day (weekdays)
+    schedule:
+      interval: 'weekly'
+
+  # Enable version updates for GitHub Actions
+  - package-ecosystem: 'github-actions'
+    # Workflow files stored in the default location of `.github/workflows`
+    # You don't need to specify `/.github/workflows` for `directory`. You can use `directory: "/"`.
+    directory: '/'
+    schedule:
+      interval: 'weekly'

.github/workflows/basic-validation.yml

@@ -0,0 +1,18 @@
+name: Basic validation
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  call-basic-validation:
+    name: Basic validation
+    uses: actions/reusable-workflows/.github/workflows/basic-validation.yml@main
+    with:
+      node-version: '24.x'

.github/workflows/check-dist.yml

@@ -1,8 +1,3 @@
-# `dist/index.js` is a special file in Actions.
-# When you reference an action with `uses:` in a workflow,
-# `index.js` is the code that will run.
-# For our project, we generate this file through a build process from other source files.
-# We need to make sure the checked-in `index.js` actually matches what we expect it to be.
 name: Check dist/
 
 on:
@@ -17,36 +12,8 @@ on:
   workflow_dispatch:
 
 jobs:
-  check-dist:
+  call-check-dist:
-    runs-on: ubuntu-latest
+    name: Check dist/
-
+    uses: actions/reusable-workflows/.github/workflows/check-dist.yml@main
-    steps:
+    with:
-      - uses: actions/checkout@v3
+      node-version: '24.x'
-
-      - name: Set Node.js 16.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16.x
-          cache: npm
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Rebuild the dist/ directory
-        run: npm run build
-
-      - name: Compare the expected and actual dist/ directories
-        run: |
-          if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; then
-            echo "Detected uncommitted changes after build.  See status below:"
-            git diff
-            exit 1
-          fi
-        id: diff
-
-      # If index.js was different than expected, upload the expected version as an artifact
-      - uses: actions/upload-artifact@v3
-        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
-        with:
-          name: dist
-          path: dist/

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,14 @@
+name: CodeQL analysis
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '0 3 * * 0'
+
+jobs:
+  call-codeQL-analysis:
+    name: CodeQL analysis
+    uses: actions/reusable-workflows/.github/workflows/codeql-analysis.yml@main

.github/workflows/licensed.yml

@@ -9,20 +9,6 @@ on:
       - main
 
 jobs:
-  test:
+  call-licensed:
-    runs-on: ubuntu-latest
+    name: Licensed
-    name: Check licenses
+    uses: actions/reusable-workflows/.github/workflows/licensed.yml@main
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set Node.js 16.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16.x
-      - run: npm ci
-      - name: Install licensed
-        run: |
-          cd $RUNNER_TEMP
-          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/3.4.4/licensed-3.4.4-linux-x64.tar.gz
-          sudo tar -xzf licensed.tar.gz
-          sudo mv licensed /usr/local/bin/licensed
-      - run: licensed status

.github/workflows/microsoft-validation.yml

@@ -0,0 +1,143 @@
+name: Validate Microsoft build of Go
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  microsoft-basic:
+    name: 'Microsoft build of Go ${{ matrix.go-version }} on ${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        go-version: ['1.25', '1.24']
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Microsoft build of Go ${{ matrix.go-version }}
+        uses: ./
+        with:
+          go-version: ${{ matrix.go-version }}
+          go-download-base-url: 'https://aka.ms/golang/release/latest'
+          cache: false
+
+      - name: Verify Go installation
+        run: go version
+
+      - name: Verify Go env
+        run: go env
+
+      - name: Verify Go is functional
+        shell: bash
+        run: |
+          # Create a simple Go program and run it
+          mkdir -p /tmp/test-go && cd /tmp/test-go
+          cat > main.go << 'EOF'
+          package main
+          import "fmt"
+          func main() {
+            fmt.Println("Hello from Microsoft build of Go!")
+          }
+          EOF
+          go run main.go
+
+  microsoft-env-var:
+    name: 'Microsoft build of Go via env var on ${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    env:
+      GO_DOWNLOAD_BASE_URL: 'https://aka.ms/golang/release/latest'
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Microsoft build of Go via environment variable
+        uses: ./
+        with:
+          go-version: '1.25'
+          cache: false
+
+      - name: Verify Go installation
+        run: go version
+
+      - name: Verify Go is functional
+        shell: bash
+        run: |
+          mkdir -p /tmp/test-go && cd /tmp/test-go
+          cat > main.go << 'EOF'
+          package main
+          import "fmt"
+          func main() {
+            fmt.Println("Hello from Microsoft build of Go via env var!")
+          }
+          EOF
+          go run main.go
+
+  microsoft-architecture:
+    name: 'Microsoft build of Go arch ${{ matrix.architecture }} on ${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        architecture: [x64]
+        include:
+          - os: macos-latest
+            architecture: arm64
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Microsoft build of Go with architecture
+        uses: ./
+        with:
+          go-version: '1.25'
+          go-download-base-url: 'https://aka.ms/golang/release/latest'
+          architecture: ${{ matrix.architecture }}
+          cache: false
+
+      - name: Verify Go installation
+        run: go version
+
+  microsoft-with-cache:
+    name: 'Microsoft build of Go with caching on ${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Microsoft build of Go with caching
+        uses: ./
+        with:
+          go-version: '1.25'
+          go-download-base-url: 'https://aka.ms/golang/release/latest'
+          cache: true
+
+      - name: Verify Go installation
+        run: go version
+
+      - name: Verify Go is functional
+        shell: bash
+        run: |
+          mkdir -p /tmp/test-go && cd /tmp/test-go
+          go mod init test
+          cat > main.go << 'EOF'
+          package main
+          import "fmt"
+          func main() {
+            fmt.Println("Hello from cached Microsoft build of Go!")
+          }
+          EOF
+          go run main.go

.github/workflows/publish-immutable-actions.yml

@@ -0,0 +1,20 @@
+name: 'Publish Immutable Action Version'
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+      packages: write
+
+    steps:
+      - name: Checking out
+        uses: actions/checkout@v6
+      - name: Publish
+        id: publish
+        uses: actions/publish-immutable-action@v0.0.4

.github/workflows/release-new-action-version.yml

@@ -1,4 +1,5 @@
 name: Release new action version
+
 on:
   release:
     types: [released]
@@ -21,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Update the ${{ env.TAG_NAME }} tag
-        uses: actions/publish-action@v0.2.1
+        uses: actions/publish-action@v0.4.0
         with:
           source-tag: ${{ env.TAG_NAME }}
           slack-webhook: ${{ secrets.SLACK_WEBHOOK }}

.github/workflows/update-config-files.yml

@@ -0,0 +1,11 @@
+name: Update configuration files
+
+on:
+  schedule:
+    - cron: '0 3 * * 0'
+  workflow_dispatch:
+
+jobs:
+  call-update-configuration-files:
+    name: Update configuration files
+    uses: actions/reusable-workflows/.github/workflows/update-config-files.yml@main

.github/workflows/versions.yml

@@ -1,4 +1,5 @@
 name: Validate 'setup-go'
+
 on:
   push:
     branches:
@@ -17,9 +18,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: Setup Go Stable
         uses: ./
         with:
@@ -32,29 +33,31 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: Setup Go oldStable
         uses: ./
         with:
           go-version: oldstable
       - name: Verify Go
         run: go version
-  
+
   aliases-arch:
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
         version: [stable, oldstable]
         architecture: [x64, x32]
         exclude:
-        - os: macos-latest
+          - os: macos-latest
-          architecture: x32
+            architecture: x32
+          - os: macos-latest-large
+            architecture: x32
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: Setup Go ${{ matrix.version }} ${{ matrix.architecture }}
         uses: ./
         with:
@@ -69,11 +72,17 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest, ubuntu-latest]
+        os: [macos-latest, windows-latest, ubuntu-latest, macos-latest-large]
-        go: [1.17, 1.18, 1.19]
+        go: [1.21.13, 1.22.8, 1.23.2]
+        include:
+          - os: windows-latest
+            go: 1.20.14
+        exclude:
+          - os: windows-latest
+            go: 1.23.2
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
 
       - name: setup-go ${{ matrix.go }}
         uses: ./
@@ -89,10 +98,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
-        go-version: [1.16, 1.17]
+        go-version: ['1.20', '1.21', '1.22', '1.23']
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: Setup Go and check latest
         uses: ./
         with:
@@ -106,15 +115,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: Setup Go and check latest
         uses: ./
         with:
           go-version-file: __tests__/data/go.mod
       - name: verify go
-        run: __tests__/verify-go.sh 1.14
+        run: __tests__/verify-go.sh 1.20.14
         shell: bash
 
   go-version-file-with-gowork:
@@ -122,28 +131,59 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: Setup Go and check latest
         uses: ./
         with:
           go-version-file: __tests__/data/go.work
       - name: verify go
-        run: __tests__/verify-go.sh 1.19
+        run: __tests__/verify-go.sh 1.21
         shell: bash
 
-  setup-versions-from-manifest:
+  go-version-file-with-tool-versions:
-    name: Setup ${{ matrix.go }} ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest, ubuntu-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
-        go: [1.12.16, 1.13.11, 1.14.3]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go and check latest
+        uses: ./
+        with:
+          go-version-file: __tests__/data/.tool-versions
+      - name: verify go
+        run: __tests__/verify-go.sh 1.23.2
+        shell: bash
+
+  go-version-file-with-go-version:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go from .go-version file
+        uses: ./
+        with:
+          go-version-file: __tests__/data/.go-version
+      - name: verify go
+        run: __tests__/verify-go.sh 1.22.4
+        shell: bash
+
+  setup-versions-from-manifest:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, windows-latest, ubuntu-latest, macos-latest-large]
+        go: [1.20.14, 1.21.10, 1.22.8, 1.23.2]
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
 
       - name: setup-go ${{ matrix.go }}
         uses: ./
@@ -155,16 +195,15 @@ jobs:
         shell: bash
 
   setup-versions-from-dist:
-    name: Setup ${{ matrix.go }} ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest, ubuntu-latest]
+        os: [windows-latest, ubuntu-latest, macos-latest-large]
-        go: [1.9, 1.8.6]
+        go: [1.11.12]
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
 
       - name: setup-go ${{ matrix.go }}
         uses: ./
@@ -180,14 +219,23 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
-        go-version: [1.16, 1.17]
+        go-version: [1.20.14, 1.21, 1.22, 1.23]
+        include:
+          - os: macos-latest
+            architecture: arm64
+          - os: ubuntu-latest
+            architecture: x64
+          - os: windows-latest
+            architecture: x64
+          - os: macos-latest-large
+            architecture: x64
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: Setup Go and check latest
         uses: ./
         with:
           go-version: ${{ matrix.go-version }}
-          architecture: x64
+          architecture: ${{ matrix.architecture }}
       - name: Verify Go
         run: go version

.github/workflows/windows-validation.yml

@@ -0,0 +1,136 @@
+name: Validate Windows installation
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  create-link-if-not-default:
+    runs-on: windows-latest
+    name: 'Validate if symlink is created'
+    strategy:
+      matrix:
+        cache: [false, true]
+        go: [1.20.1]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: 'Setup ${{ matrix.cache }}, cache: ${{ matrix.go }}'
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
+          cache: ${{ matrix.cache }}
+
+      - name: 'Drive C: should have zero size link'
+        run: |
+          du -m -s 'C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'
+          # make sure drive c: contains only a link
+          size=$(du -m -s 'C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'|cut -f1 -d$'\t')
+          if [ $size -ne 0 ];then
+            echo 'Size of the link created on drive c: must be 0'
+            exit 1
+          fi
+        shell: bash
+
+      # Drive D: is small, take care the action does not eat up the space
+      - name: 'Drive D: space usage should be below 1G'
+        run: |
+          du -m -s 'D:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'
+          size=$(du -m -s 'D:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'|cut -f1 -d$'\t')
+          # make sure archive does not take lot of space
+          if [ $size -gt 999 ];then
+            echo 'Size of installed on drive d: go is too big';
+            exit 1
+          fi
+        shell: bash
+
+      # make sure the Go installation has not been changed to the end user
+      - name: Test paths and environments
+        run: |
+          echo $PATH
+          which go
+          go version
+          go env
+          if [ $(which go) != '/c/hostedtoolcache/windows/go/${{ matrix.go }}/x64/bin/go' ];then
+            echo 'which go should return "/c/hostedtoolcache/windows/go/${{ matrix.go }}/x64/bin/go"'
+            exit 1
+          fi
+          if [ $(go env GOROOT) != 'C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64' ];then
+            echo 'go env GOROOT should return "C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64"'
+            exit 1
+          fi
+        shell: bash
+
+  find-default-go:
+    name: 'Find default go version'
+    runs-on: windows-latest
+    outputs:
+      version: ${{ steps.goversion.outputs.version }}
+    steps:
+      - run: |
+          version=`go env GOVERSION|sed s/^go//`
+          echo "default go version: $version"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+        id: goversion
+        shell: bash
+
+  dont-create-link-if-default:
+    name: 'Validate if symlink is not created for default go'
+    runs-on: windows-latest
+    needs: find-default-go
+    strategy:
+      matrix:
+        cache: [false, true]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: 'Setup default go, cache: ${{ matrix.cache }}'
+        uses: ./
+        with:
+          go-version: ${{ needs.find-default-go.outputs.version }}
+          cache: ${{ matrix.cache }}
+
+      - name: 'Drive C: should have Go installation, cache: ${{ matrix.cache}}'
+        run: |
+          size=$(du -m -s 'C:\hostedtoolcache\windows\go\${{ needs.find-default-go.outputs.version }}\x64'|cut -f1 -d$'\t')
+          if [ $size -eq 0 ];then
+            echo 'Size of the hosted go installed on drive c: must be above zero'
+            exit 1
+          fi
+        shell: bash
+
+      - name: 'Drive D: should not have Go installation, cache: ${{ matrix.cache }}'
+        run: |
+          if [ -e 'D:\hostedtoolcache\windows\go\${{ needs.find-default-go.outputs.version }}\x64' ];then
+            echo 'D:\hostedtoolcache\windows\go\${{ needs.find-default-go.outputs.version }}\x64 should not exist for hosted version of go';
+            exit 1
+          fi
+        shell: bash
+
+  hostedtoolcache:
+    name: 'Validate if hostedtoolcache works as expected'
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        cache: [false]
+        go: [1.20.1]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: 'Setup ${{ matrix.go }}, cache: ${{ matrix.cache }}'
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
+          cache: ${{ matrix.cache }}
+
+      - name: 'Setup ${{ matrix.go }}, cache: ${{ matrix.cache }} (from hostedtoolcache)'
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
+          cache: ${{ matrix.cache }}

.github/workflows/workflow.yml

@@ -1,39 +0,0 @@
-name: build-test
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - '**.md'
-  pull_request:
-    paths-ignore:
-      - '**.md'
-jobs:
-  run:
-    name: Run
-    runs-on: ${{ matrix.operating-system }}
-    strategy:
-      matrix:
-        operating-system: [ubuntu-latest, windows-latest]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Setup node 16
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          cache: npm
-
-      - name: npm ci
-        run: npm ci
-
-      - name: Lint
-        run: npm run format-check
-
-      - name: npm test
-        run: npm test
-
-      - name: audit packages
-        run: npm audit --audit-level=high
-        if: matrix.operating-system == 'ubuntu-latest'

.licensed.yml

@@ -12,4 +12,5 @@ allowed:
   - 0bsd
 
 reviewed:
-  npm:
+  npm:
+     - "@actions/http-client"

.prettierignore

@@ -0,0 +1,7 @@
+# Ignore list
+/*
+
+# Do not ignore these folders:
+!__tests__/
+!.github/
+!src/

.prettierrc.js

@@ -0,0 +1,11 @@
+// This is a reusable configuration file copied from https://github.com/actions/reusable-workflows/tree/main/reusable-configurations. Please don't make changes to this file as it's the subject of an automatic update.
+module.exports = {
+  printWidth: 80,
+  tabWidth: 2,
+  useTabs: false,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'none',
+  bracketSpacing: false,
+  arrowParens: 'avoid'
+};

.prettierrc.json

@@ -1,11 +0,0 @@
-{
-    "printWidth": 80,
-    "tabWidth": 2,
-    "useTabs": false,
-    "semi": true,
-    "singleQuote": true,
-    "trailingComma": "none",
-    "bracketSpacing": false,
-    "arrowParens": "avoid",
-    "parser": "typescript"
-  }

CODEOWNERS

@@ -1 +1 @@
-* @actions/actions-service
+* @actions/setup-actions-team

README.md

@@ -1,224 +1,148 @@
 # setup-go
 
-[![build-test](https://github.com/actions/setup-go/actions/workflows/workflow.yml/badge.svg)](https://github.com/actions/setup-go/actions/workflows/workflow.yml)
+[![Basic validation](https://github.com/actions/setup-go/actions/workflows/basic-validation.yml/badge.svg)](https://github.com/actions/setup-go/actions/workflows/basic-validation.yml)
 [![Validate 'setup-go'](https://github.com/actions/setup-go/actions/workflows/versions.yml/badge.svg)](https://github.com/actions/setup-go/actions/workflows/versions.yml)
 
-This action sets up a go environment for use in actions by:
+This action sets up a Go environment for use in GitHub Actions by:
 
-- Optionally downloading and caching a version of Go by version and adding to `PATH`.
+- Optionally downloading and caching a version of Go by version and adding it to the PATH
-- Registering problem matchers for error output.
+- Optionally caching Go modules and build outputs
+- Registering problem matchers for error output
 
-# V3
+## Breaking changes in V6
 
-The V3 edition of the action offers:
+The V6 edition of the action includes:
+- **Upgraded Node.js runtime from node20 to node24**
+  > Make sure your runner is on version v2.327.1 or later to ensure compatibility with this release. See [Release Notes](https://github.com/actions/runner/releases/tag/v2.327.1)
 
-- Adds `GOBIN` to the `PATH`
+- **Go toolchain**
-- Proxy support
+  - Supports both `go` and `toolchain` directives in `go.mod`. If the `toolchain` directive is present, its version is used; otherwise, the action falls back to the `go` directive.
-- Check latest version
-- Caching packages dependencies
-- stable and oldstable aliases
-- Bug Fixes (including issues around version matching and semver)
 
-The action will first check the local cache for a version match. If a version is not found locally, it will pull it from the `main` branch of the [go-versions](https://github.com/actions/go-versions/blob/main/versions-manifest.json) repository. On miss or failure, it will fall back to downloading directly from [go dist](https://storage.googleapis.com/golang). To change the default behavior, please use the [check-latest input](#check-latest-version).
+- **Cache key update**
+  - By default, the cache key for Go modules is based on `go.mod`. To use `go.sum`, configure the `cache-dependency-path` input.
 
-**Note:** The `setup-go` action uses executable binaries which are built by Golang side. The action does not build golang from source code.
+See full release notes on the [releases page](https://github.com/actions/setup-go/releases).
 
-Matching by [semver spec](https://github.com/npm/node-semver):
+## Usage
 
+See [action.yml](action.yml).
+
+<!-- start usage -->
 ```yaml
-steps:
+- uses: actions/setup-go@v6
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '^1.13.1' # The Go version to download (if necessary) and use.
-  - run: go version
-```
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '>=1.17.0'
-  - run: go version
-```
-
-Matching an unstable pre-release:
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.18.0-rc.1' # The Go version to download (if necessary) and use.
-  - run: go version
-```
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.16.0-beta.1' # The Go version to download (if necessary) and use.
-  - run: go version
-```
-
-# Usage
-
-See [action.yml](action.yml)
-
-## Basic
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.16.1' # The Go version to download (if necessary) and use.
-  - run: go run hello.go
-```
-
-
-## Check latest version
-
-The `check-latest` flag defaults to `false`. Use the default or set `check-latest` to `false` if you prefer stability and if you want to ensure a specific Go version is always used.
-
-If `check-latest` is set to `true`, the action first checks if the cached version is the latest one. If the locally cached version is not the most up-to-date, a Go version will then be downloaded. Set `check-latest` to `true` if you want the most up-to-date Go version to always be used.
-
-> Setting `check-latest` to `true` has performance implications as downloading Go versions is slower than using cached versions.
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.14'
-      check-latest: true
-  - run: go run hello.go
-```
-
-## Using stable/oldstable aliases
-
-If `stable` is provided, action will get the latest stable version from the [`go-versions`](https://github.com/actions/go-versions/blob/main/versions-manifest.json) repository manifest. 
-
-If `oldstable` is provided, when current release is 1.19.x, action will resolve version as 1.18.x, where x is the latest patch release.
-
-**Note:** using these aliases will result in same version as using corresponding minor release with `check-latest` input set to `true`
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: 'stable'
-  - run: go run hello.go
-```
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: 'oldstable'
-  - run: go run hello.go
-```
-
-## Caching dependency files and build outputs:
-
-The action has a built-in functionality for caching and restoring go modules and build outputs. It uses [actions/cache](https://github.com/actions/cache) under the hood but requires less configuration settings. The `cache` input is optional, and caching is turned off by default.
-
-The action defaults to search for the dependency file - go.sum in the repository root, and uses its hash as a part of the cache key. Use `cache-dependency-path` input for cases when multiple dependency files are used, or they are located in different subdirectories.
-
-**Caching without specifying dependency file path**
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.17'
-      check-latest: true
-      cache: true
-  - run: go run hello.go
-```
-
-**Caching in monorepos**
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.17'
-      check-latest: true
-      cache: true
-      cache-dependency-path: subdir/go.sum
-  - run: go run hello.go
-  ```
-## Getting go version from the go.mod file
-
-The `go-version-file` input accepts a path to a `go.mod` file or a `go.work` file that contains the version of Go to be used by a project. As the `go.mod` file contains only major and minor (e.g. 1.18) tags, the action will search for the latest available patch version sequentially in the runner's directory with the cached tools, in the [version-manifest.json](https://github.com/actions/go-versions/blob/main/versions-manifest.json) file or at the go servers.
-
-If both the `go-version` and the `go-version-file` inputs are provided then the `go-version` input is used.
-> The action will search for the `go.mod` file relative to the repository root
-
-```yaml
-steps:
-- uses: actions/checkout@v3
-- uses: actions/setup-go@v3
   with:
-    go-version-file: 'path/to/go.mod'
+    # Version or version range of Go to use
-- run: go version
+    go-version: '1.23'
+    
+    # Path to go.mod, go.work, .go-version, or .tool-versions file
+    # Note: if both go-version and go-version-file are provided, go-version takes precedence.
+    go-version-file: 'go.mod'
+    
+    # Set this option if you want the action to check for the latest available version
+    # Default: false
+    check-latest: false
+    
+    # GitHub token for authentication
+    token: ${{ github.token }}
+    
+    # Used to specify whether caching is needed.
+    # Default: true
+    cache: true
+    
+    # Path to dependency files for caching
+    cache-dependency-path: 'go.sum'
+    
+    # Architecture to install (auto-detected if not specified)
+    architecture: 'x64'
+    
+    # Custom base URL for Go downloads (e.g., for mirrors)
+    go-download-base-url: ''
 ```
+<!-- end usage -->
 
-## Matrix testing
+**Basic:**
 
 ```yaml
-jobs:
+steps:
-  build:
+  - uses: actions/checkout@v6
-    runs-on: ubuntu-latest
+  - uses: actions/setup-go@v6
-    strategy:
+    with:
-      matrix:
+      go-version: '1.25' # The Go version to download (if necessary) and use.
-        go: [ '1.14', '1.13' ]
+  - run: go run hello.go
-    name: Go ${{ matrix.go }} sample
-    steps:
-      - uses: actions/checkout@v3
-      - name: Setup go
-        uses: actions/setup-go@v3
-        with:
-          go-version: ${{ matrix.go }}
-      - run: go run hello.go
 ```
 
-### Supported version syntax
+**Version resolution behavior:**
+
+The action resolves the requested version in the following order:
+1. **Local cache** - Checks the local tool cache for a matching [semver](https://github.com/npm/node-semver#versions) version.
+2. **go-versions repository** - If the requested version isn’t available in the tool cache, it pulls the version manifest from the `main` branch of the [go-versions repository](https://github.com/actions/go-versions/blob/main/versions-manifest.json).
+3. **Direct download** - If that lookup misses or fails, it will fall back to downloading directly from the [official Go distribution site](https://go.dev/dl).
+
+To change the default behavior, please use
+the [check-latest input](docs/advanced-usage.md#check-latest-version).
+
+> **Note**: The `setup-go` action uses executable binaries built by the Go team and does not build Go binaries from source code.
+
+## Supported version syntax
 
 The `go-version` input supports the following syntax:
 
-- Specific versions: `1.15`, `1.16.1`, `1.17.0-rc.2`, `1.16.0-beta.1`
+- Specific versions: `1.25`, `1.24.11`, `1.24.0-rc.1`, `1.23.0-beta.1`
-- SemVer's version range syntax: `^1.13.1`, `>=1.18.0-rc.1`
+- SemVer version range syntax: `^1.25.1`, `~1.24.1`, `>=1.25.0-rc.1`, `<1.25.0`, `>=1.22.0 <1.24.0`
+- Aliases: `stable`, `oldstable`
+- Wildcards: `1.25.x`, `1.x`
 
-For more information about semantic versioning, please refer to [semver](https://github.com/npm/node-semver) documentation.
+For details on Semantic Versioning, see [the semver package documentation](https://github.com/npm/node-semver).
 
-## Using `setup-go` on GHES
+> **Note**: Due to the peculiarities of YAML parsing, it is recommended to wrap the version in single quotation marks:
+>
+> ```yaml
+>   go-version: '1.20'
+> ```
+>
+> The recommendation is based on the YAML parser's behavior, which interprets non-wrapped values as numbers and, in the case of version `1.20`, trims it down to `1.2`, which may not be very obvious.
 
-`setup-go` comes pre-installed on the appliance with GHES if Actions is enabled. When dynamically downloading Go distributions, `setup-go` downloads distributions from [`actions/go-versions`](https://github.com/actions/go-versions) on github.com (outside of the appliance). These calls to `actions/go-versions` are made via unauthenticated requests, which are limited to [60 requests per hour per IP](https://docs.github.com/en/rest/overview/resources-in-the-rest-api#rate-limiting). If more requests are made within the time frame, then you will start to see rate-limit errors during downloading that looks like: `##[error]API rate limit exceeded for...`. After that error the action will try to download versions directly from https://storage.googleapis.com/golang, but it also can have rate limit so it's better to put token.
+For more usage examples, please refer to the section: [Using go-version input](docs/advanced-usage.md#using-the-go-version-input) of the [Advanced usage](docs/advanced-usage.md) guide.
 
-To get a higher rate limit, you can [generate a personal access token on github.com](https://github.com/settings/tokens/new) and pass it as the `token` input for the action:
+## Recommended permissions
+
+When using the `setup-go` action in your GitHub Actions workflow, it is recommended to set the following permissions to ensure proper functionality:
 
 ```yaml
-uses: actions/setup-go@v3
+permissions:
-with:
+  contents: read # access to check out code and install dependencies
-  token: ${{ secrets.GH_DOTCOM_TOKEN }}
-  go-version: 1.18
 ```
 
-If the runner is not able to access github.com, any Go versions requested during a workflow run must come from the runner's tool cache. See "[Setting up the tool cache on self-hosted runners without internet access](https://docs.github.com/en/enterprise-server@3.2/admin/github-actions/managing-access-to-actions-from-githubcom/setting-up-the-tool-cache-on-self-hosted-runners-without-internet-access)" for more information.
+## Caching dependency files and build outputs
 
-# License
+The action includes built-in caching and restoration for Go modules and build outputs. It uses
+[toolkit/cache](https://github.com/actions/toolkit/tree/main/packages/cache) under the hood, but requires less configuration.
+The `cache` input is optional, and caching is enabled by default. To disable caching, set `cache: false`.
 
-The scripts and documentation in this project are released under the [MIT License](LICENSE)
+By default, the action looks for `go.mod` in the repository root and uses its hash as part of the cache key. Use the `cache-dependency-path` input when you have multiple dependency files, or when they’re located in different subdirectories. This input supports glob patterns.
 
-# Contributions
+If caching cannot be performed for any reason, the action logs a warning and continues workflow execution.
 
-Contributions are welcome! See [Contributor's Guide](docs/contributors.md)
+For examples of using `cache-dependency-path`, see the [Caching](docs/advanced-usage.md#caching) section of the [Advanced usage](docs/advanced-usage.md) guide.
+
+
+## Advanced usage
+
+- [Using the go-version input](docs/advanced-usage.md#using-the-go-version-input)
+- [Using the go-version-file input](docs/advanced-usage.md#using-the-go-version-file-input)
+- [Check latest version](docs/advanced-usage.md#check-latest-version)
+- [Caching](docs/advanced-usage.md#caching)
+- [Outputs](docs/advanced-usage.md#outputs)
+- [Custom download URL](docs/advanced-usage.md#custom-download-url)
+- [Using `setup-go` on GHES](docs/advanced-usage.md#using-setup-go-on-ghes)
+
+## License
+
+The scripts and documentation in this project are released under the [MIT License](LICENSE).
+
+## Contributions
+
+Contributions are welcome! See our [Contributor's Guide](docs/contributors.md).
 
 ## Code of Conduct
 

__tests__/cache-restore.test.ts

@@ -1,99 +1,102 @@
 import * as cache from '@actions/cache';
 import * as core from '@actions/core';
 import * as glob from '@actions/glob';
+import fs from 'fs';
 
 import * as cacheRestore from '../src/cache-restore';
 import * as cacheUtils from '../src/cache-utils';
 import {PackageManagerInfo} from '../src/package-managers';
 
 describe('restoreCache', () => {
-  //Arrange
+  let hashFilesSpy: jest.SpyInstance;
-  let hashFilesSpy = jest.spyOn(glob, 'hashFiles');
+  let getCacheDirectoryPathSpy: jest.SpyInstance;
-  let getCacheDirectoryPathSpy = jest.spyOn(
+  let restoreCacheSpy: jest.SpyInstance;
-    cacheUtils,
+  let infoSpy: jest.SpyInstance;
-    'getCacheDirectoryPath'
+  let setOutputSpy: jest.SpyInstance;
-  );
-  let restoreCacheSpy = jest.spyOn(cache, 'restoreCache');
-  let infoSpy = jest.spyOn(core, 'info');
-  let setOutputSpy = jest.spyOn(core, 'setOutput');
 
   const versionSpec = '1.13.1';
   const packageManager = 'default';
   const cacheDependencyPath = 'path';
 
+  let originalWorkspace: string | undefined;
+
   beforeEach(() => {
+    originalWorkspace = process.env.GITHUB_WORKSPACE;
+    process.env.GITHUB_WORKSPACE = '/test/workspace';
+    //Arrange
+    hashFilesSpy = jest.spyOn(glob, 'hashFiles');
+    getCacheDirectoryPathSpy = jest.spyOn(cacheUtils, 'getCacheDirectoryPath');
+    restoreCacheSpy = jest.spyOn(cache, 'restoreCache');
+    infoSpy = jest.spyOn(core, 'info');
+    setOutputSpy = jest.spyOn(core, 'setOutput');
+
     getCacheDirectoryPathSpy.mockImplementation(
       (PackageManager: PackageManagerInfo) => {
-        return new Promise<string[]>(resolve => {
+        return Promise.resolve([
-          resolve(['cache_directory_path', 'cache_directory_path']);
+          'cache_directory_path',
-        });
+          'cache_directory_path'
+        ]);
       }
     );
   });
 
-  it('should throw if dependency file path is not valid', async () => {
+  afterEach(() => {
-    //Arrange
+    process.env.GITHUB_WORKSPACE = originalWorkspace;
-    hashFilesSpy.mockImplementation((somePath: string) => {
+    jest.restoreAllMocks();
-      return new Promise<string>(resolve => {
+  });
-        resolve('');
-      });
-    });
 
-    //Act + Assert
+  it('should throw if dependency file path is not valid', async () => {
-    expect(async () => {
+    // Arrange
-      await cacheRestore.restoreCache(
+    hashFilesSpy.mockImplementation(() => Promise.resolve(''));
+    // Act + Assert
+    await expect(
+      cacheRestore.restoreCache(
         versionSpec,
         packageManager,
         cacheDependencyPath
-      );
+      )
-    }).rejects.toThrowError(
+    ).rejects.toThrow(
       'Some specified paths were not resolved, unable to cache dependencies.'
     );
   });
 
-  it('should inform if cache hit is not occured', async () => {
+  it('should inform if cache hit is not occurred', async () => {
-    //Arrange
+    // Arrange
-    hashFilesSpy.mockImplementation((somePath: string) => {
+    hashFilesSpy.mockImplementation(() => Promise.resolve('file_hash'));
-      return new Promise<string>(resolve => {
+    restoreCacheSpy.mockImplementation(() => Promise.resolve(''));
-        resolve('file_hash');
+    // Act + Assert
-      });
-    });
-
-    restoreCacheSpy.mockImplementation(() => {
-      return new Promise<string>(resolve => {
-        resolve('');
-      });
-    });
-
-    //Act + Assert
     await cacheRestore.restoreCache(
       versionSpec,
       packageManager,
       cacheDependencyPath
     );
-    expect(infoSpy).toBeCalledWith(`Cache is not found`);
+    expect(infoSpy).toHaveBeenCalledWith('Cache is not found');
   });
 
-  it('should set output if cache hit is occured', async () => {
+  it('should set output if cache hit is occurred', async () => {
-    //Arrange
+    // Arrange
-    hashFilesSpy.mockImplementation((somePath: string) => {
+    hashFilesSpy.mockImplementation(() => Promise.resolve('file_hash'));
-      return new Promise<string>(resolve => {
+    restoreCacheSpy.mockImplementation(() => Promise.resolve('cache_key'));
-        resolve('file_hash');
+    // Act + Assert
-      });
-    });
-
-    restoreCacheSpy.mockImplementation(() => {
-      return new Promise<string>(resolve => {
-        resolve('cache_key');
-      });
-    });
-
-    //Act + Assert
     await cacheRestore.restoreCache(
       versionSpec,
       packageManager,
       cacheDependencyPath
     );
-    expect(setOutputSpy).toBeCalledWith('cache-hit', true);
+    expect(setOutputSpy).toHaveBeenCalledWith('cache-hit', true);
+  });
+
+  it('should throw if dependency file is not found in workspace', async () => {
+    jest.spyOn(fs, 'readdirSync').mockReturnValue(['main.go'] as any);
+
+    await expect(
+      cacheRestore.restoreCache(
+        versionSpec,
+        packageManager
+        // No cacheDependencyPath
+      )
+    ).rejects.toThrow(
+      'Dependencies file is not found in /test/workspace. Supported file pattern: go.mod'
+    );
   });
 });

__tests__/cache-save.test.ts

@@ -0,0 +1,155 @@
+import * as cache from '@actions/cache';
+import * as core from '@actions/core';
+import fs from 'fs';
+
+import {run} from '../src/cache-save';
+import * as cacheUtils from '../src/cache-utils';
+import {State} from '../src/constants';
+
+describe('cache-save', () => {
+  const primaryKey = 'primary-key';
+
+  let primaryKeyValue: string;
+  let matchedKeyValue: string;
+
+  let getBooleanInputSpy: jest.SpyInstance;
+  let getStateSpy: jest.SpyInstance;
+  let infoSpy: jest.SpyInstance;
+  let warningSpy: jest.SpyInstance;
+  let debugSpy: jest.SpyInstance;
+  let setFailedSpy: jest.SpyInstance;
+  let saveCacheSpy: jest.SpyInstance;
+  let getCacheDirectoryPathSpy: jest.SpyInstance;
+  let existsSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    primaryKeyValue = primaryKey;
+    matchedKeyValue = 'matched-key';
+
+    getBooleanInputSpy = jest.spyOn(core, 'getBooleanInput');
+    getBooleanInputSpy.mockReturnValue(true);
+
+    getStateSpy = jest.spyOn(core, 'getState');
+    getStateSpy.mockImplementation((key: string) => {
+      if (key === State.CachePrimaryKey) {
+        return primaryKeyValue;
+      }
+      if (key === State.CacheMatchedKey) {
+        return matchedKeyValue;
+      }
+      return '';
+    });
+
+    infoSpy = jest.spyOn(core, 'info');
+    infoSpy.mockImplementation(() => undefined);
+
+    warningSpy = jest.spyOn(core, 'warning');
+    warningSpy.mockImplementation(() => undefined);
+
+    debugSpy = jest.spyOn(core, 'debug');
+    debugSpy.mockImplementation(() => undefined);
+
+    setFailedSpy = jest.spyOn(core, 'setFailed');
+    setFailedSpy.mockImplementation(() => undefined);
+
+    saveCacheSpy = jest.spyOn(cache, 'saveCache');
+    saveCacheSpy.mockImplementation(() => Promise.resolve(0));
+
+    getCacheDirectoryPathSpy = jest.spyOn(cacheUtils, 'getCacheDirectoryPath');
+    getCacheDirectoryPathSpy.mockImplementation(() =>
+      Promise.resolve(['cache_directory_path', 'cache_directory_path'])
+    );
+
+    existsSpy = jest.spyOn(fs, 'existsSync');
+    existsSpy.mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('does not save cache when the cache input is false', async () => {
+    getBooleanInputSpy.mockReturnValue(false);
+
+    await run();
+
+    expect(saveCacheSpy).not.toHaveBeenCalled();
+    expect(warningSpy).not.toHaveBeenCalled();
+    expect(setFailedSpy).not.toHaveBeenCalled();
+  });
+
+  it('does not save cache when there are no cache folders on the disk', async () => {
+    existsSpy.mockImplementation(() => false);
+
+    await run();
+
+    expect(warningSpy).toHaveBeenCalledWith(
+      'There are no cache folders on the disk'
+    );
+    expect(saveCacheSpy).not.toHaveBeenCalled();
+    expect(setFailedSpy).not.toHaveBeenCalled();
+  });
+
+  it('does not save cache when the primary key was not generated', async () => {
+    primaryKeyValue = '';
+
+    await run();
+
+    expect(infoSpy).toHaveBeenCalledWith(
+      'Primary key was not generated. Please check the log messages above for more errors or information'
+    );
+    expect(saveCacheSpy).not.toHaveBeenCalled();
+    expect(setFailedSpy).not.toHaveBeenCalled();
+  });
+
+  it('does not save cache when a cache hit occurred on the primary key', async () => {
+    matchedKeyValue = primaryKey;
+
+    await run();
+
+    expect(infoSpy).toHaveBeenCalledWith(
+      `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+    );
+    expect(saveCacheSpy).not.toHaveBeenCalled();
+    expect(setFailedSpy).not.toHaveBeenCalled();
+  });
+
+  it('saves cache when the primary key differs from the matched key', async () => {
+    await run();
+
+    expect(saveCacheSpy).toHaveBeenCalled();
+    expect(infoSpy).toHaveBeenCalledWith(
+      `Cache saved with the key: ${primaryKey}`
+    );
+    expect(warningSpy).not.toHaveBeenCalled();
+    expect(setFailedSpy).not.toHaveBeenCalled();
+  });
+
+  it('save with -1 cacheId , should not fail workflow', async () => {
+    saveCacheSpy.mockImplementation(() => Promise.resolve(-1));
+
+    await run();
+
+    expect(saveCacheSpy).toHaveBeenCalled();
+    expect(debugSpy).toHaveBeenCalledWith(
+      `Cache was not saved for the key: ${primaryKey}`
+    );
+    expect(infoSpy).not.toHaveBeenCalledWith(
+      `Cache saved with the key: ${primaryKey}`
+    );
+    expect(warningSpy).not.toHaveBeenCalled();
+    expect(setFailedSpy).not.toHaveBeenCalled();
+  });
+
+  it('saves with error from toolkit, should not fail workflow', async () => {
+    saveCacheSpy.mockImplementation(() =>
+      Promise.reject(new Error('Unable to reach the service'))
+    );
+
+    await run();
+
+    expect(saveCacheSpy).toHaveBeenCalled();
+    expect(warningSpy).toHaveBeenCalledWith('Unable to reach the service');
+    expect(setFailedSpy).not.toHaveBeenCalled();
+  });
+});

__tests__/cache-utils.test.ts

@@ -6,7 +6,7 @@ import {PackageManagerInfo} from '../src/package-managers';
 
 describe('getCommandOutput', () => {
   //Arrange
-  let getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
+  const getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
 
   it('should return trimmed stdout in case of successful exit code', async () => {
     //Arrange
@@ -36,7 +36,7 @@ describe('getCommandOutput', () => {
     });
 
     //Act + Assert
-    expect(async () => {
+    await expect(async () => {
       await cacheUtils.getCommandOutput('command');
     }).rejects.toThrow();
   });
@@ -47,7 +47,7 @@ describe('getPackageManagerInfo', () => {
     //Arrange
     const packageManagerName = 'default';
     const expectedResult = {
-      dependencyFilePattern: 'go.sum',
+      dependencyFilePattern: 'go.mod',
       cacheFolderCommandList: ['go env GOMODCACHE', 'go env GOCACHE']
     };
 
@@ -62,7 +62,7 @@ describe('getPackageManagerInfo', () => {
     const packageManagerName = 'invalidName';
 
     //Act + Assert
-    expect(async () => {
+    await expect(async () => {
       await cacheUtils.getPackageManagerInfo(packageManagerName);
     }).rejects.toThrow();
   });
@@ -70,10 +70,10 @@ describe('getPackageManagerInfo', () => {
 
 describe('getCacheDirectoryPath', () => {
   //Arrange
-  let getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
+  const getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
 
   const validPackageManager: PackageManagerInfo = {
-    dependencyFilePattern: 'go.sum',
+    dependencyFilePattern: 'go.mod',
     cacheFolderCommandList: ['go env GOMODCACHE', 'go env GOCACHE']
   };
 
@@ -93,6 +93,41 @@ describe('getCacheDirectoryPath', () => {
       .then(data => expect(data).toEqual(expectedResult));
   });
 
+  it('should return path to the cache folder if one command return empty str', async () => {
+    //Arrange
+    getExecOutputSpy.mockImplementationOnce((commandLine: string) => {
+      return new Promise<exec.ExecOutput>(resolve => {
+        resolve({exitCode: 0, stdout: 'path/to/cache/folder', stderr: ''});
+      });
+    });
+
+    getExecOutputSpy.mockImplementationOnce((commandLine: string) => {
+      return new Promise<exec.ExecOutput>(resolve => {
+        resolve({exitCode: 0, stdout: '', stderr: ''});
+      });
+    });
+
+    const expectedResult = ['path/to/cache/folder'];
+
+    //Act + Assert
+    return cacheUtils
+      .getCacheDirectoryPath(validPackageManager)
+      .then(data => expect(data).toEqual(expectedResult));
+  });
+
+  it('should throw if the both commands return empty str', async () => {
+    getExecOutputSpy.mockImplementation((commandLine: string) => {
+      return new Promise<exec.ExecOutput>(resolve => {
+        resolve({exitCode: 10, stdout: '', stderr: ''});
+      });
+    });
+
+    //Act + Assert
+    await expect(async () => {
+      await cacheUtils.getCacheDirectoryPath(validPackageManager);
+    }).rejects.toThrow();
+  });
+
   it('should throw if the specified package name is invalid', async () => {
     getExecOutputSpy.mockImplementation((commandLine: string) => {
       return new Promise<exec.ExecOutput>(resolve => {
@@ -101,7 +136,7 @@ describe('getCacheDirectoryPath', () => {
     });
 
     //Act + Assert
-    expect(async () => {
+    await expect(async () => {
       await cacheUtils.getCacheDirectoryPath(validPackageManager);
     }).rejects.toThrow();
   });
@@ -109,8 +144,8 @@ describe('getCacheDirectoryPath', () => {
 
 describe('isCacheFeatureAvailable', () => {
   //Arrange
-  let isFeatureAvailableSpy = jest.spyOn(cache, 'isFeatureAvailable');
+  const isFeatureAvailableSpy = jest.spyOn(cache, 'isFeatureAvailable');
-  let warningSpy = jest.spyOn(core, 'warning');
+  const warningSpy = jest.spyOn(core, 'warning');
 
   it('should return true when cache feature is available', () => {
     //Arrange
@@ -118,16 +153,14 @@ describe('isCacheFeatureAvailable', () => {
       return true;
     });
 
-    let functionResult;
-
     //Act
-    functionResult = cacheUtils.isCacheFeatureAvailable();
+    const functionResult = cacheUtils.isCacheFeatureAvailable();
 
     //Assert
     expect(functionResult).toBeTruthy();
   });
 
-  it('should warn when cache feature is unavailable and GHES is not used ', () => {
+  it('should warn when cache feature is unavailable and GHES is not used', () => {
     //Arrange
     isFeatureAvailableSpy.mockImplementation(() => {
       return false;
@@ -135,7 +168,7 @@ describe('isCacheFeatureAvailable', () => {
 
     process.env['GITHUB_SERVER_URL'] = 'https://github.com';
 
-    let warningMessage =
+    const warningMessage =
       'The runner was not able to contact the cache service. Caching will be skipped';
 
     //Act
@@ -153,16 +186,14 @@ describe('isCacheFeatureAvailable', () => {
 
     process.env['GITHUB_SERVER_URL'] = 'https://github.com';
 
-    let functionResult;
-
     //Act
-    functionResult = cacheUtils.isCacheFeatureAvailable();
+    const functionResult = cacheUtils.isCacheFeatureAvailable();
 
     //Assert
     expect(functionResult).toBeFalsy();
   });
 
-  it('should throw when cache feature is unavailable and GHES is used', () => {
+  it('should warn when cache feature is unavailable and GHES is used', () => {
     //Arrange
     isFeatureAvailableSpy.mockImplementation(() => {
       return false;
@@ -170,10 +201,49 @@ describe('isCacheFeatureAvailable', () => {
 
     process.env['GITHUB_SERVER_URL'] = 'https://nongithub.com';
 
-    let errorMessage =
+    const warningMessage =
       'Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.';
 
     //Act + Assert
-    expect(() => cacheUtils.isCacheFeatureAvailable()).toThrow(errorMessage);
+    expect(cacheUtils.isCacheFeatureAvailable()).toBeFalsy();
+    expect(warningSpy).toHaveBeenCalledWith(warningMessage);
+  });
+});
+
+describe('isGhes', () => {
+  const pristineEnv = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = {...pristineEnv};
+  });
+
+  afterAll(() => {
+    process.env = pristineEnv;
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable is not defined', async () => {
+    delete process.env['GITHUB_SERVER_URL'];
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable is set to github.com', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://github.com';
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable is set to a GitHub Enterprise Cloud-style URL', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://contoso.ghe.com';
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable has a .localhost suffix', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://mock-github.localhost';
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns true when the GITHUB_SERVER_URL environment variable is set to some other URL', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://src.onpremise.fabrikam.com';
+    expect(cacheUtils.isGhes()).toBeTruthy();
   });
 });

__tests__/data/.go-version

@@ -0,0 +1 @@
+1.22.4

__tests__/data/.tool-versions

@@ -0,0 +1 @@
+golang 1.23.2

__tests__/data/go.mod

@@ -1,6 +1,6 @@
 module example.com/mymodule
 
-go 1.14
+go 1.20
 
 require (
 	example.com/othermodule v1.2.3

__tests__/data/go.work

@@ -1,3 +1,3 @@
-go 1.19
+go 1.21
 
 use .