Merge remote-tracking branch 'github/main' into refactor-installer

__tests__/cache-restore.test.ts

@@ -0,0 +1,101 @@
+import {readdir} from 'node:fs/promises';
+import * as cache from '@actions/cache';
+import * as core from '@actions/core';
+import * as glob from '@actions/glob';
+import {restoreCache} from '../src/cache-restore';
+import {getNuGetFolderPath} from '../src/cache-utils';
+import {lockFilePatterns} from '../src/constants';
+
+jest.mock('node:fs/promises');
+jest.mock('@actions/cache');
+jest.mock('@actions/core');
+jest.mock('@actions/glob');
+jest.mock('../src/cache-utils');
+
+describe('cache-restore tests', () => {
+  describe.each(lockFilePatterns)('restoreCache("%s")', lockFilePattern => {
+    /** Store original process.env.GITHUB_WORKSPACE */
+    let githubWorkspace: string | undefined;
+    beforeAll(() => {
+      githubWorkspace = process.env.GITHUB_WORKSPACE;
+      jest.mocked(getNuGetFolderPath).mockResolvedValue({
+        'global-packages': 'global-packages',
+        'http-cache': 'http-cache',
+        temp: 'temp',
+        'plugins-cache': 'plugins-cache'
+      });
+    });
+    beforeEach(() => {
+      process.env.GITHUB_WORKSPACE = './';
+      jest.mocked(glob.hashFiles).mockClear();
+      jest.mocked(core.saveState).mockClear();
+      jest.mocked(core.setOutput).mockClear();
+      jest.mocked(cache.restoreCache).mockClear();
+    });
+    afterEach(() => (process.env.GITHUB_WORKSPACE = githubWorkspace));
+
+    it('throws error when lock file is not found', async () => {
+      jest.mocked(glob.hashFiles).mockResolvedValue('');
+
+      await expect(restoreCache(lockFilePattern)).rejects.toThrow();
+
+      expect(jest.mocked(core.saveState)).not.toHaveBeenCalled();
+      expect(jest.mocked(core.setOutput)).not.toHaveBeenCalled();
+      expect(jest.mocked(cache.restoreCache)).not.toHaveBeenCalled();
+    });
+
+    it('does not call core.saveState("CACHE_RESULT") when cache.restoreCache() returns falsy', async () => {
+      jest.mocked(glob.hashFiles).mockResolvedValue('hash');
+      jest.mocked(cache.restoreCache).mockResolvedValue(undefined);
+
+      await restoreCache(lockFilePattern);
+
+      const expectedKey = `dotnet-cache-${process.env.RUNNER_OS}-hash`;
+      expect(jest.mocked(core.saveState)).toHaveBeenCalledWith(
+        'CACHE_KEY',
+        expectedKey
+      );
+      expect(jest.mocked(core.saveState)).not.toHaveBeenCalledWith(
+        'CACHE_RESULT',
+        expectedKey
+      );
+      expect(jest.mocked(core.setOutput)).toHaveBeenCalledWith(
+        'cache-hit',
+        false
+      );
+    });
+
+    it('calls core.saveState("CACHE_RESULT") when cache.restoreCache() returns key', async () => {
+      const expectedKey = `dotnet-cache-${process.env.RUNNER_OS}-hash`;
+      jest.mocked(glob.hashFiles).mockResolvedValue('hash');
+      jest.mocked(cache.restoreCache).mockResolvedValue(expectedKey);
+
+      await restoreCache(lockFilePattern);
+
+      expect(jest.mocked(core.saveState)).toHaveBeenCalledWith(
+        'CACHE_KEY',
+        expectedKey
+      );
+      expect(jest.mocked(core.saveState)).toHaveBeenCalledWith(
+        'CACHE_RESULT',
+        expectedKey
+      );
+      expect(jest.mocked(core.setOutput)).toHaveBeenCalledWith(
+        'cache-hit',
+        true
+      );
+    });
+
+    it('calls glob.hashFiles("/packages.lock.json") if cacheDependencyPath is falsy', async () => {
+      const expectedKey = `dotnet-cache-${process.env.RUNNER_OS}-hash`;
+      jest.mocked(glob.hashFiles).mockResolvedValue('hash');
+      jest.mocked(cache.restoreCache).mockResolvedValue(expectedKey);
+      jest.mocked(readdir).mockResolvedValue([lockFilePattern] as any);
+
+      await restoreCache('');
+
+      expect(jest.mocked(glob.hashFiles)).not.toHaveBeenCalledWith('');
+      expect(jest.mocked(glob.hashFiles)).toHaveBeenCalledWith(lockFilePattern);
+    });
+  });
+});

