feat: added optional visual studio components option

Author: soumyamahunt

.github/workflows/main.yml

@@ -248,7 +248,7 @@ jobs:
       uses: addnab/docker-run-action@v3
       with:
         image: swift:${{ fromJSON(steps.setup-swift.outputs.toolchain).docker }}
-        run: swift --version  | grep ${{ steps.setup-swift.outputs.swift-version }} || exit 1
+        run: swift --version | grep ${{ steps.setup-swift.outputs.swift-version }} || exit 1
 
   dependabot:
     name: Check dependabot PR raised updating swiftorg

__tests__/installer/windows.test.ts

@@ -7,7 +7,7 @@ import * as cache from '@actions/cache'
 import * as toolCache from '@actions/tool-cache'
 import {coerce as parseSemVer} from 'semver'
 import {WindowsToolchainInstaller} from '../../src/installer/windows'
-import * as vs from '../../src/utils/visual_studio'
+import {VisualStudio} from '../../src/utils/visual_studio'
 
 describe('windows toolchain installation verification', () => {
   const env = process.env
@@ -21,14 +21,14 @@ describe('windows toolchain installation verification', () => {
     branch: 'swift-5.8-release',
     windows: true
   }
-  const visualStudio: vs.VisualStudio = {
+  const visualStudio = VisualStudio.createFromJSON({
     installationPath: path.join('C:', 'Visual Studio'),
     installationVersion: '16',
     catalog: {productDisplayVersion: '16'},
     properties: {
       setupEngineFilePath: path.join('C:', 'Visual Studio', 'setup.exe')
     }
-  }
+  })
   const vsEnvs = [
     `UniversalCRTSdkDir=${path.join('C:', 'Windows Kits')}`,
     `UCRTVersion=10.0.17063`,
@@ -44,6 +44,20 @@ describe('windows toolchain installation verification', () => {
     process.env = env
   })
 
+  it('tests adding additional components', async () => {
+    jest
+      .spyOn(core, 'getInput')
+      .mockReturnValue(
+        'Microsoft.VisualStudio.Component.VC.ATL;Microsoft.VisualStudio.Component.VC.CMake.Project;Microsoft.VisualStudio.Component.Windows10SDK'
+      )
+    const installer = new WindowsToolchainInstaller(toolchain)
+    expect(installer['vsRequirement'].components.slice(2)).toStrictEqual([
+      'Microsoft.VisualStudio.Component.VC.ATL',
+      'Microsoft.VisualStudio.Component.VC.CMake.Project',
+      'Microsoft.VisualStudio.Component.Windows10SDK'
+    ])
+  })
+
   it('tests download with caching', async () => {
     const installer = new WindowsToolchainInstaller(toolchain)
     expect(installer['version']).toStrictEqual(parseSemVer('5.8'))
@@ -130,7 +144,7 @@ describe('windows toolchain installation verification', () => {
   it('tests add to PATH', async () => {
     const installer = new WindowsToolchainInstaller(toolchain)
     const installation = path.resolve('tool', 'installed', 'path')
-    jest.spyOn(vs, 'setupVisualStudioTools').mockResolvedValue(visualStudio)
+    jest.spyOn(VisualStudio, 'setup').mockResolvedValue(visualStudio)
     jest.spyOn(fs, 'access').mockRejectedValue(new Error())
     jest.spyOn(fs, 'copyFile').mockResolvedValue()
     jest.spyOn(exec, 'exec').mockResolvedValue(0)
@@ -186,7 +200,7 @@ describe('windows toolchain installation verification', () => {
     const swiftDev = path.join(cached, 'Swift-development', 'bin')
     const icu67 = path.join(cached, 'icu-67', 'usr', 'bin')
     const setupSpy = jest
-      .spyOn(vs, 'setupVisualStudioTools')
+      .spyOn(VisualStudio, 'setup')
       .mockResolvedValue(visualStudio)
     jest.spyOn(fs, 'access').mockRejectedValue(new Error())
     jest.spyOn(fs, 'copyFile').mockResolvedValue()

__tests__/main.test.ts

@@ -0,0 +1,88 @@
+import * as core from '@actions/core'
+import * as main from '../src/main'
+import {Swiftorg} from '../src/swiftorg'
+import {Platform} from '../src/platform'
+import {LinuxToolchainInstaller} from '../src/installer'
+
+describe('setup-swift run validation', () => {
+  const swiftorgSpy = jest
+    .spyOn(Swiftorg.prototype, 'update')
+    .mockResolvedValue()
+  const toolchainSpy = jest.spyOn(Platform, 'toolchain')
+  const installSpy = jest.spyOn(Platform, 'install')
+  const outputSpy = jest.spyOn(core, 'setOutput')
+  const failedSpy = jest.spyOn(core, 'setFailed')
+  const toolchain = {
+    name: 'Ubuntu 22.04',
+    date: new Date('2023-03-30 10:28:49.000000000 -05:00'),
+    download: 'swift-5.8-RELEASE-ubuntu22.04.tar.gz',
+    download_signature: 'swift-5.8-RELEASE-ubuntu22.04.tar.gz.sig',
+    dir: 'swift-5.8-RELEASE',
+    docker: '5.8-jammy',
+    platform: 'ubuntu2204',
+    branch: 'swift-5.8-release'
+  }
+
+  it('tests dry run', async () => {
+    toolchainSpy.mockResolvedValue(toolchain)
+    jest.spyOn(core, 'getBooleanInput').mockReturnValue(true)
+    jest.spyOn(core, 'getInput').mockReturnValue('latest')
+    await main.run()
+    expect(failedSpy).not.toHaveBeenCalled()
+    expect(installSpy).not.toHaveBeenCalled()
+    for (const spy of [swiftorgSpy, toolchainSpy, outputSpy]) {
+      expect(spy).toHaveBeenCalled()
+    }
+    for (const call of outputSpy.mock.calls) {
+      switch (call[0]) {
+        case 'swift-version':
+          expect(call.slice(1)).toStrictEqual(['5.8'])
+          break
+        case 'toolchain': {
+          const obj = JSON.parse(call[1])
+          obj.date = new Date(obj.date)
+          expect(obj).toStrictEqual(toolchain)
+          break
+        }
+      }
+    }
+  })
+
+  it('tests install', async () => {
+    const installer = new LinuxToolchainInstaller(toolchain)
+    installSpy.mockResolvedValue(installer)
+    jest.spyOn(core, 'getBooleanInput').mockReturnValue(false)
+    jest.spyOn(core, 'getInput').mockReturnValue('latest')
+    jest.spyOn(installer, 'installedSwiftVersion').mockResolvedValue('5.8')
+    await main.run()
+    expect(failedSpy).not.toHaveBeenCalled()
+    expect(toolchainSpy).not.toHaveBeenCalled()
+    for (const spy of [swiftorgSpy, installSpy, outputSpy]) {
+      expect(spy).toHaveBeenCalled()
+    }
+    for (const call of outputSpy.mock.calls) {
+      switch (call[0]) {
+        case 'swift-version':
+          expect(call.slice(1)).toStrictEqual(['5.8'])
+          break
+        case 'toolchain': {
+          const obj = JSON.parse(call[1])
+          obj.date = new Date(obj.date)
+          expect(obj).toStrictEqual(toolchain)
+          break
+        }
+      }
+    }
+  })
+
+  it('tests failure', async () => {
+    toolchainSpy.mockResolvedValue(undefined)
+    jest.spyOn(core, 'getBooleanInput').mockReturnValue(true)
+    jest.spyOn(core, 'getInput').mockReturnValue('latest')
+    await main.run()
+    expect(failedSpy).toHaveBeenCalled()
+    for (const spy of [installSpy, outputSpy]) {
+      expect(spy).not.toHaveBeenCalled()
+    }
+  })
+})

__tests__/swiftorg.test.ts

@@ -5,13 +5,9 @@ import {MODULE_DIR} from '../src/const'
 
 describe('swiftorg sync validation', () => {
   const accessSpy = jest.spyOn(fs, 'access')
-  const rmdirSpy = jest.spyOn(fs, 'rmdir')
+  const rmdirSpy = jest.spyOn(fs, 'rmdir').mockResolvedValue()
   const execSpy = jest.spyOn(exec, 'exec')
 
-  beforeEach(() => {
-    rmdirSpy.mockResolvedValue()
-  })
-
   it('tests latest sync', async () => {
     accessSpy.mockResolvedValue()
     execSpy.mockResolvedValue(0)

__tests__/utils/visual_studio.test.ts

@@ -0,0 +1,57 @@
+import * as path from 'path'
+import {promises as fs} from 'fs'
+import * as exec from '@actions/exec'
+import {VisualStudio} from '../../../src/utils/visual_studio'
+
+describe('visual studio setup validation', () => {
+  const env = process.env
+  const visualStudio = VisualStudio.createFromJSON({
+    installationPath: path.join('C:', 'Visual Studio'),
+    installationVersion: '16',
+    catalog: {productDisplayVersion: '16'},
+    properties: {
+      setupEngineFilePath: path.join('C:', 'Visual Studio', 'setup.exe')
+    }
+  })
+
+  beforeEach(() => {
+    process.env = {...env}
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    process.env = env
+  })
+
+  it('tests visual studio setup fails when invalid path', async () => {
+    process.env.VSWHERE_PATH = path.join('C:', 'Visual Studio')
+    jest.spyOn(fs, 'access').mockResolvedValue()
+    jest.spyOn(exec, 'exec').mockResolvedValue(-1)
+    jest.spyOn(exec, 'getExecOutput').mockResolvedValue({
+      exitCode: 0,
+      stdout: JSON.stringify([{...visualStudio, installationPath: ''}]),
+      stderr: ''
+    })
+    await expect(
+      VisualStudio.setup({version: '16', components: ['Component']})
+    ).rejects.toMatchObject(
+      new Error(
+        `Unable to find any Visual Studio installation for version: 16.`
+      )
+    )
+  })
+
+  it('tests visual studio setup successfully', async () => {
+    process.env.VSWHERE_PATH = path.join('C:', 'Visual Studio')
+    jest.spyOn(fs, 'access').mockResolvedValue()
+    jest.spyOn(exec, 'exec').mockResolvedValue(0)
+    jest.spyOn(exec, 'getExecOutput').mockResolvedValue({
+      exitCode: 0,
+      stdout: JSON.stringify([visualStudio]),
+      stderr: ''
+    })
+    await expect(
+      VisualStudio.setup({version: '16', components: ['Component']})
+    ).resolves.toMatchObject(visualStudio)
+  })
+})

__tests__/utils/visual_studio/setup.test.ts

@@ -0,0 +1,51 @@
+import * as path from 'path'
+import {promises as fs} from 'fs'
+import * as io from '@actions/io'
+import {VSWhere} from '../../../src/utils/visual_studio/vswhere'
+
+describe('vswhere find validation', () => {
+  const env = process.env
+
+  beforeEach(() => {
+    process.env = {...env}
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    process.env = env
+  })
+
+  it('tests vswhere path from environment variable', async () => {
+    jest.spyOn(fs, 'access').mockResolvedValue()
+    const vswhereExe = path.join('C:', 'Visual Studio', 'vswhere.exe')
+    process.env.VSWHERE_PATH = path.join('C:', 'Visual Studio')
+    expect(await VSWhere.get()).toBe(vswhereExe)
+  })
+
+  it('tests vswhere path from @actions/io', async () => {
+    jest.spyOn(fs, 'access').mockResolvedValue()
+    const vswhereExe = path.join('C:', 'Visual Studio', 'vswhere.exe')
+    jest.spyOn(io, 'which').mockResolvedValue(vswhereExe)
+    expect(await VSWhere.get()).toBe(vswhereExe)
+  })
+
+  it('tests fallback vswhere path', async () => {
+    jest.spyOn(fs, 'access').mockResolvedValue()
+    const vswhereExe = path.join(
+      'C:',
+      'Program Files (x86)',
+      'Microsoft Visual Studio',
+      'Installer',
+      'vswhere.exe'
+    )
+    process.env['ProgramFiles(x86)'] = path.join('C:', 'Program Files (x86)')
+    expect(await VSWhere.get()).toBe(vswhereExe)
+  })
+
+  it('tests vswhere missing', async () => {
+    jest.spyOn(fs, 'access').mockRejectedValue(new Error())
+    await expect(VSWhere.get()).rejects.toMatchObject(
+      new Error('Missing vswhere.exe, needed Visual Studio installation')
+    )
+  })
+})