Add mirror-url parameter to allow downloading Node.js from a custom URL

__tests__/main.test.ts

@@ -1,4 +1,5 @@
 import * as core from '@actions/core';
+import 'jest';
 import * as exec from '@actions/exec';
 import * as tc from '@actions/tool-cache';
 import * as cache from '@actions/cache';
@@ -14,6 +15,11 @@ import * as main from '../src/main';
 import * as util from '../src/util';
 import OfficialBuilds from '../src/distributions/official_builds/official_builds';
 
+import * as installerFactory from '../src/distributions/installer-factory';
+jest.mock('../src/distributions/installer-factory', () => ({
+  getNodejsDistribution: jest.fn()
+}));
+
 describe('main tests', () => {
   let inputs = {} as any;
   let os = {} as any;
@@ -280,4 +286,93 @@ describe('main tests', () => {
       );
     });
   });
+
+  // Create a mock object that satisfies the BaseDistribution interface
+  const createMockNodejsDistribution = () => ({
+    setupNodeJs: jest.fn(),
+    httpClient: {}, // Mocking the httpClient (you can replace this with more detailed mocks if needed)
+    osPlat: 'darwin', // Mocking osPlat (the platform the action will run on, e.g., 'darwin', 'win32', 'linux')
+    nodeInfo: {
+      version: '14.x',
+      arch: 'x64',
+      platform: 'darwin'
+    },
+    getDistributionUrl: jest.fn().mockReturnValue('https://nodejs.org/dist/'), // Example URL
+    install: jest.fn(),
+    validate: jest.fn()
+    // Add any other methods/properties required by your BaseDistribution type
+  });
+
+  describe('Mirror URL Tests', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should pass mirror URL correctly when provided', async () => {
+      jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
+        if (name === 'mirror-url') return 'https://custom-mirror-url.com';
+        if (name === 'node-version') return '14.x';
+        return '';
+      });
+
+      const mockNodejsDistribution = createMockNodejsDistribution();
+      (installerFactory.getNodejsDistribution as jest.Mock).mockReturnValue(
+        mockNodejsDistribution
+      );
+
+      await main.run();
+
+      // Ensure setupNodeJs is called with the correct parameters, including the mirror URL
+      expect(mockNodejsDistribution.setupNodeJs).toHaveBeenCalledWith({
+        versionSpec: '14.x',
+        checkLatest: false,
+        auth: undefined,
+        stable: true,
+        arch: 'x64',
+        mirrorURL: 'https://custom-mirror-url.com' // Ensure this matches
+      });
+    });
+
+    it('should use default mirror URL when no mirror URL is provided', async () => {
+      jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
+        if (name === 'mirror-url') return ''; // Simulating no mirror URL provided
+        if (name === 'node-version') return '14.x';
+        return '';
+      });
+
+      const mockNodejsDistribution = createMockNodejsDistribution();
+      (installerFactory.getNodejsDistribution as jest.Mock).mockReturnValue(
+        mockNodejsDistribution
+      );
+
+      await main.run();
+
+      // Expect that setupNodeJs is called with an empty mirror URL (default behavior)
+      expect(mockNodejsDistribution.setupNodeJs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          mirrorURL: '' // Default URL is expected to be handled internally
+        })
+      );
+    });
+
+    it('should handle mirror URL with spaces correctly', async () => {
+      const mirrorURL = 'https://custom-mirror-url.com ';
+      const expectedTrimmedURL = 'https://custom-mirror-url.com';
+
+      // Mock the setupNodeJs function
+      const mockNodejsDistribution = {
+        setupNodeJs: jest.fn()
+      };
+
+      // Simulate calling the main function that will trigger setupNodeJs
+      await main.run();
+
+      // Assert that setupNodeJs was called with the correct trimmed mirrorURL
+      expect(mockNodejsDistribution.setupNodeJs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          mirrorURL: expectedTrimmedURL // Ensure the URL is trimmed properly
+        })
+      );
+    });
+  });
 });

__tests__/official-installer.test.ts