__tests__/cache-save.test.ts

@@ -0,0 +1,87 @@
+import * as cache from '@actions/cache';
+import * as core from '@actions/core';
+import fs from 'node:fs';
+import {run} from '../src/cache-save';
+import {getNuGetFolderPath} from '../src/cache-utils';
+
+jest.mock('@actions/cache');
+jest.mock('@actions/core');
+jest.mock('node:fs');
+jest.mock('../src/cache-utils');
+
+describe('cache-save tests', () => {
+  beforeAll(() => {
+    jest.mocked(getNuGetFolderPath).mockResolvedValue({
+      'global-packages': 'global-packages',
+      'http-cache': 'http-cache',
+      temp: 'temp',
+      'plugins-cache': 'plugins-cache'
+    });
+  });
+  beforeEach(() => {
+    jest.mocked(core.setFailed).mockClear();
+    jest.mocked(core.getState).mockClear();
+    jest.mocked(core.setOutput).mockClear();
+    jest.mocked(cache.saveCache).mockClear();
+    jest.mocked(fs.existsSync).mockClear();
+  });
+
+  it('does not save cache when inputs:cache === false', async () => {
+    jest.mocked(core.getBooleanInput).mockReturnValue(false);
+
+    await run();
+
+    expect(jest.mocked(core.setFailed)).not.toHaveBeenCalled();
+    expect(jest.mocked(core.getState)).not.toHaveBeenCalled();
+    expect(jest.mocked(fs.existsSync)).not.toHaveBeenCalled();
+    expect(jest.mocked(cache.saveCache)).not.toHaveBeenCalled();
+  });
+
+  it('does not save cache when core.getState("CACHE_KEY") returns ""', async () => {
+    jest.mocked(core.getBooleanInput).mockReturnValue(true);
+    jest.mocked(core.getState).mockReturnValue('');
+
+    await run();
+
+    expect(jest.mocked(core.setFailed)).not.toHaveBeenCalled();
+    expect(jest.mocked(core.getState)).toHaveBeenCalledTimes(2);
+    expect(jest.mocked(fs.existsSync)).not.toHaveBeenCalled();
+    expect(jest.mocked(cache.saveCache)).not.toHaveBeenCalled();
+  });
+
+  it('throws Error when cachePath not exists', async () => {
+    jest.mocked(core.getBooleanInput).mockReturnValue(true);
+    jest.mocked(core.getState).mockReturnValue('cache-key');
+    jest.mocked(fs.existsSync).mockReturnValue(false);
+
+    await run();
+
+    expect(jest.mocked(core.setFailed)).toHaveBeenCalled();
+    expect(jest.mocked(core.getState)).toHaveBeenCalledTimes(2);
+    expect(jest.mocked(cache.saveCache)).not.toHaveBeenCalled();
+  });
+
+  it('does not save cache when state.CACHE_KEY === state.CACHE_RESULT', async () => {
+    jest.mocked(core.getBooleanInput).mockReturnValue(true);
+    jest.mocked(core.getState).mockReturnValue('cache-key');
+    jest.mocked(fs.existsSync).mockReturnValue(true);
+
+    await run();
+
+    expect(jest.mocked(core.setFailed)).not.toHaveBeenCalled();
+    expect(jest.mocked(core.getState)).toHaveBeenCalledTimes(2);
+    expect(jest.mocked(cache.saveCache)).not.toHaveBeenCalled();
+  });
+
+  it('saves cache when state.CACHE_KEY !== state.CACHE_RESULT', async () => {
+    jest.mocked(core.getBooleanInput).mockReturnValue(true);
+    jest.mocked(core.getState).mockImplementation(s => s);
+    jest.mocked(fs.existsSync).mockReturnValue(true);
+
+    await run();
+
+    expect(jest.mocked(core.setFailed)).not.toHaveBeenCalled();
+    expect(jest.mocked(core.getState)).toHaveBeenCalledTimes(2);
+    expect(jest.mocked(cache.saveCache)).toHaveBeenCalled();
+  });
+});

