depricate ubuntu-20.04

`v1` - Remove `dotnetcli.blob.core.windows.net` storage account fallback logic and update install scripts

.gitattributes

@@ -0,0 +1 @@
+.licenses/** -diff linguist-generated=true

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @actions/virtual-environments-owners

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,22 +2,31 @@
 name: Bug report
 about: Create a bug report
 title: ''
-labels: ''
+labels: bug, needs triage
 assignees: ''
 
 ---
 
-### Description
+**Description:**
+A clear and concise description of what the bug is.
 
-<!--
-* Please share short description of the problem
-  -->
+**Task version:**
+Specify the task version
 
-### Details
+**Platform:**
+- [ ] Ubuntu
+- [ ] macOS
+- [ ] Windows
 
-<!--
-* Include the relevant yaml, platform, and dotnet versions in use
-* If an error occurred on a public action, please share a link
-* Include any error messages received in text (search does not work for images)
-* Was this a regression from previous behavior?
-  -->
+**Runner type:**
+- [ ] Hosted
+- [ ] Self-hosted
+
+**Repro steps:**  
+A description with steps to reproduce the issue. If your have a public example or repo to share, please provide the link.
+
+**Expected behavior:**
+A description of what you expected to happen.
+
+**Actual behavior:**
+A description of what is actually happening.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: true
+blank_issues_enabled: false
 contact_links:
   - name: .NET issues
     url: https://github.com/dotnet/runtime#filing-issues

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature request, needs triage
+assignees: ''
+---
+
+**Description:**
+Describe your proposal.
+
+**Justification:**
+Justification or a use case for your proposal.
+
+**Are you willing to submit a PR?**
+<!--- We accept contributions! -->

.github/pull_request_template.md

@@ -0,0 +1,9 @@
+**Description:**
+Describe your changes.
+
+**Related issue:**
+Add link to the related issue.
+
+**Check list:**
+- [ ] Mark if documentation changes are required.
+- [ ] Mark if tests were added or updated to cover the changes.

.github/workflows/check-dist.yml

@@ -0,0 +1,51 @@
+# `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:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  workflow_dispatch:
+
+jobs:
+  check-dist:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set Node.js 12.x
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12.x
+
+      - 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@v4
+        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
+        with:
+          name: dist
+          path: dist/

.github/workflows/licensed.yml

@@ -0,0 +1,25 @@
+name: Licensed
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    name: Check licenses
+    steps:
+      - uses: actions/checkout@v2
+      - run: npm ci
+      - name: Install licensed
+        run: |
+          cd $RUNNER_TEMP
+          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/3.3.1/licensed-3.3.1-linux-x64.tar.gz
+          sudo tar -xzf licensed.tar.gz
+          sudo mv licensed /usr/local/bin/licensed
+      - run: licensed status

.github/workflows/publish-immutable-action.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@v4
+      - name: Publish
+        id: publish
+        uses: actions/publish-immutable-action@v0.0.4

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

@@ -0,0 +1,28 @@
+name: Release new action version
+on:
+  release:
+    types: [released]
+  workflow_dispatch:
+    inputs:
+      TAG_NAME:
+        description: 'Tag name that the major tag will point to'
+        required: true
+
+env:
+  TAG_NAME: ${{ github.event.inputs.TAG_NAME || github.event.release.tag_name }}
+permissions:
+  contents: write
+
+jobs:
+  update_tag:
+    name: Update the major tag to include the ${{ github.event.inputs.TAG_NAME || github.event.release.tag_name }} changes
+    environment:
+      name: releaseNewActionVersion
+    runs-on: ubuntu-latest
+    steps:
+    - name: Update the ${{ env.TAG_NAME }} tag
+      id: update-major-tag
+      uses: actions/publish-action@v0.1.0
+      with:
+        source-tag: ${{ env.TAG_NAME }}
+        slack-webhook: ${{ secrets.SLACK_WEBHOOK }}

.github/workflows/test-dotnet.yml

@@ -0,0 +1,37 @@
+name: Validate dotnet
+
+on:
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  push:
+    branches:
+      - main
+      - releases/*
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  setup-version:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-22.04, windows-latest, macOS-latest]
+        dotnet-version: ['2.1', '2.2', '3.0', '3.1', '5.0']
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet ${{ matrix.dotnet-version }}
+        uses: ./
+        with:
+          dotnet-version: ${{ matrix.dotnet-version }}
+      - name: Check installed version
+        shell: pwsh
+        run: |
+          $version = & dotnet --version
+          Write-Host "Installed version: $version"
+          if (-not $version.StartsWith("${{ matrix.dotnet-version }}")) { throw "Unexpected version" }

.github/workflows/workflow.yml

@@ -2,24 +2,29 @@ name: Main workflow
 
 on:
   pull_request:
+    paths-ignore:
+      - '**.md'
   push:
     branches:
-      - master
+      - main
       - releases/*
+    paths-ignore:
+      - '**.md'
 
 jobs:
   build:
     runs-on: ${{ matrix.operating-system }}
     strategy:
+      fail-fast: false
       matrix:
-        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+        operating-system: [ubuntu-22.04, windows-latest, macos-13]
     steps:
     - name: Checkout
       uses: actions/checkout@v2
     - name: Set Node.js 12
       uses: actions/setup-node@v1
       with:
-        version: 12.x
+        node-version: 12.x
     - run: npm ci
     - run: npm run build
     - run: npm run format-check
@@ -27,65 +32,186 @@ jobs:
     - name: Verify no unstaged changes
       if: runner.os != 'windows'
       run: __tests__/verify-no-unstaged-changes.sh
-
-  test:
+  
+  test-setup-multiple-versions:
     runs-on: ${{ matrix.operating-system }}
     strategy:
+      fail-fast: false
       matrix:
-        operating-system: [ubuntu-latest, windows-latest, macOS-latest]
+        operating-system: [ubuntu-22.04, windows-latest, macOS-latest]
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Clear tool cache
-        run: mv "${{ runner.tool_cache }}" "${{ runner.tool_cache }}.old"
-      - name: Setup dotnet 3.0.100
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet 2.2.402 and 3.1.404
         uses: ./
         with:
-          dotnet-version: 3.0.100
+          dotnet-version: |
+             2.2.402
+             3.1.404
+             3.0.x
       - name: Verify dotnet
-        if: runner.os != 'windows'
-        run: __tests__/verify-dotnet.sh 3.0.100
-      - name: Verify dotnet (Windows)
-        if: runner.os == 'windows'
-        run: __tests__/verify-dotnet.ps1 3.0.100
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 2.2.402 3.1.404 '3.0'
+
+  test-setup-full-version:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-22.04, windows-latest, macos-13]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      # Side-by-side install of 2.2 and 3.1 used for the test project
+      - name: Setup dotnet 2.2.402
+        uses: ./
+        with:
+          dotnet-version: 2.2.402
+      - name: Setup dotnet 3.1.201
+        uses: ./
+        with:
+          dotnet-version: 3.1.201
+          # We are including this veriable to force the generation of the nuget config file to verify that it is created in the correct place
+          source-url: https://api.nuget.org/v3/index.json
+        env:
+          NUGET_AUTH_TOKEN: NOTATOKEN
+      - name: Verify nuget config file
+        shell: pwsh
+        run: |
+          if (-Not (Test-Path "../nuget.config")) { throw "nuget file not generated correctly" }
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1.201 2.2.402
+
+  test-setup-without-patch-version:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-22.04, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      # 2.0, 3.0, 5.0 needs to be in single quotes to interpret as a string instead of as an integer
+      - name: Setup dotnet '3.1'
+        uses: ./
+        with:
+          dotnet-version: '3.1'
+      - name: Setup dotnet '2.2'
+        uses: ./
+        with:
+          dotnet-version: '2.2'
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1 2.2
+  
+  test-setup-latest-patch-version:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-22.04, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet 3.1.x
+        uses: ./
+        with:
+          dotnet-version: 3.1.x
+      - name: Setup dotnet 2.2.x
+        uses: ./
+        with:
+          dotnet-version: 2.2.x
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1 2.2
+
+  test-setup-with-wildcard:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      fail-fast: false
+      matrix:
+        operating-system: [ubuntu-22.04, windows-latest, macOS-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Clear toolcache
+        shell: pwsh
+        run: __tests__/clear-toolcache.ps1 ${{ runner.os }}
+      - name: Setup dotnet 3.1.*
+        uses: ./
+        with:
+          dotnet-version: 3.1.*
+      - name: Setup dotnet 2.2.*
+        uses: ./
+        with:
+          dotnet-version: 2.2.*
+      - name: Verify dotnet
+        shell: pwsh
+        run: __tests__/verify-dotnet.ps1 3.1 2.2
 
   test-proxy:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     container:
-      image: mcr.microsoft.com/dotnet/core/runtime-deps:3.0-bionic
+      image: ubuntu:22.04
       options: --dns 127.0.0.1
     services:
       squid-proxy:
-        image: datadog/squid:latest
+        image: ubuntu/squid:latest
         ports:
           - 3128:3128
     env:
       https_proxy: http://squid-proxy:3128
+      http_proxy: http://squid-proxy:3128
+      DOTNET_SYSTEM_GLOBALIZATION_INVARIANT: true
+
     steps:
       - name: Checkout
         uses: actions/checkout@v2
       - name: Clear tool cache
-        run: rm -rf $RUNNER_TOOL_CACHE/*
-      - name: Setup dotnet 3.0.100
+        run: rm -rf "/usr/share/dotnet"
+      - name: Install curl
+        run: |
+          apt update
+          apt -y install curl libssl-dev
+      - name: Setup dotnet 3.1.201
         uses: ./
         with:
-          dotnet-version: 3.0.100
+          dotnet-version: 3.1.201
+          source-url: https://api.nuget.org/v3/index.json
+        env:
+          NUGET_AUTH_TOKEN: NOTATOKEN
       - name: Verify dotnet
-        run: __tests__/verify-dotnet.sh 3.0.100
+        run: __tests__/verify-dotnet.sh 3.1.201
 
   test-bypass-proxy:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     env:
       https_proxy: http://no-such-proxy:3128
-      no_proxy: github.com,dotnetcli.blob.core.windows.net,download.visualstudio.microsoft.com,api.nuget.org
+      no_proxy: github.com,download.visualstudio.microsoft.com,api.nuget.org,builds.dotnet.microsoft.com,ci.dot.net
     steps:
       - name: Checkout
         uses: actions/checkout@v2
       - name: Clear tool cache
-        run: mv "${{ runner.tool_cache }}" "${{ runner.tool_cache }}.old"
-      - name: Setup dotnet 3.0.100
+        run: rm -rf "/usr/share/dotnet"
+      - name: Setup dotnet 3.1.201
         uses: ./
         with:
-          dotnet-version: 3.0.100
+          dotnet-version: 3.1.201
+          source-url: https://api.nuget.org/v3/index.json
+        env:
+          NUGET_AUTH_TOKEN: NOTATOKEN
       - name: Verify dotnet
-        run: __tests__/verify-dotnet.sh 3.0.100
+        run: __tests__/verify-dotnet.sh 3.1.201

.gitignore

@@ -95,4 +95,5 @@ typings/
 # DynamoDB Local files
 .dynamodb/
 
-.vscode/*
+# Ignore .vscode files
+.vscode/

.licensed.yml

@@ -0,0 +1,14 @@
+sources:
+  npm: true
+
+allowed:
+  - apache-2.0
+  - bsd-2-clause
+  - bsd-3-clause
+  - isc
+  - mit
+  - cc0-1.0
+  - unlicense
+
+reviewed:
+  npm:

README.md

@@ -4,12 +4,18 @@
   <a href="https://github.com/actions/setup-dotnet"><img alt="GitHub Actions status" src="https://github.com/actions/setup-dotnet/workflows/Main%20workflow/badge.svg"></a>
 </p>
 
-This action sets up a [dotnet core cli](https://github.com/dotnet/cli) environment for use in actions by:
+This action sets up a [.NET CLI](https://github.com/dotnet/sdk) environment for use in actions by:
 
-- optionally downloading and caching a version of dotnet by SDK version and adding to PATH
+- optionally downloading and caching a version(s) of dotnet by SDK version(s) and adding to PATH
 - registering problem matchers for error output
 - setting up authentication to private package sources like GitHub Packages
 
+Please Note: GitHub hosted runners have some versions of the .NET SDK
+preinstalled. Installed versions are subject to change. Please refer to the
+documentation
+[software installed on github hosted runners](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-software)
+for .NET SDK versions that are currently available.
+
 # Usage
 
 See [action.yml](action.yml)
@@ -17,24 +23,48 @@ See [action.yml](action.yml)
 Basic:
 ```yaml
 steps:
-- uses: actions/checkout@master
+- uses: actions/checkout@v2
 - uses: actions/setup-dotnet@v1
   with:
     dotnet-version: '3.1.x' # SDK Version to use; x will use the latest version of the 3.1 channel
 - run: dotnet build <my project>
 ```
+Multiple versions:
+> Note: In case multiple versions are installed, the latest .NET version will be used by default unless another version is specified in the `global.json` file.
+
+```yml
+steps:
+- uses: actions/checkout@v2
+- name: Setup dotnet
+  uses: actions/setup-dotnet@v1
+  with:
+    dotnet-version: | 
+      3.1.x
+      5.0.x
+- run: dotnet build <my project>
+```
+Preview version:
+```yml
+steps:
+- uses: actions/checkout@v2
+- uses: actions/setup-dotnet@v1
+  with:
+    dotnet-version: '6.0.x'
+    include-prerelease: true
+- run: dotnet build <my project>
+```
 
 Matrix Testing:
 ```yaml
 jobs:
   build:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        dotnet: [ '2.2.103', '3.0', '3.1.x' ]
+        dotnet: [ '2.1.x', '3.1.x', '5.0.x' ]
     name: Dotnet ${{ matrix.dotnet }} sample
     steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v2
       - name: Setup dotnet
         uses: actions/setup-dotnet@v1
         with:
@@ -42,10 +72,30 @@ jobs:
       - run: dotnet build <my project>
 ```
 
+Side by Side Testing:
+```yaml
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Dotnet Side by Side testing sample
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: '2.1.x'
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: '3.1.x'
+      - run: dotnet build <my project>
+      - run: dotnet test <my project>
+```
+
 Authentication for nuget feeds:
 ```yaml
 steps:
-- uses: actions/checkout@master
+- uses: actions/checkout@v2
 # Authenticates packages to push to GPR
 - uses: actions/setup-dotnet@v1
   with:
@@ -56,10 +106,10 @@ steps:
 - run: dotnet build <my project>
 - name: Create the package
   run: dotnet pack --configuration Release <my project>
- - name: Publish the package to GPR
+- name: Publish the package to GPR
   run: dotnet nuget push <my project>/bin/Release/*.nupkg
 
-# Authticates packages to push to Azure Artifacts
+# Authenticates packages to push to Azure Artifacts
 - uses: actions/setup-dotnet@v1
   with:
     source-url: https://pkgs.dev.azure.com/<your-organization>/_packaging/<your-feed-name>/nuget/v3/index.json
@@ -67,27 +117,37 @@ steps:
     NUGET_AUTH_TOKEN: ${{secrets.AZURE_DEVOPS_PAT}} # Note, create a secret with this name in Settings
 - name: Publish the package to Azure Artifacts
   run: dotnet nuget push <my project>/bin/Release/*.nupkg
+
+# Authenticates packages to push to nuget.org.
+# It's only the way to push a package to nuget.org feed for macOS/Linux machines due to API key config store limitations.
+- uses: actions/setup-dotnet@v1
+  with:
+    dotnet-version: 3.1.x
+- name: Publish the package to nuget.org
+  run: dotnet nuget push */bin/Release/*.nupkg -k $NUGET_AUTH_TOKEN -s https://api.nuget.org/v3/index.json
+  env:
+    NUGET_AUTH_TOKEN: ${{ secrets.NUGET_TOKEN }}
 ```
 
 ## Environment Variables to use with dotnet
 
-Some environment variables may be necessary for your particular case or to improve logging. Some examples are listed below, but the full list with complete details can be found here: https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet#environment-variables
+Some environment variables may be necessary for your particular case or to improve logging. Some examples are listed below, but the full list with complete details can be found here: https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-environment-variables
 
 - DOTNET_NOLOGO - removes logo and telemetry message from first run of dotnet cli (default: false)
 - DOTNET_CLI_TELEMETRY_OPTOUT - opt-out of telemetry being sent to Microsoft (default: false)
 - DOTNET_MULTILEVEL_LOOKUP - configures whether the global install location is used as a fall-back (default: true)
 
 Example usage:
-```
+```yaml
 build:
   runs-on: ubuntu-latest
   env:
     DOTNET_NOLOGO: true
   steps:
-    - uses: actions/checkout@master
+    - uses: actions/checkout@main
     - uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: '3.1.100' # SDK Version to use.
+        dotnet-version: '3.1.x' # SDK Version to use.
 ```
 
 # License

__tests__/authutil.test.ts

@@ -75,14 +75,17 @@ const azureartifactsnugetorgNuGetConfig: string = `<?xml version="1.0" encoding=
 const nugetConfigFile = path.join(fakeSourcesDirForTesting, '../nuget.config');
 
 process.env['GITHUB_REPOSITORY'] = 'OwnerName/repo';
-process.env['RUNNER_TEMP'] = fakeSourcesDirForTesting;
 import * as auth from '../src/authutil';
 
 describe('authutil tests', () => {
   beforeEach(async () => {
     await io.rmRF(fakeSourcesDirForTesting);
     await io.mkdirP(fakeSourcesDirForTesting);
-  }, 100000);
+  }, 30000);
+
+  afterAll(async () => {
+    await io.rmRF(fakeSourcesDirForTesting);
+  }, 30000);
 
   beforeEach(() => {
     if (fs.existsSync(nugetConfigFile)) {
@@ -95,7 +98,9 @@ describe('authutil tests', () => {
   it('No existing config, sets up a full NuGet.config with URL and user/PAT for GPR', async () => {
     process.env['NUGET_AUTH_TOKEN'] = 'TEST_FAKE_AUTH_TOKEN';
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -107,7 +112,9 @@ describe('authutil tests', () => {
     let thrown = false;
     try {
       await auth.configAuthentication(
-        'https://nuget.pkg.github.com/OwnerName/index.json'
+        'https://nuget.pkg.github.com/OwnerName/index.json',
+        '',
+        fakeSourcesDirForTesting
       );
     } catch {
       thrown = true;
@@ -119,7 +126,9 @@ describe('authutil tests', () => {
     process.env['NUGET_AUTH_TOKEN'] = 'TEST_FAKE_AUTH_TOKEN';
     process.env['INPUT_OWNER'] = 'otherorg';
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/otherorg/index.json'
+      'https://nuget.pkg.github.com/otherorg/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -137,7 +146,9 @@ describe('authutil tests', () => {
     let thrown = false;
     try {
       await auth.configAuthentication(
-        'https://nuget.pkg.github.com/OwnerName/index.json'
+        'https://nuget.pkg.github.com/OwnerName/index.json',
+        '',
+        fakeSourcesDirForTesting
       );
     } catch {
       thrown = true;
@@ -153,7 +164,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, emptyNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -169,7 +182,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, nugetorgNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -185,7 +200,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, gprNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -201,7 +218,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, gprnugetorgNuGetConfig);
     await auth.configAuthentication(
-      'https://nuget.pkg.github.com/OwnerName/index.json'
+      'https://nuget.pkg.github.com/OwnerName/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -216,7 +235,11 @@ describe('authutil tests', () => {
       'nuget.config'
     );
     fs.writeFileSync(inputNuGetConfigPath, twogprNuGetConfig);
-    await auth.configAuthentication('https://nuget.pkg.github.com');
+    await auth.configAuthentication(
+      'https://nuget.pkg.github.com',
+      '',
+      fakeSourcesDirForTesting
+    );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
       fs.readFileSync(nugetConfigFile, {encoding: 'utf8'})
@@ -233,7 +256,9 @@ describe('authutil tests', () => {
     let thrown = false;
     try {
       await auth.configAuthentication(
-        'https://nuget.pkg.github.com/OwnerName/index.json'
+        'https://nuget.pkg.github.com/OwnerName/index.json',
+        '',
+        fakeSourcesDirForTesting
       );
     } catch {
       thrown = true;
@@ -255,7 +280,8 @@ describe('authutil tests', () => {
     fs.writeFileSync(inputNuGetConfigPath, gprNuGetConfig);
     await auth.configAuthentication(
       'https://nuget.pkg.github.com/OwnerName/index.json',
-      'subfolder/nuget.config'
+      'subfolder/nuget.config',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -271,7 +297,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, azureartifactsNuGetConfig);
     await auth.configAuthentication(
-      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json'
+      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -287,7 +315,9 @@ describe('authutil tests', () => {
     );
     fs.writeFileSync(inputNuGetConfigPath, azureartifactsnugetorgNuGetConfig);
     await auth.configAuthentication(
-      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json'
+      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(
@@ -298,7 +328,9 @@ describe('authutil tests', () => {
   it('No existing config, sets up a full NuGet.config with URL and token for other source', async () => {
     process.env['NUGET_AUTH_TOKEN'] = 'TEST_FAKE_AUTH_TOKEN';
     await auth.configAuthentication(
-      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json'
+      'https://pkgs.dev.azure.com/amullans/_packaging/GitHubBuilds/nuget/v3/index.json',
+      '',
+      fakeSourcesDirForTesting
     );
     expect(fs.existsSync(nugetConfigFile)).toBe(true);
     expect(

__tests__/clear-toolcache.ps1

@@ -0,0 +1,13 @@
+$dotnetPaths = @{
+    Linux = "/usr/share/dotnet"
+    macOS = "$env:HOME/.dotnet"
+    Windows = "$env:ProgramFiles\dotnet", "$env:LocalAppData\Microsoft\dotnet"
+}
+
+foreach ($srcPath in $dotnetPaths[$args[0]]) {
+    if (Test-Path $srcPath) {
+        Write-Host "Move $srcPath path"
+        $dstPath = Join-Path ([IO.Path]::GetTempPath()) ([IO.Path]::GetRandomFileName())
+        Move-Item -Path $srcPath -Destination $dstPath
+    }
+}

__tests__/installer.test.ts

@@ -4,75 +4,21 @@ import os = require('os');
 import path = require('path');
 import hc = require('@actions/http-client');
 
-import each from 'jest-each';
-
 const toolDir = path.join(__dirname, 'runner', 'tools');
 const tempDir = path.join(__dirname, 'runner', 'temp');
 
 process.env['RUNNER_TOOL_CACHE'] = toolDir;
 process.env['RUNNER_TEMP'] = tempDir;
-import * as setup from '../src/setup-dotnet';
 import * as installer from '../src/installer';
 
 const IS_WINDOWS = process.platform === 'win32';
 
-describe('version tests', () => {
-  each(['3.1.999', '3.1.101-preview.3']).test(
-    "Exact version '%s' should be the same",
-    vers => {
-      let versInfo = new installer.DotNetVersionInfo(vers);
-
-      expect(versInfo.isExactVersion()).toBe(true);
-      expect(versInfo.version()).toBe(vers);
-    }
-  );
-
-  each([['3.1.x', '3.1'], ['1.1.*', '1.1'], ['2.0', '2.0']]).test(
-    "Generic version '%s' should be '%s'",
-    (vers, resVers) => {
-      let versInfo = new installer.DotNetVersionInfo(vers);
-
-      expect(versInfo.isExactVersion()).toBe(false);
-      expect(versInfo.version()).toBe(resVers);
-    }
-  );
-
-  each([
-    '',
-    '.',
-    '..',
-    ' . ',
-    '. ',
-    ' .',
-    ' . . ',
-    ' .. ',
-    ' .  ',
-    '-1.-1',
-    '-1',
-    '-1.-1.-1',
-    '..3',
-    '1..3',
-    '1..',
-    '.2.3',
-    '.2.x',
-    '1',
-    '2.x',
-    '*.*.1',
-    '*.1',
-    '*.',
-    '1.2.',
-    '1.2.-abc',
-    'a.b',
-    'a.b.c',
-    'a.b.c-preview',
-    ' 0 . 1 . 2 '
-  ]).test("Malformed version '%s' should throw", vers => {
-    expect(() => new installer.DotNetVersionInfo(vers)).toThrow();
-  });
-});
-
 describe('installer tests', () => {
   beforeAll(async () => {
+    process.env.RUNNER_TOOL_CACHE = toolDir;
+    process.env.DOTNET_INSTALL_DIR = toolDir;
+    process.env.RUNNER_TEMP = tempDir;
+    process.env.DOTNET_ROOT = '';
     await io.rmRF(toolDir);
     await io.rmRF(tempDir);
   });
@@ -84,83 +30,61 @@ describe('installer tests', () => {
     } catch {
       console.log('Failed to remove test directories');
     }
-  }, 100000);
+  }, 30000);
 
-  it('Resolving a normal generic version works', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller('3.1.x');
-    let versInfo = await dotnetInstaller.resolveInfos(
-      ['win-x64'],
-      new installer.DotNetVersionInfo('3.1.x')
-    );
+  it('Aquires multiple versions of dotnet', async () => {
+    const versions = ['2.2.207', '3.1.120'];
 
-    expect(versInfo.resolvedVersion.startsWith('3.1.'));
-  }, 100000);
-
-  it('Resolving a nonexistent generic version fails', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller('999.1.x');
-    try {
-      await dotnetInstaller.resolveInfos(
-        ['win-x64'],
-        new installer.DotNetVersionInfo('999.1.x')
-      );
-      fail();
-    } catch {
-      expect(true);
+    for (const version of versions) {
+      await getDotnet(version);
     }
-  }, 100000);
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '2.2.207'))).toBe(true);
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '3.1.120'))).toBe(true);
 
-  it('Resolving a exact stable version works', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller('3.1.201');
-    let versInfo = await dotnetInstaller.resolveInfos(
-      ['win-x64'],
-      new installer.DotNetVersionInfo('3.1.201')
-    );
+    if (IS_WINDOWS) {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
+    } else {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
+    }
 
-    expect(versInfo.resolvedVersion).toBe('3.1.201');
-  }, 100000);
-
-  it('Resolving a exact preview version works', async () => {
-    const dotnetInstaller = new installer.DotnetCoreInstaller(
-      '5.0.0-preview.4'
-    );
-    let versInfo = await dotnetInstaller.resolveInfos(
-      ['win-x64'],
-      new installer.DotNetVersionInfo('5.0.0-preview.4')
-    );
-
-    expect(versInfo.resolvedVersion).toBe('5.0.0-preview.4');
-  }, 100000);
+    expect(process.env.DOTNET_ROOT).toBeDefined;
+    expect(process.env.PATH).toBeDefined;
+    expect(process.env.DOTNET_ROOT).toBe(toolDir);
+    expect(process.env.PATH?.startsWith(toolDir)).toBe(true);
+  }, 600000);
 
   it('Acquires version of dotnet if no matching version is installed', async () => {
-    await getDotnet('2.2.205');
-    const dotnetDir = path.join(toolDir, 'dncs', '2.2.205', os.arch());
-
-    expect(fs.existsSync(`${dotnetDir}.complete`)).toBe(true);
+    await getDotnet('3.1.201');
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '3.1.201'))).toBe(true);
     if (IS_WINDOWS) {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet.exe'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
     } else {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
     }
-  }, 400000); //This needs some time to download on "slower" internet connections
 
-  it('Acquires version of dotnet if no matching version is installed', async () => {
-    const dotnetDir = path.join(toolDir, 'dncs', '2.2.105', os.arch());
+    expect(process.env.DOTNET_ROOT).toBeDefined;
+    expect(process.env.PATH).toBeDefined;
+    expect(process.env.DOTNET_ROOT).toBe(toolDir);
+    expect(process.env.PATH?.startsWith(toolDir)).toBe(true);
+  }, 600000); //This needs some time to download on "slower" internet connections
 
-    const globalJsonPath = path.join(process.cwd(), 'global.json');
-    const jsonContents = `{${os.EOL}"sdk": {${os.EOL}"version": "2.2.105"${os.EOL}}${os.EOL}}`;
-    if (!fs.existsSync(globalJsonPath)) {
-      fs.writeFileSync(globalJsonPath, jsonContents);
-    }
-    await setup.run();
-
-    expect(fs.existsSync(`${dotnetDir}.complete`)).toBe(true);
+  it('Acquires generic version of dotnet if no matching version is installed', async () => {
+    await getDotnet('3.1');
+    var directory = fs
+      .readdirSync(path.join(toolDir, 'sdk'))
+      .filter(fn => fn.startsWith('3.1.'));
+    expect(directory.length > 0).toBe(true);
     if (IS_WINDOWS) {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet.exe'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
     } else {
-      expect(fs.existsSync(path.join(dotnetDir, 'dotnet'))).toBe(true);
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
     }
-    fs.unlinkSync(globalJsonPath);
-  }, 100000);
+
+    expect(process.env.DOTNET_ROOT).toBeDefined;
+    expect(process.env.PATH).toBeDefined;
+    expect(process.env.DOTNET_ROOT).toBe(toolDir);
+    expect(process.env.PATH?.startsWith(toolDir)).toBe(true);
+  }, 600000); //This needs some time to download on "slower" internet connections
 
   it('Throws if no location contains correct dotnet version', async () => {
     let thrown = false;
@@ -170,30 +94,7 @@ describe('installer tests', () => {
       thrown = true;
     }
     expect(thrown).toBe(true);
-  }, 100000);
-
-  it('Uses version of dotnet installed in cache', async () => {
-    const dotnetDir: string = path.join(toolDir, 'dncs', '250.0.0', os.arch());
-    await io.mkdirP(dotnetDir);
-    fs.writeFileSync(`${dotnetDir}.complete`, 'hello');
-    // This will throw if it doesn't find it in the cache (because no such version exists)
-    await getDotnet('250.0.0');
-    return;
-  });
-
-  it('Doesnt use version of dotnet that was only partially installed in cache', async () => {
-    const dotnetDir: string = path.join(toolDir, 'dncs', '251.0.0', os.arch());
-    await io.mkdirP(dotnetDir);
-    let thrown = false;
-    try {
-      // This will throw if it doesn't find it in the cache (because no such version exists)
-      await getDotnet('251.0.0');
-    } catch {
-      thrown = true;
-    }
-    expect(thrown).toBe(true);
-    return;
-  });
+  }, 30000);
 
   it('Uses an up to date bash download script', async () => {
     const httpCallbackClient = new hc.HttpClient('setup-dotnet-test', [], {
@@ -213,7 +114,7 @@ describe('installer tests', () => {
     expect(normalizeFileContents(currentContents)).toBe(
       normalizeFileContents(upToDateContents)
     );
-  }, 100000);
+  }, 30000);
 
   it('Uses an up to date powershell download script', async () => {
     var httpCallbackClient = new hc.HttpClient('setup-dotnet-test', [], {
@@ -233,7 +134,7 @@ describe('installer tests', () => {
     expect(normalizeFileContents(currentContents)).toBe(
       normalizeFileContents(upToDateContents)
     );
-  }, 100000);
+  }, 30000);
 });
 
 function normalizeFileContents(contents: string): string {
@@ -246,4 +147,5 @@ function normalizeFileContents(contents: string): string {
 async function getDotnet(version: string): Promise<void> {
   const dotnetInstaller = new installer.DotnetCoreInstaller(version);
   await dotnetInstaller.installDotnet();
+  installer.DotnetCoreInstaller.addToPath();
 }

__tests__/sample-csproj/Program.cs

@@ -1,14 +1,15 @@
-using System;
-using Newtonsoft.Json;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
 
 namespace sample_csproj
 {
-    class Program
+    [TestClass]
+    public class Program
     {
-        static void Main(string[] args)
+        [TestMethod]
+        public void TestMethod1()
         {
-            var json = JsonConvert.SerializeObject(new[] {"Hello", "World!" });
-            Console.WriteLine(json);
+            Console.WriteLine("Hello, World!");
         }
     }
 }

__tests__/sample-csproj/runtimeconfig.template.json

@@ -1,7 +0,0 @@
-{
-  "runtimeOptions": {
-    "configProperties": {
-      "System.Globalization.Invariant": true
-    }
-  }
-}

__tests__/sample-csproj/sample.csproj

@@ -1,13 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.0</TargetFramework>
+    <TargetFrameworks>netcoreapp3.1;netcoreapp3.0;netcoreapp2.2</TargetFrameworks>
     <RootNamespace>sample_csproj</RootNamespace>
+
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <!-- These packages will be downloaded over the network for testing proxy settings -->
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.1.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.1.0" />
+    <PackageReference Include="coverlet.collector" Version="1.2.0" />
   </ItemGroup>
 
 </Project>

__tests__/setup-dotnet.test.ts

@@ -0,0 +1,70 @@
+import io = require('@actions/io');
+import fs = require('fs');
+import os = require('os');
+import path = require('path');
+
+const toolDir = path.join(__dirname, 'runner', 'tools2');
+const tempDir = path.join(__dirname, 'runner', 'temp2');
+
+import * as setup from '../src/setup-dotnet';
+import * as dotnetInstaller from '../src/installer';
+
+const IS_WINDOWS = process.platform === 'win32';
+
+describe('setup-dotnet tests', () => {
+  beforeAll(async () => {
+    process.env.RUNNER_TOOL_CACHE = toolDir;
+    process.env.DOTNET_INSTALL_DIR = toolDir;
+    process.env.RUNNER_TEMP = tempDir;
+    await io.rmRF(toolDir);
+    await io.rmRF(tempDir);
+  });
+
+  afterEach(async () => {
+    try {
+      await io.rmRF(path.join(process.cwd(), 'global.json'));
+      await io.rmRF(toolDir);
+      await io.rmRF(tempDir);
+    } catch {
+      console.log('Failed to remove test directories');
+    }
+  }, 30000);
+
+  it('Acquires version of dotnet from global.json if no matching version is installed', async () => {
+    const globalJsonPath = path.join(process.cwd(), 'global.json');
+    const jsonContents = `{${os.EOL}"sdk": {${os.EOL}"version": "3.1.201"${os.EOL}}${os.EOL}}`;
+    if (!fs.existsSync(globalJsonPath)) {
+      fs.writeFileSync(globalJsonPath, jsonContents);
+    }
+    await setup.run();
+
+    expect(fs.existsSync(path.join(toolDir, 'sdk', '3.1.201'))).toBe(true);
+    if (IS_WINDOWS) {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
+    } else {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
+    }
+  }, 400000);
+
+  it('Acquires version of dotnet from global.json with rollForward option, install the latest patch', async () => {
+    const globalJsonPath = path.join(process.cwd(), 'global.json');
+    const jsonContents = `{${os.EOL}"sdk": {${os.EOL}"version":"3.1.201",${os.EOL}"rollForward":"latestFeature"${os.EOL}}${os.EOL}}`;
+    if (!fs.existsSync(globalJsonPath)) {
+      fs.writeFileSync(globalJsonPath, jsonContents);
+    }
+
+    const version = '3.1';
+    const installer = new dotnetInstaller.DotnetCoreInstaller(version);
+    const patchVersion = await installer.resolveVersion(
+      new dotnetInstaller.DotNetVersionInfo(version)
+    );
+    await setup.run();
+
+    expect(fs.existsSync(path.join(toolDir, 'sdk', patchVersion))).toBe(true);
+    if (IS_WINDOWS) {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet.exe'))).toBe(true);
+    } else {
+      expect(fs.existsSync(path.join(toolDir, 'dotnet'))).toBe(true);
+    }
+  }, 400000);
+});

__tests__/verify-dotnet.ps1

@@ -6,15 +6,38 @@ if (!$args[0])
 $dotnet = Get-Command dotnet | Select-Object -First 1 | ForEach-Object { $_.Path }
 Write-Host "Found '$dotnet'"
 
-$version = & $dotnet --version | Out-String | ForEach-Object { $_.Trim() }
-Write-Host "Version $version"
-# if ($version -ne $args[0])
-# {
-#   Write-Host "PATH='$env:path'"
-#   Write-Host "gcm dotnet:"
-#   gcm dotnet | fl
-#   throw "Unexpected version"
-# }
+if($args.count -eq 1)
+{
+  $version = & $dotnet --version | Out-String | ForEach-Object { $_.Trim() }
+  Write-Host "Version $version"
+  if (-not ($version.StartsWith($args[0].ToString())))
+  {
+    Write-Host "PATH='$env:PATH'"
+    throw "Unexpected version"
+  }
+}
+
+if ($args[1])
+{
+  # SDKs are listed on multiple lines with the path afterwards in square brackets
+  $versions = & $dotnet --list-sdks | ForEach-Object { $_.SubString(0, $_.IndexOf('[')).Trim() }
+  Write-Host "Installed versions: $versions"
+  $InstalledVersionCount = 0
+  foreach($arg in $args){
+    foreach ($version in $versions)
+    {
+      if ($version.StartsWith($arg.ToString())) 
+      {
+        $InstalledVersionCount++
+      }
+    }
+   }
+  if ( $InstalledVersionCount -ne $args.Count)
+  {
+    Write-Host "PATH='$env:PATH'"
+    throw "Unexpected version"
+  }
+}
 
 Write-Host "Building sample csproj"
 & $dotnet build __tests__/sample-csproj/ --no-cache
@@ -24,9 +47,27 @@ if ($LASTEXITCODE -ne 0)
 }
 
 Write-Host "Testing compiled app"
-$sample_output = "$(__tests__/sample-csproj/bin/Debug/netcoreapp3.0/sample.exe)".Trim()
+$sample_output = "$(dotnet test __tests__/sample-csproj/ --no-build)"
 Write-Host "Sample output: $sample_output"
-if ($sample_output -notlike "*Hello*World*")
+# For Side-by-Side installs we want to run the tests twice, for a single install the tests will run once
+if ($args[1])
 {
-  throw "Unexpected output"
+  if ($sample_output -notlike "*Test Run Successful.*Test Run Successful.*")
+  {
+    throw "Unexpected output"
+  }
+}
+if ($args[2])
+{
+  if ($sample_output -notlike "*Test Run Successful.*Test Run Successful.*Test Run Successful.*")
+  {
+    throw "Unexpected output"
+  }
+}
+else
+{
+  if ($sample_output -notlike "*Test Run Successful.*")
+  {
+    throw "Unexpected output"
+  }
 }

__tests__/verify-dotnet.sh

@@ -3,6 +3,11 @@ if [ -z "$1" ]; then
   exit 1
 fi
 
+if [ ! -f "../nuget.config" ]; then
+  echo "nuget file not generated correctly"
+  exit 1
+fi
+
 dotnet_version="$(dotnet --version)"
 echo "Found dotnet version '$dotnet_version'"
 if [ -z "$(echo $dotnet_version | grep $1)" ]; then
@@ -10,13 +15,30 @@ if [ -z "$(echo $dotnet_version | grep $1)" ]; then
   exit 1
 fi
 
+if [ -n "$2" ]; then
+  dotnet_version="$(dotnet --list-sdks)"
+  echo "Found dotnet version '$dotnet_version'"
+  if [ -z "$(echo $dotnet_version | grep $2)" ]; then
+    echo "Unexpected version"
+    exit 1
+  fi
+fi
+
 echo "Building sample csproj"
 dotnet build __tests__/sample-csproj/ --no-cache || exit 1
 
 echo "Testing compiled app"
-sample_output="$(__tests__/sample-csproj/bin/Debug/netcoreapp3.0/sample)"
+sample_output=$(dotnet test __tests__/sample-csproj/ --no-build)
 echo "Sample output: $sample_output"
-if [ -z "$(echo $sample_output | grep Hello)" ]; then
-  echo "Unexpected output"
-  exit 1
+# For Side-by-Side installs we want to run the tests twice, for a single install the tests will run once
+if [ -n "$2" ]; then
+  if [ -z "$(echo $sample_output | grep "Test Run Successful.*Test Run Successful.")" ]; then
+    echo "Unexpected output"
+    exit 1
+  fi
+else
+  if [ -z "$(echo $sample_output | grep "Test Run Successful.")" ]; then
+    echo "Unexpected output"
+    exit 1
+  fi
 fi

__tests__/versionutil.test.ts

@@ -0,0 +1,91 @@
+import each from 'jest-each';
+import * as installer from '../src/installer';
+
+describe('version tests', () => {
+  each(['3.1.999', '3.1.101-preview.3']).test(
+    "Exact version '%s' should be the same",
+    vers => {
+      let versInfo = new installer.DotNetVersionInfo(vers);
+
+      expect(versInfo.isExactVersion()).toBe(true);
+      expect(versInfo.version()).toBe(vers);
+    }
+  );
+
+  each([
+    ['3.x', '3.x'],
+    ['3.*', '3.*'],
+    ['3.1.x', '3.1'],
+    ['1.1.*', '1.1'],
+    ['2.0', '2.0']
+  ]).test("Generic version '%s' should be '%s'", (vers, resVers) => {
+    let versInfo = new installer.DotNetVersionInfo(vers);
+
+    expect(versInfo.isExactVersion()).toBe(false);
+    expect(versInfo.version()).toBe(resVers);
+  });
+
+  each([
+    '',
+    '.',
+    '..',
+    ' . ',
+    '. ',
+    ' .',
+    ' . . ',
+    ' .. ',
+    ' .  ',
+    '-1.-1',
+    '-1',
+    '-1.-1.-1',
+    '..3',
+    '1..3',
+    '1..',
+    '.2.3',
+    '.2.x',
+    '1',
+    '*.*.1',
+    '*.1',
+    '*.',
+    '1.2.',
+    '1.2.-abc',
+    'a.b',
+    'a.b.c',
+    'a.b.c-preview',
+    ' 0 . 1 . 2 '
+  ]).test("Malformed version '%s' should throw", vers => {
+    expect(() => new installer.DotNetVersionInfo(vers)).toThrow();
+  });
+
+  each([
+    ['3.1.x', '3.1.'],
+    ['3.1.*', '3.1.'],
+    ['3.1', '3.1.'],
+    ['5.0.0-preview.6', '5.0.0-preview.6'],
+    ['3.1.201', '3.1.201']
+  ]).test(
+    "Resolving version '%s' as '%s'",
+    async (input, expectedVersion) => {
+      const dotnetInstaller = new installer.DotnetCoreInstaller(input);
+      let versInfo = await dotnetInstaller.resolveVersion(
+        new installer.DotNetVersionInfo(input)
+      );
+      console.log(versInfo);
+
+      expect(versInfo.startsWith(expectedVersion));
+    },
+    100000
+  );
+
+  it('Resolving a nonexistent generic version fails', async () => {
+    const dotnetInstaller = new installer.DotnetCoreInstaller('999.1.x');
+    try {
+      await dotnetInstaller.resolveVersion(
+        new installer.DotNetVersionInfo('999.1.x')
+      );
+      fail();
+    } catch {
+      expect(true);
+    }
+  }, 100000);
+});

action.yml

@@ -1,22 +1,21 @@
 name: 'Setup .NET Core SDK'
-description: 'Set up a specific version of the .NET Core CLI in the PATH and set up authentication to a private NuGet repository'
+description: 'Used to build and publish .NET source. Set up a specific version of the .NET and authentication to private NuGet repository'
 author: 'GitHub'
 branding:
   icon: play
   color: green
-inputs: 
+inputs:
   dotnet-version:
-    description: 'SDK version to use. Examples: 2.2.104, 3.1, 3.1.x'
+    description: 'Optional SDK version(s) to use. If not provided, will install global.json version when available. Examples: 2.2.104, 3.1, 3.1.x'
   source-url:
     description: 'Optional package source for which to set up authentication. Will consult any existing NuGet.config in the root of the repo and provide a temporary NuGet.config using the NUGET_AUTH_TOKEN environment variable as a ClearTextPassword'
   owner:
     description: 'Optional OWNER for using packages from GitHub Package Registry organizations/users other than the current repository''s owner. Only used if a GPR URL is also provided in source-url'
   config-file:
     description: 'Optional NuGet.config location, if your NuGet.config isn''t located in the root of the repo.'
-  # Deprecated option, do not use. Will not be supported after October 1, 2019
-  version:
-    description: 'Deprecated. Use dotnet-version instead. Will not be supported after October 1, 2019'
-    deprecationMessage: 'The version property will not be supported after October 1, 2019. Use dotnet-version instead'
+  include-prerelease:
+    description: 'Whether prerelease versions should be matched with non-exact versions (for example 5.0.0-preview.6 being matched by 5, 5.0, 5.x or 5.0.x). Defaults to false if not provided.'
+    required: False
 runs:
   using: 'node12'
   main: 'dist/index.js'

docs/contributors.md

@@ -1,17 +1,34 @@
 # Contributors
 
+Thank you for contributing! This action is targetted around setting up the dotnet cli and related sdks for GitHub actions. As part of that we use proxy settings (for self-hosted runners) and set-up nuget authentication for private feeds.
 
-# Checkin
+If you would like to contribute there are a few things to consider:
 
-- Do checkin source (src)
-- Do checkin build output (lib)
-- Do checkin runtime node_modules
-- Do not checkin 
+## Commands to use
 
-# Adding a dev dependency
+- npm run build - Compiles the action into a single js file at dist/index.js (Please check in the changes made by this command)
+- npm run test - Runs all tests under __tests__
+- npm run format - Runs formatting required to pass the lint test (Please check in the changes made by this command)
+- npm run update-installers - Updates the install-dotnet scripts in externals (Please check in the changes made by this command)
 
-Remember to update .gitignore.  
+## To check in or not to check in
 
-# Updating toolkit dependency
+- Do check in source (src)
+- Do check in index file (dist)
+- Do check in updates to install-dotnet scripts (externals)
+- Do not check in build output (lib)
+- Do not check in runtime (node_modules)
 
-Until released publically, update tgz packages in toolkit
+## Writing tests
+
+With any contribution please take time to consider how this can be tested to maintain high quality. Current tests can be found in the folder __tests__ for examples.
+
+## Creating new version
+
+Details on versioning can be found here: https://github.com/actions/toolkit/blob/main/docs/action-versioning.md
+Create a new release using the UI. Version format should be `v1.x.x`. Creating a new major version requires reaction from users and should be done only with breaking changes.
+Once the new release is created, the v1 tag needs to be updated as well.
+```
+git tag -fa v1 -m "Update v1 tag"
+git push origin v1 --force
+```

externals/get-os-distro.sh

@@ -1,192 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) .NET Foundation and contributors. All rights reserved.
-# Licensed under the MIT license. See LICENSE file in the project root for full license information.
-#
-
-# Stop script on NZEC
-set -e
-# Stop script if unbound variable found (use ${var:-} if intentional)
-set -u
-# By default cmd1 | cmd2 returns exit code of cmd2 regardless of cmd1 success
-# This is causing it to fail
-set -o pipefail
-
-# Use in the the functions: eval $invocation
-invocation='say_verbose "Calling: ${yellow:-}${FUNCNAME[0]} ${green:-}$*${normal:-}"'
-
-# standard output may be used as a return value in the functions
-# we need a way to write text on the screen in the functions so that
-# it won't interfere with the return value.
-# Exposing stream 3 as a pipe to standard output of the script itself
-exec 3>&1
-
-say_err() {
-    printf "%b\n" "get-os-distro: Error: $1" >&2
-}
-
-# This platform list is finite - if the SDK/Runtime has supported Linux distribution-specific assets,
-#   then and only then should the Linux distribution appear in this list.
-# Adding a Linux distribution to this list does not imply distribution-specific support.
-get_legacy_os_name_from_platform() {
-
-    platform="$1"
-    case "$platform" in
-        "centos.7")
-            echo "centos"
-            return 0
-            ;;
-        "debian.8")
-            echo "debian"
-            return 0
-            ;;
-        "fedora.23")
-            echo "fedora.23"
-            return 0
-            ;;
-        "fedora.27")
-            echo "fedora.27"
-            return 0
-            ;;
-        "fedora.24")
-            echo "fedora.24"
-            return 0
-            ;;
-        "opensuse.13.2")
-            echo "opensuse.13.2"
-            return 0
-            ;;
-        "opensuse.42.1")
-            echo "opensuse.42.1"
-            return 0
-            ;;
-        "opensuse.42.3")
-            echo "opensuse.42.3"
-            return 0
-            ;;
-        "rhel.7"*)
-            echo "rhel"
-            return 0
-            ;;
-        "ubuntu.14.04")
-            echo "ubuntu"
-            return 0
-            ;;
-        "ubuntu.16.04")
-            echo "ubuntu.16.04"
-            return 0
-            ;;
-        "ubuntu.16.10")
-            echo "ubuntu.16.10"
-            return 0
-            ;;
-        "ubuntu.18.04")
-            echo "ubuntu.18.04"
-            return 0
-            ;;
-        "alpine.3.4.3")
-            echo "alpine"
-            return 0
-            ;;
-    esac
-    return 1
-}
-
-get_linux_platform_name() {
-
-    if [ -e /etc/os-release ]; then
-        . /etc/os-release
-        echo "$ID.$VERSION_ID"
-        return 0
-    elif [ -e /etc/redhat-release ]; then
-        local redhatRelease=$(</etc/redhat-release)
-        if [[ $redhatRelease == "CentOS release 6."* || $redhatRelease == "Red Hat Enterprise Linux Server release 6."* ]]; then
-            echo "rhel.6"
-            return 0
-        fi
-    fi
-
-    say_err "Linux specific platform name and version could not be detected: UName = $uname"
-    return 1
-}
-
-get_current_os_name() {
-
-    local uname=$(uname)
-    if [ "$uname" = "Darwin" ]; then
-        echo "osx"
-        return 0
-    elif [ "$uname" = "Linux" ]; then
-        local linux_platform_name
-        linux_platform_name="$(get_linux_platform_name)" || { echo "linux" && return 0 ; }
-
-        if [[ $linux_platform_name == "rhel.6" ]]; then
-            echo "$linux_platform_name"
-            return 0
-        elif [[ $linux_platform_name == alpine* ]]; then
-            echo "linux-musl"
-            return 0
-        else
-            echo "linux"
-            return 0
-        fi
-    fi
-
-    say_err "OS name could not be detected: UName = $uname"
-    return 1
-}
-
-get_legacy_os_name() {
-
-    local uname=$(uname)
-    if [ "$uname" = "Darwin" ]; then
-        echo "osx"
-        return 0
-    else
-        if [ -e /etc/os-release ]; then
-            . /etc/os-release
-            os=$(get_legacy_os_name_from_platform "$ID.$VERSION_ID" || echo "")
-            if [ -n "$os" ]; then
-                echo "$os"
-                return 0
-            fi
-        fi
-    fi
-
-    say_err "Distribution specific OS name and version could not be detected: UName = $uname"
-    return 1
-}
-
-get_machine_architecture() {
-
-    if command -v uname > /dev/null; then
-        CPUName=$(uname -m)
-        case $CPUName in
-        armv7l)
-            echo "arm"
-            return 0
-            ;;
-        aarch64)
-            echo "arm64"
-            return 0
-            ;;
-        esac
-    fi
-
-    # Always default to 'x64'
-    echo "x64"
-    return 0
-}
-
-osName=$(get_current_os_name || echo "")
-legacyOsName=$(get_legacy_os_name || echo "")
-arch=$(get_machine_architecture || echo "")
-
-primaryName="$osName-$arch"
-legacyName="$legacyOsName"
-
-echo "Primary:$primaryName"
-echo "Legacy:$legacyName"
-
-if [ -z "$osName" ] && [ -z "$legacyOsName" ];then
-    exit 1
-fi

externals/get-os-platform.ps1

@@ -1,18 +0,0 @@
-function Get-Machine-Architecture()
-{
-    # possible values: AMD64, IA64, x86
-    return $ENV:PROCESSOR_ARCHITECTURE
-}
-
-function Get-CLIArchitecture-From-Architecture([string]$Architecture)
-{
-    switch ($Architecture.ToLower())
-    {
-        { ($_ -eq "amd64") -or ($_ -eq "x64") } { return "x64" }
-        { $_ -eq "x86" } { return "x86" }
-        default { throw "Architecture not supported. If you think this is a bug, please report it at https://github.com/dotnet/cli/issues" }
-    }
-}
-
-$CLIArchitecture = Get-CLIArchitecture-From-Architecture $(Get-Machine-Architecture)
-Write-Output "Primary:win-$CLIArchitecture"

package.json

@@ -11,6 +11,13 @@
     "test": "jest",
     "update-installers": "nwget https://dot.net/v1/dotnet-install.ps1 -O externals/install-dotnet.ps1 && nwget https://dot.net/v1/dotnet-install.sh -O externals/install-dotnet.sh"
   },
+  "husky": {
+    "hooks": {
+      "//": "Tests are not run at push time since they can take 2-4 minutes to complete",
+      "pre-commit": "npm run format",
+      "pre-push": "npm run format-check"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/actions/setup-dotnet.git"
@@ -23,26 +30,29 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.2",
-    "@actions/exec": "^1.0.3",
+    "@actions/core": "^1.6.0",
+    "@actions/exec": "^1.0.4",
     "@actions/github": "^1.1.0",
     "@actions/http-client": "^1.0.8",
     "@actions/io": "^1.0.2",
-    "@actions/tool-cache": "^1.3.1",
     "fast-xml-parser": "^3.15.1",
     "semver": "^6.3.0",
     "xmlbuilder": "^13.0.2"
   },
   "devDependencies": {
-    "@types/jest": "^24.0.13",
-    "@types/node": "^12.0.4",
-    "@types/semver": "^6.0.0",
-    "@zeit/ncc": "^0.21.0",
-    "jest": "^26.0.1",
-    "jest-circus": "^26.0.1",
-    "prettier": "^1.17.1",
-    "ts-jest": "^26.0.0",
-    "typescript": "^3.9.2",
-    "wget-improved": "^3.0.2"
+    "@types/jest": "^27.0.2",
+    "@types/node": "^12.12.62",
+    "@types/semver": "^6.2.2",
+    "@zeit/ncc": "^0.21.1",
+    "husky": "^7.0.2",
+    "jest": "^27.2.5",
+    "jest-circus": "^27.2.5",
+    "prettier": "^1.19.1",
+    "ts-jest": "^27.0.5",
+    "typescript": "^3.9.7",
+    "wget-improved": "^3.2.1"
+  },
+  "jest": {
+    "testEnvironment": "node"
   }
 }

src/authutil.ts

@@ -4,18 +4,22 @@ import * as core from '@actions/core';
 import * as github from '@actions/github';
 import * as xmlbuilder from 'xmlbuilder';
 import * as xmlParser from 'fast-xml-parser';
+import {ProcessEnvOptions} from 'child_process';
 
 export function configAuthentication(
   feedUrl: string,
-  existingFileLocation: string = ''
+  existingFileLocation: string = '',
+  processRoot: string = process.cwd()
 ) {
   const existingNuGetConfig: string = path.resolve(
-    process.env['RUNNER_TEMP'] || process.cwd(),
-    existingFileLocation == '' ? 'nuget.config' : existingFileLocation
+    processRoot,
+    existingFileLocation === ''
+      ? getExistingNugetConfig(processRoot)
+      : existingFileLocation
   );
 
   const tempNuGetConfig: string = path.resolve(
-    process.env['RUNNER_TEMP'] || process.cwd(),
+    processRoot,
     '../',
     'nuget.config'
   );
@@ -23,6 +27,21 @@ export function configAuthentication(
   writeFeedToFile(feedUrl, existingNuGetConfig, tempNuGetConfig);
 }
 
+function isValidKey(key: string): boolean {
+  return /^[\w\-\.]+$/i.test(key);
+}
+
+function getExistingNugetConfig(processRoot: string) {
+  const defaultConfigName = 'nuget.config';
+  const configFileNames = fs
+    .readdirSync(processRoot)
+    .filter(filename => filename.toLowerCase() === defaultConfigName);
+  if (configFileNames.length) {
+    return configFileNames[0];
+  }
+  return defaultConfigName;
+}
+
 function writeFeedToFile(
   feedUrl: string,
   existingFileLocation: string,
@@ -107,9 +126,9 @@ function writeFeedToFile(
   xml = xml.ele('packageSourceCredentials');
 
   sourceKeys.forEach(key => {
-    if (key.indexOf(' ') > -1) {
+    if (!isValidKey(key)) {
       throw new Error(
-        "This action currently can't handle source names with spaces. Remove the space from your repo's NuGet.config and try again."
+        "Source name can contain letters, numbers, and '-', '_', '.' symbols only. Please, fix source name in NuGet.config and try again."
       );
     }
 

src/installer.ts

@@ -1,40 +1,26 @@
 // Load tempDirectory before it gets wiped by tool-cache
-let tempDirectory = process.env['RUNNER_TEMPDIRECTORY'] || '';
 import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 import * as io from '@actions/io';
-import * as tc from '@actions/tool-cache';
 import hc = require('@actions/http-client');
 import {chmodSync} from 'fs';
-import * as os from 'os';
 import * as path from 'path';
+import {ExecOptions} from '@actions/exec/lib/interfaces';
 import * as semver from 'semver';
 
 const IS_WINDOWS = process.platform === 'win32';
 
-if (!tempDirectory) {
-  let baseLocation;
-  if (IS_WINDOWS) {
-    // On windows use the USERPROFILE env variable
-    baseLocation = process.env['USERPROFILE'] || 'C:\\';
-  } else {
-    if (process.platform === 'darwin') {
-      baseLocation = '/Users';
-    } else {
-      baseLocation = '/home';
-    }
-  }
-  tempDirectory = path.join(baseLocation, 'actions', 'temp');
-}
-
 /**
  * Represents the inputted version information
  */
 export class DotNetVersionInfo {
+  public inputVersion: string;
   private fullversion: string;
   private isExactVersionSet: boolean = false;
 
   constructor(version: string) {
+    this.inputVersion = version;
+
     // Check for exact match
     if (semver.valid(semver.clean(version) || '') != null) {
       this.fullversion = semver.clean(version) as string;
@@ -43,8 +29,7 @@ export class DotNetVersionInfo {
       return;
     }
 
-    //Note: No support for previews when using generic
-    let parts: string[] = version.split('.');
+    const parts: string[] = version.split('.');
 
     if (parts.length < 2 || parts.length > 3) this.throwInvalidVersionFormat();
 
@@ -52,8 +37,10 @@ export class DotNetVersionInfo {
       this.throwInvalidVersionFormat();
     }
 
-    let major = this.getVersionNumberOrThrow(parts[0]);
-    let minor = this.getVersionNumberOrThrow(parts[1]);
+    const major = this.getVersionNumberOrThrow(parts[0]);
+    const minor = ['x', '*'].includes(parts[1])
+      ? parts[1]
+      : this.getVersionNumberOrThrow(parts[1]);
 
     this.fullversion = major + '.' + minor;
   }
@@ -74,7 +61,9 @@ export class DotNetVersionInfo {
   }
 
   private throwInvalidVersionFormat() {
-    throw 'Invalid version format! Supported: 1.2.3, 1.2, 1.2.x, 1.2.*';
+    throw new Error(
+      'Invalid version format! Supported: 1.2.3, 1.2, 1.2.x, 1.2.*'
+    );
   }
 
   /**
@@ -89,91 +78,55 @@ export class DotNetVersionInfo {
   }
 }
 
-/**
- * Represents a resolved version from the Web-Api
- */
-class ResolvedVersionInfo {
-  downloadUrls: string[];
-  resolvedVersion: string;
-
-  constructor(downloadUrls: string[], resolvedVersion: string) {
-    if (downloadUrls.length === 0) {
-      throw 'DownloadUrls can not be empty';
-    }
-
-    if (!resolvedVersion) {
-      throw 'Resolved version is invalid';
-    }
-
-    this.downloadUrls = downloadUrls;
-    this.resolvedVersion = resolvedVersion;
-  }
-}
-
 export class DotnetCoreInstaller {
-  constructor(version: string) {
-    this.versionInfo = new DotNetVersionInfo(version);
-    this.cachedToolName = 'dncs';
-    this.arch = 'x64';
+  constructor(version: string, includePrerelease: boolean = false) {
+    this.version = version;
+    this.includePrerelease = includePrerelease;
   }
 
   public async installDotnet() {
-    // Check cache
-    let toolPath: string = '';
-    let osSuffixes = await this.detectMachineOS();
-    let parts = osSuffixes[0].split('-');
-    if (parts.length > 1) {
-      this.arch = parts[1];
-    }
-
-    // If version is not generic -> look up cache
-    if (this.versionInfo.isExactVersion())
-      toolPath = this.getLocalTool(this.versionInfo.version());
-
-    if (!toolPath) {
-      // download, extract, cache
-      console.log('Getting a download url', this.versionInfo.version());
-      let resolvedVersionInfo = await this.resolveInfos(
-        osSuffixes,
-        this.versionInfo
-      );
-
-      //Check if cache exists for resolved version
-      toolPath = this.getLocalTool(resolvedVersionInfo.resolvedVersion);
-      if (!toolPath) {
-        //If not exists install it
-        toolPath = await this.downloadAndInstall(resolvedVersionInfo);
-      } else {
-        console.log('Using cached tool');
-      }
-    } else {
-      console.log('Using cached tool');
-    }
-
-    // Need to set this so that .NET Core global tools find the right locations.
-    core.exportVariable('DOTNET_ROOT', toolPath);
-
-    // Prepend the tools path. instructs the agent to prepend for future tasks
-    core.addPath(toolPath);
-  }
-
-  private getLocalTool(version: string): string {
-    console.log('Checking tool cache', version);
-    return tc.find(this.cachedToolName, version, this.arch);
-  }
-
-  private async detectMachineOS(): Promise<string[]> {
-    let osSuffix: string[] = [];
     let output = '';
-
     let resultCode = 0;
+
+    let calculatedVersion = await this.resolveVersion(
+      new DotNetVersionInfo(this.version)
+    );
+
+    var envVariables: {[key: string]: string} = {};
+    for (let key in process.env) {
+      if (process.env[key]) {
+        let value: any = process.env[key];
+        envVariables[key] = value;
+      }
+    }
     if (IS_WINDOWS) {
       let escapedScript = path
-        .join(__dirname, '..', 'externals', 'get-os-platform.ps1')
+        .join(__dirname, '..', 'externals', 'install-dotnet.ps1')
         .replace(/'/g, "''");
       let command = `& '${escapedScript}'`;
+      if (calculatedVersion) {
+        command += ` -Version ${calculatedVersion}`;
+      }
+      if (process.env['https_proxy'] != null) {
+        command += ` -ProxyAddress ${process.env['https_proxy']}`;
+      }
+      // This is not currently an option
+      if (process.env['no_proxy'] != null) {
+        command += ` -ProxyBypassList ${process.env['no_proxy']}`;
+      }
 
+      // process.env must be explicitly passed in for DOTNET_INSTALL_DIR to be used
       const powershellPath = await io.which('powershell', true);
+
+      var options: ExecOptions = {
+        listeners: {
+          stdout: (data: Buffer) => {
+            output += data.toString();
+          }
+        },
+        env: envVariables
+      };
+
       resultCode = await exec.exec(
         `"${powershellPath}"`,
         [
@@ -186,98 +139,70 @@ export class DotnetCoreInstaller {
           '-Command',
           command
         ],
-        {
-          listeners: {
-            stdout: (data: Buffer) => {
-              output += data.toString();
-            }
-          }
-        }
+        options
       );
     } else {
-      let scriptPath = path.join(
-        __dirname,
-        '..',
-        'externals',
-        'get-os-distro.sh'
-      );
-      chmodSync(scriptPath, '777');
+      let escapedScript = path
+        .join(__dirname, '..', 'externals', 'install-dotnet.sh')
+        .replace(/'/g, "''");
+      chmodSync(escapedScript, '777');
 
-      const toolPath = await io.which(scriptPath, true);
-      resultCode = await exec.exec(`"${toolPath}"`, [], {
+      const scriptPath = await io.which(escapedScript, true);
+
+      let scriptArguments: string[] = [];
+      if (calculatedVersion) {
+        scriptArguments.push('--version', calculatedVersion);
+      }
+
+      // process.env must be explicitly passed in for DOTNET_INSTALL_DIR to be used
+      resultCode = await exec.exec(`"${scriptPath}"`, scriptArguments, {
         listeners: {
           stdout: (data: Buffer) => {
             output += data.toString();
           }
-        }
+        },
+        env: envVariables
       });
     }
 
     if (resultCode != 0) {
-      throw `Failed to detect os with result code ${resultCode}. Output: ${output}`;
+      throw new Error(`Failed to install dotnet ${resultCode}. ${output}`);
     }
-
-    let index;
-    if ((index = output.indexOf('Primary:')) >= 0) {
-      let primary = output.substr(index + 'Primary:'.length).split(os.EOL)[0];
-      osSuffix.push(primary);
-    }
-
-    if ((index = output.indexOf('Legacy:')) >= 0) {
-      let legacy = output.substr(index + 'Legacy:'.length).split(os.EOL)[0];
-      osSuffix.push(legacy);
-    }
-
-    if (osSuffix.length == 0) {
-      throw 'Could not detect platform';
-    }
-
-    return osSuffix;
   }
 
-  private async downloadAndInstall(resolvedVersionInfo: ResolvedVersionInfo) {
-    let downloaded = false;
-    let downloadPath = '';
-    for (const url of resolvedVersionInfo.downloadUrls) {
-      try {
-        downloadPath = await tc.downloadTool(url);
-        downloaded = true;
-        break;
-      } catch (error) {
-        console.log('Could not Download', url, JSON.stringify(error));
+  static addToPath() {
+    if (process.env['DOTNET_INSTALL_DIR']) {
+      core.addPath(process.env['DOTNET_INSTALL_DIR']);
+      core.exportVariable('DOTNET_ROOT', process.env['DOTNET_INSTALL_DIR']);
+    } else {
+      if (IS_WINDOWS) {
+        // This is the default set in install-dotnet.ps1
+        core.addPath(
+          path.join(process.env['LocalAppData'] + '', 'Microsoft', 'dotnet')
+        );
+        core.exportVariable(
+          'DOTNET_ROOT',
+          path.join(process.env['LocalAppData'] + '', 'Microsoft', 'dotnet')
+        );
+      } else {
+        // This is the default set in install-dotnet.sh
+        core.addPath(path.join(process.env['HOME'] + '', '.dotnet'));
+        core.exportVariable(
+          'DOTNET_ROOT',
+          path.join(process.env['HOME'] + '', '.dotnet')
+        );
       }
     }
 
-    if (!downloaded) {
-      throw 'Failed to download package';
-    }
-
-    // extract
-    console.log('Extracting Package', downloadPath);
-    let extPath: string = IS_WINDOWS
-      ? await tc.extractZip(downloadPath)
-      : await tc.extractTar(downloadPath);
-
-    // cache tool
-    console.log('Caching tool');
-    let cachedDir = await tc.cacheDir(
-      extPath,
-      this.cachedToolName,
-      resolvedVersionInfo.resolvedVersion,
-      this.arch
-    );
-
-    console.log('Successfully installed', resolvedVersionInfo.resolvedVersion);
-    return cachedDir;
+    console.log(process.env['PATH']);
   }
 
-  // OsSuffixes - The suffix which is a part of the file name ex- linux-x64, windows-x86
-  // Type - SDK / Runtime
   // versionInfo - versionInfo of the SDK/Runtime
-  async resolveInfos(
-    osSuffixes: string[],
-    versionInfo: DotNetVersionInfo
-  ): Promise<ResolvedVersionInfo> {
+  async resolveVersion(versionInfo: DotNetVersionInfo): Promise<string> {
+    if (versionInfo.isExactVersion()) {
+      return versionInfo.version();
+    }
+
     const httpClient = new hc.HttpClient('actions/setup-dotnet', [], {
       allowRetries: true,
       maxRetries: 3
@@ -293,79 +218,43 @@ export class DotnetCoreInstaller {
     let releasesInfo: any[] = releasesResult['releases'];
     releasesInfo = releasesInfo.filter((releaseInfo: any) => {
       return (
-        semver.satisfies(
-          releaseInfo['sdk']['version'],
-          versionInfo.version()
-        ) ||
+        semver.satisfies(releaseInfo['sdk']['version'], versionInfo.version(), {
+          includePrerelease: this.includePrerelease
+        }) ||
         semver.satisfies(
           releaseInfo['sdk']['version-display'],
-          versionInfo.version()
+          versionInfo.version(),
+          {
+            includePrerelease: this.includePrerelease
+          }
         )
       );
     });
 
     // Exclude versions that are newer than the latest if using not exact
-    if (!versionInfo.isExactVersion()) {
-      let latestSdk: string = releasesResult['latest-sdk'];
+    let latestSdk: string = releasesResult['latest-sdk'];
 
-      releasesInfo = releasesInfo.filter((releaseInfo: any) =>
-        semver.lte(releaseInfo['sdk']['version'], latestSdk)
-      );
-    }
+    releasesInfo = releasesInfo.filter((releaseInfo: any) =>
+      semver.lte(releaseInfo['sdk']['version'], latestSdk, {
+        includePrerelease: this.includePrerelease
+      })
+    );
 
     // Sort for latest version
     releasesInfo = releasesInfo.sort((a, b) =>
-      semver.rcompare(a['sdk']['version'], b['sdk']['version'])
+      semver.rcompare(a['sdk']['version'], b['sdk']['version'], {
+        includePrerelease: this.includePrerelease
+      })
     );
 
-    let downloadedVersion: string = '';
-    let downloadUrls: string[] = [];
-
-    if (releasesInfo.length != 0) {
-      let release = releasesInfo[0];
-
-      downloadedVersion = release['sdk']['version'];
-
-      let files: any[] = release['sdk']['files'];
-      files = files.filter((file: any) => {
-        if (file['rid'] == osSuffixes[0] || file['rid'] == osSuffixes[1]) {
-          return (
-            file['url'].endsWith('.zip') || file['url'].endsWith('.tar.gz')
-          );
-        }
-      });
-
-      if (files.length > 0) {
-        files.forEach((file: any) => {
-          downloadUrls.push(file['url']);
-        });
-      } else {
-        throw `The specified version's download links are not correctly formed in the supported versions document => ${releasesJsonUrl}`;
-      }
-    } else {
-      console.log(
-        `Could not fetch download information for version ${versionInfo.version()}`
+    if (releasesInfo.length == 0) {
+      throw new Error(
+        `Could not find dotnet core version. Please ensure that specified version ${versionInfo.inputVersion} is valid.`
       );
-
-      if (versionInfo.isExactVersion()) {
-        console.log('Using fallback');
-
-        downloadUrls = await this.getFallbackDownloadUrls(
-          versionInfo.version()
-        );
-        downloadedVersion = versionInfo.version();
-      } else {
-        console.log('Unable to use fallback, version is generic!');
-      }
     }
 
-    if (downloadUrls.length == 0) {
-      throw `Could not construct download URL. Please ensure that specified version ${versionInfo.version()}/${downloadedVersion} is valid.`;
-    }
-
-    core.debug(`Got download urls ${downloadUrls}`);
-
-    return new ResolvedVersionInfo(downloadUrls, downloadedVersion);
+    let release = releasesInfo[0];
+    return release['sdk']['version'];
   }
 
   private async getReleasesJsonUrl(
@@ -375,125 +264,40 @@ export class DotnetCoreInstaller {
     const response = await httpClient.getJson<any>(DotNetCoreIndexUrl);
     const result = response.result || {};
     let releasesInfo: any[] = result['releases-index'];
+
     releasesInfo = releasesInfo.filter((info: any) => {
       // channel-version is the first 2 elements of the version (e.g. 2.1), filter out versions that don't match 2.1.x.
       const sdkParts: string[] = info['channel-version'].split('.');
-      if (versionParts.length >= 2 && versionParts[1] != 'x') {
+      if (
+        versionParts.length >= 2 &&
+        !(versionParts[1] == 'x' || versionParts[1] == '*')
+      ) {
         return versionParts[0] == sdkParts[0] && versionParts[1] == sdkParts[1];
       }
       return versionParts[0] == sdkParts[0];
     });
+
     if (releasesInfo.length === 0) {
-      throw `Could not find info for version ${versionParts.join(
-        '.'
-      )} at ${DotNetCoreIndexUrl}`;
+      throw new Error(
+        `Could not find info for version ${versionParts.join(
+          '.'
+        )} at ${DotNetCoreIndexUrl}`
+      );
     }
-    return releasesInfo[0]['releases.json'];
+
+    const releaseInfo = releasesInfo[0];
+    if (releaseInfo['support-phase'] === 'eol') {
+      core.warning(
+        `${releaseInfo['product']} ${releaseInfo['channel-version']} is no longer supported and will not receive security updates in the future. Please refer to https://aka.ms/dotnet-core-support for more information about the .NET support policy.`
+      );
+    }
+
+    return releaseInfo['releases.json'];
   }
 
-  private async getFallbackDownloadUrls(version: string): Promise<string[]> {
-    let primaryUrlSearchString: string;
-    let legacyUrlSearchString: string;
-    let output = '';
-    let resultCode = 0;
-
-    if (IS_WINDOWS) {
-      let escapedScript = path
-        .join(__dirname, '..', 'externals', 'install-dotnet.ps1')
-        .replace(/'/g, "''");
-      let command = `& '${escapedScript}' -Version ${version} -DryRun`;
-
-      const powershellPath = await io.which('powershell', true);
-      resultCode = await exec.exec(
-        `"${powershellPath}"`,
-        [
-          '-NoLogo',
-          '-Sta',
-          '-NoProfile',
-          '-NonInteractive',
-          '-ExecutionPolicy',
-          'Unrestricted',
-          '-Command',
-          command
-        ],
-        {
-          listeners: {
-            stdout: (data: Buffer) => {
-              output += data.toString();
-            }
-          }
-        }
-      );
-
-      primaryUrlSearchString = 'dotnet-install: Primary named payload URL: ';
-      legacyUrlSearchString = 'dotnet-install: Legacy named payload URL: ';
-    } else {
-      let escapedScript = path
-        .join(__dirname, '..', 'externals', 'install-dotnet.sh')
-        .replace(/'/g, "''");
-      chmodSync(escapedScript, '777');
-
-      const scriptPath = await io.which(escapedScript, true);
-      resultCode = await exec.exec(
-        `"${scriptPath}"`,
-        ['--version', version, '--dry-run'],
-        {
-          listeners: {
-            stdout: (data: Buffer) => {
-              output += data.toString();
-            }
-          }
-        }
-      );
-
-      primaryUrlSearchString = 'dotnet-install: Primary named payload URL: ';
-      legacyUrlSearchString = 'dotnet-install: Legacy named payload URL: ';
-    }
-
-    if (resultCode != 0) {
-      throw `Failed to get download urls with result code ${resultCode}. ${output}`;
-    }
-
-    let primaryUrl: string = '';
-    let legacyUrl: string = '';
-    if (!!output && output.length > 0) {
-      let lines: string[] = output.split(os.EOL);
-
-      // Fallback to \n if initial split doesn't work (not consistent across versions)
-      if (lines.length === 1) {
-        lines = output.split('\n');
-      }
-      if (!!lines && lines.length > 0) {
-        lines.forEach((line: string) => {
-          if (!line) {
-            return;
-          }
-          var primarySearchStringIndex = line.indexOf(primaryUrlSearchString);
-          if (primarySearchStringIndex > -1) {
-            primaryUrl = line.substring(
-              primarySearchStringIndex + primaryUrlSearchString.length
-            );
-            return;
-          }
-
-          var legacySearchStringIndex = line.indexOf(legacyUrlSearchString);
-          if (legacySearchStringIndex > -1) {
-            legacyUrl = line.substring(
-              legacySearchStringIndex + legacyUrlSearchString.length
-            );
-            return;
-          }
-        });
-      }
-    }
-
-    return [primaryUrl, legacyUrl];
-  }
-
-  private versionInfo: DotNetVersionInfo;
-  private cachedToolName: string;
-  private arch: string;
+  private version: string;
+  private includePrerelease: boolean;
 }
 
 const DotNetCoreIndexUrl: string =
-  'https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json';
+  'https://builds.dotnet.microsoft.com/dotnet/release-metadata/releases-index.json';

src/setup-dotnet.ts

@@ -7,30 +7,35 @@ import * as auth from './authutil';
 export async function run() {
   try {
     //
-    // Version is optional.  If supplied, install / use from the tool cache
-    // If not supplied then task is still used to setup proxy, auth, etc...
+    // dotnet-version is optional, but needs to be provided for most use cases.
+    // If supplied, install / use from the tool cache.
+    // If not supplied, look for version in ./global.json.
+    // If a valid version still can't be identified, nothing will be installed.
+    // Proxy, auth, (etc) are still set up, even if no version is identified
     //
-    let version: string = core.getInput('version');
-    if (!version) {
-      version = core.getInput('dotnet-version');
-    }
-    if (!version) {
+    let versions = core.getMultilineInput('dotnet-version');
+    if (!versions.length) {
       // Try to fall back to global.json
       core.debug('No version found, trying to find version from global.json');
       const globalJsonPath = path.join(process.cwd(), 'global.json');
       if (fs.existsSync(globalJsonPath)) {
-        const globalJson = JSON.parse(
-          fs.readFileSync(globalJsonPath, {encoding: 'utf8'})
-        );
-        if (globalJson.sdk && globalJson.sdk.version) {
-          version = globalJson.sdk.version;
-        }
+        versions.push(getVersionFromGlobalJson(globalJsonPath));
       }
     }
 
-    if (version) {
-      const dotnetInstaller = new installer.DotnetCoreInstaller(version);
-      await dotnetInstaller.installDotnet();
+    if (versions.length) {
+      const includePrerelease: boolean =
+        (core.getInput('include-prerelease') || 'false').toLowerCase() ===
+        'true';
+      let dotnetInstaller!: installer.DotnetCoreInstaller;
+      for (const version of new Set<string>(versions)) {
+        dotnetInstaller = new installer.DotnetCoreInstaller(
+          version,
+          includePrerelease
+        );
+        await dotnetInstaller.installDotnet();
+      }
+      installer.DotnetCoreInstaller.addToPath();
     }
 
     const sourceUrl: string = core.getInput('source-url');
@@ -46,4 +51,21 @@ export async function run() {
   }
 }
 
+function getVersionFromGlobalJson(globalJsonPath: string): string {
+  let version: string = '';
+  const globalJson = JSON.parse(
+    // .trim() is necessary to strip BOM https://github.com/nodejs/node/issues/20649
+    fs.readFileSync(globalJsonPath, {encoding: 'utf8'}).trim()
+  );
+  if (globalJson.sdk && globalJson.sdk.version) {
+    version = globalJson.sdk.version;
+    const rollForward = globalJson.sdk.rollForward;
+    if (rollForward && rollForward === 'latestFeature') {
+      const [major, minor] = version.split('.');
+      version = `${major}.${minor}`;
+    }
+  }
+  return version;
+}
+
 run();