@@ -9,9 +9,10 @@ import cp from 'child_process';
 import osm from 'os';
 import path from 'path';
 import * as main from '../src/main';
+import isLtsAlias from '../src/distributions/official_builds/official_builds';
 import * as auth from '../src/authutil';
 import OfficialBuilds from '../src/distributions/official_builds/official_builds';
-import {INodeVersion} from '../src/distributions/base-models';
+import {INodeVersion, NodeInputs} from '../src/distributions/base-models';
 
 import nodeTestManifest from './data/versions-manifest.json';
 import nodeTestDist from './data/node-dist-index.json';
@@ -828,4 +829,99 @@ describe('setup-node', () => {
       }
     );
   });
+
+  describe('OfficialBuilds - Mirror URL functionality', () => {
+    let officialBuilds: OfficialBuilds;
+
+    beforeEach(() => {
+      const mockNodeInfo = {
+        versionSpec: '16.x',
+        mirrorURL: 'https://my.custom.mirror/nodejs',
+        arch: 'x64',
+        stable: true,
+        checkLatest: false,
+        osPlat: 'linux' // Mock OS platform to avoid "undefined" error
+      };
+    });
+
+    it('should download using the mirror URL when provided', async () => {
+      // Mock data for nodeInfo
+      const nodeInfo: NodeInputs = {
+        versionSpec: '8.0.0-canary',
+        arch: 'x64',
+        checkLatest: false,
+        stable: false,
+        mirrorURL: 'https://my.custom.mirror/nodejs' // Mirror URL provided here
+      };
+
+      // Mock the core.info function to capture logs
+      const logSpy = jest.spyOn(core, 'info').mockImplementation(() => {});
+
+      // Mock the tc.downloadTool to simulate downloading
+      const mockDownloadPath = '/some/temp/path';
+      const mockDownloadTool = jest
+        .spyOn(tc, 'downloadTool')
+        .mockResolvedValue(mockDownloadPath);
+
+      // Mock core.addPath to avoid actual path changes
+      const mockAddPath = jest
+        .spyOn(core, 'addPath')
+        .mockImplementation(() => {});
+
+      // Mock the findSpy or any other necessary logic
+      findSpy.mockImplementation(() => nodeInfo);
+
+      // Call the function that will use the mirror URL and log the message
+      await main.run();
+
+      // Ensure downloadTool was called with the mirror URL
+      expect(mockDownloadTool).toHaveBeenCalledWith(
+        'https://my.custom.mirror/nodejs'
+      );
+
+      // Optionally, check that the download path was logged
+      expect(core.info).toHaveBeenCalledWith(
+        'downloadPath from downloadFromMirrorURL() /some/temp/path'
+      );
+
+      // Ensure the download path was added to the path
+      expect(mockAddPath).toHaveBeenCalledWith(mockDownloadPath);
+      expect(cnSpy).toHaveBeenCalledWith('https://my.custom.mirror/nodejs');
+    });
+
+    it('should log an error and handle failure during mirror URL download', async () => {
+      const errorMessage = 'Network error';
+
+      try {
+        // Act: Run the main function
+        await main.run();
+      } catch (error) {
+        // Expect core.error to be called with the error message
+        expect(core.error).toHaveBeenCalledWith(errorMessage);
+        expect(core.debug).toHaveBeenCalledWith(
+          expect.stringContaining('empty stack')
+        );
+      }
+    });
+
+    it('should log an error message if downloading from the mirror URL fails', async () => {
+      // Spy on core.setFailed
+      const setFailedSpy = jest
+        .spyOn(core, 'setFailed')
+        .mockImplementation(() => {});
+
+      // Mocking downloadFromMirrorURL to reject the promise and simulate a failure
+      dlSpy.mockImplementation(() =>
+        Promise.reject(new Error('Download failed'))
+      );
+
+      try {
+        // Call the function with the mirror URL
+        await main.run();
+      } catch (e) {
+        // Verifying if core.setFailed was called with the error message 'Download failed'
+        expect(setFailedSpy).toHaveBeenCalledWith('Download failed');
+      }
+    });
+  });
 });