__tests__/cache-utils.test.ts

@@ -0,0 +1,122 @@
+import * as cache from '@actions/cache';
+import * as exec from '@actions/exec';
+
+import {getNuGetFolderPath, isCacheFeatureAvailable} from '../src/cache-utils';
+
+jest.mock('@actions/cache');
+jest.mock('@actions/core');
+jest.mock('@actions/exec');
+
+describe('cache-utils tests', () => {
+  describe('getNuGetFolderPath()', () => {
+    it.each([
+      [
+        `
+http-cache: /home/codespace/.local/share/NuGet/v3-cache
+global-packages: /var/nuget
+temp: /tmp/NuGetScratch
+plugins-cache: /home/codespace/.local/share/NuGet/plugins-cache
+`,
+        {
+          'http-cache': '/home/codespace/.local/share/NuGet/v3-cache',
+          'global-packages': '/var/nuget',
+          temp: '/tmp/NuGetScratch',
+          'plugins-cache': '/home/codespace/.local/share/NuGet/plugins-cache'
+        }
+      ],
+      [
+        `
+  http-cache: /home/codespace/.local/share/NuGet/v3-cache
+  global-packages: /var/nuget
+  temp: /tmp/NuGetScratch
+  plugins-cache: /home/codespace/.local/share/NuGet/plugins-cache
+`,
+        {
+          'http-cache': '/home/codespace/.local/share/NuGet/v3-cache',
+          'global-packages': '/var/nuget',
+          temp: '/tmp/NuGetScratch',
+          'plugins-cache': '/home/codespace/.local/share/NuGet/plugins-cache'
+        }
+      ],
+      [
+        `
+http-cache: C:\\Users\\user\\AppData\\Local\\NuGet\\v3-cache
+global-packages: C:\\Users\\user\\.nuget\\packages\\
+temp: C:\\Users\\user\\AppData\\Local\\Temp\\NuGetScratch
+plugins-cache: C:\\Users\\user\\AppData\\Local\\NuGet\\plugins-cache
+        `,
+        {
+          'http-cache': 'C:\\Users\\user\\AppData\\Local\\NuGet\\v3-cache',
+          'global-packages': 'C:\\Users\\user\\.nuget\\packages\\',
+          temp: 'C:\\Users\\user\\AppData\\Local\\Temp\\NuGetScratch',
+          'plugins-cache':
+            'C:\\Users\\user\\AppData\\Local\\NuGet\\plugins-cache'
+        }
+      ],
+      [
+        `
+  http-cache: C:\\Users\\user\\AppData\\Local\\NuGet\\v3-cache
+  global-packages: C:\\Users\\user\\.nuget\\packages\\
+  temp: C:\\Users\\user\\AppData\\Local\\Temp\\NuGetScratch
+  plugins-cache: C:\\Users\\user\\AppData\\Local\\NuGet\\plugins-cache
+        `,
+        {
+          'http-cache': 'C:\\Users\\user\\AppData\\Local\\NuGet\\v3-cache',
+          'global-packages': 'C:\\Users\\user\\.nuget\\packages\\',
+          temp: 'C:\\Users\\user\\AppData\\Local\\Temp\\NuGetScratch',
+          'plugins-cache':
+            'C:\\Users\\user\\AppData\\Local\\NuGet\\plugins-cache'
+        }
+      ]
+    ])('(stdout: "%s") returns %p', async (stdout, expected) => {
+      jest
+        .mocked(exec.getExecOutput)
+        .mockResolvedValue({stdout, stderr: '', exitCode: 0});
+      const pathes = await getNuGetFolderPath();
+      expect(pathes).toStrictEqual(expected);
+    });
+
+    it.each([
+      `
+error: An invalid local resource name was provided. Provide one of the following values: http-cache, temp, global-packages, all.
+Usage: dotnet nuget locals [arguments] [options]
+Arguments:
+  Cache Location(s)  Specifies the cache location(s) to list or clear.
+<all | http-cache | global-packages | temp>
+Options:
+  -h|--help               Show help information
+  --force-english-output  Forces the application to run using an invariant, English-based culture.
+  -c|--clear              Clear the selected local resources or cache location(s).
+  -l|--list               List the selected local resources or cache location(s).
+      `,
+      'bash: dotnet: command not found',
+      ''
+    ])('(stderr: "%s", exitCode: 1) throws Error', async stderr => {
+      jest
+        .mocked(exec.getExecOutput)
+        .mockResolvedValue({stdout: '', stderr, exitCode: 1});
+      await expect(getNuGetFolderPath()).rejects.toThrow();
+    });
+  });
+
+  describe.each(['', 'https://github.com/', 'https://example.com/'])(
+    'isCacheFeatureAvailable()',
+    url => {
+      // Save & Restore env
+      let serverUrlEnv: string | undefined;
+      beforeAll(() => (serverUrlEnv = process.env['GITHUB_SERVER_URL']));
+      beforeEach(() => (process.env['GITHUB_SERVER_URL'] = url));
+      afterEach(() => (process.env['GITHUB_SERVER_URL'] = serverUrlEnv));
+
+      it('returns true when cache.isFeatureAvailable() === true', () => {
+        jest.mocked(cache.isFeatureAvailable).mockReturnValue(true);
+        expect(isCacheFeatureAvailable()).toBe(true);
+      });
+
+      it('returns false when cache.isFeatureAvailable() === false', () => {
+        jest.mocked(cache.isFeatureAvailable).mockReturnValue(false);
+        expect(isCacheFeatureAvailable()).toBe(false);
+      });
+    }
+  );
+});

__tests__/e2e-test-csproj/test.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFramework>$(TEST_TARGET_FRAMEWORK)</TargetFramework>
     <IsPackable>false</IsPackable>
+    <DisableImplicitNuGetFallbackFolder>true</DisableImplicitNuGetFallbackFolder>
   </PropertyGroup>
 
   <ItemGroup>

__tests__/installer.test.ts

@@ -1,5 +1,7 @@
 import each from 'jest-each';
 import semver from 'semver';
+import fs from 'fs';
+import fspromises from 'fs/promises';
 import * as exec from '@actions/exec';
 import * as core from '@actions/core';
 import * as io from '@actions/io';
@@ -21,14 +23,25 @@ describe('installer tests', () => {
     const warningSpy = jest.spyOn(core, 'warning');
     const whichSpy = jest.spyOn(io, 'which');
     const maxSatisfyingSpy = jest.spyOn(semver, 'maxSatisfying');
+    const chmodSyncSpy = jest.spyOn(fs, 'chmodSync');
+    const readdirSpy = jest.spyOn(fspromises, 'readdir');
 
     describe('installDotnet() tests', () => {
-      whichSpy.mockImplementation(() => Promise.resolve('PathToShell'));
+      beforeAll(() => {
+        whichSpy.mockImplementation(() => Promise.resolve('PathToShell'));
+        chmodSyncSpy.mockImplementation(() => {});
+        readdirSpy.mockImplementation(() => Promise.resolve([]));
+      });
+
+      afterAll(() => {
+        jest.resetAllMocks();
+      });
 
       it('should throw the error in case of non-zero exit code of the installation script. The error message should contain logs.', async () => {
         const inputVersion = '3.1.100';
         const inputQuality = '' as QualityOptions;
         const errorMessage = 'fictitious error message!';
+
         getExecOutputSpy.mockImplementation(() => {
           return Promise.resolve({
             exitCode: 1,
@@ -36,6 +49,7 @@ describe('installer tests', () => {
             stderr: errorMessage
           });
         });
+
         const dotnetInstaller = new installer.DotnetCoreInstaller(
           inputVersion,
           inputQuality

__tests__/setup-dotnet.test.ts

@@ -5,12 +5,15 @@ import * as auth from '../src/authutil';
 
 import * as setup from '../src/setup-dotnet';
 import {DotnetCoreInstaller, DotnetInstallDir} from '../src/installer';
+import * as cacheUtils from '../src/cache-utils';
+import * as cacheRestore from '../src/cache-restore';
 
 describe('setup-dotnet tests', () => {
   const inputs = {} as any;
 
   const getInputSpy = jest.spyOn(core, 'getInput');
   const getMultilineInputSpy = jest.spyOn(core, 'getMultilineInput');
+  const getBooleanInputSpy = jest.spyOn(core, 'getBooleanInput');
   const setFailedSpy = jest.spyOn(core, 'setFailed');
   const warningSpy = jest.spyOn(core, 'warning');
   const debugSpy = jest.spyOn(core, 'debug');
@@ -26,6 +29,11 @@ describe('setup-dotnet tests', () => {
     'installDotnet'
   );
 
+  const isCacheFeatureAvailableSpy = jest.spyOn(
+    cacheUtils,
+    'isCacheFeatureAvailable'
+  );
+  const restoreCacheSpy = jest.spyOn(cacheRestore, 'restoreCache');
   const configAuthenticationSpy = jest.spyOn(auth, 'configAuthentication');
   const addToPathOriginal = DotnetInstallDir.addToPath;
 
@@ -34,6 +42,7 @@ describe('setup-dotnet tests', () => {
       DotnetInstallDir.addToPath = jest.fn();
       getMultilineInputSpy.mockImplementation(input => inputs[input as string]);
       getInputSpy.mockImplementation(input => inputs[input as string]);
+      getBooleanInputSpy.mockImplementation(input => inputs[input as string]);
     });
 
     afterEach(() => {
@@ -166,5 +175,51 @@ describe('setup-dotnet tests', () => {
       expect(infoSpy).toHaveBeenCalledWith(warningMessage);
       expect(setOutputSpy).not.toHaveBeenCalled();
     });
+
+    it(`should get 'cache-dependency-path' and call restoreCache() if input cache is set to true and cache feature is available`, async () => {
+      inputs['dotnet-version'] = ['6.0.300'];
+      inputs['dotnet-quality'] = '';
+      inputs['cache'] = true;
+      inputs['cache-dependency-path'] = 'fictitious.package.lock.json';
+
+      installDotnetSpy.mockImplementation(() => Promise.resolve(''));
+
+      isCacheFeatureAvailableSpy.mockImplementation(() => true);
+      restoreCacheSpy.mockImplementation(() => Promise.resolve());
+
+      await setup.run();
+      expect(isCacheFeatureAvailableSpy).toHaveBeenCalledTimes(1);
+      expect(restoreCacheSpy).toHaveBeenCalledWith(
+        inputs['cache-dependency-path']
+      );
+    });
+
+    it(`shouldn't call restoreCache() if input cache isn't set to true`, async () => {
+      inputs['dotnet-version'] = ['6.0.300'];
+      inputs['dotnet-quality'] = '';
+      inputs['cache'] = false;
+
+      installDotnetSpy.mockImplementation(() => Promise.resolve(''));
+
+      isCacheFeatureAvailableSpy.mockImplementation(() => true);
+      restoreCacheSpy.mockImplementation(() => Promise.resolve());
+
+      await setup.run();
+      expect(restoreCacheSpy).not.toHaveBeenCalled();
+    });
+
+    it(`shouldn't call restoreCache() if cache feature isn't available`, async () => {
+      inputs['dotnet-version'] = ['6.0.300'];
+      inputs['dotnet-quality'] = '';
+      inputs['cache'] = true;
+
+      installDotnetSpy.mockImplementation(() => Promise.resolve(''));
+
+      isCacheFeatureAvailableSpy.mockImplementation(() => false);
+      restoreCacheSpy.mockImplementation(() => Promise.resolve());
+
+      await setup.run();
+      expect(restoreCacheSpy).not.toHaveBeenCalled();
+    });
   });
 });

__tests__/verify-dotnet.ps1

@@ -114,4 +114,4 @@ foreach ($version in $Versions)
   Remove-Item ./global.json
 }
 
-Set-Location $workingDir
+Set-Location $workingDir