Migrate to esbuild/Vitest and upgrade @actions/* to ESM-only versions (#492)

* Migrate build toolchain from ncc/Jest to esbuild/Vitest

Replace the legacy ncc/Jest/Babel build stack with a modern ESM toolchain:

Build:
- Replace @vercel/ncc with esbuild (--platform=node --target=node20 --format=esm)
- Add createRequire banner for CJS interop in ESM bundle
- Add "type": "module" to package.json
- Add tsc --noEmit typecheck script (esbuild strips types without checking)
- Add typecheck to husky pre-commit hook

Dependencies:
- Bump @actions/core@3, exec@3, io@3, tool-cache@4 (ESM-only)
- Replace jest/ts-jest/@babel/* with vitest@4

Tests:
- Convert 29 test files: jest.fn()→vi.fn(), jest.mock()→vi.mock(), jest.spyOn()→vi.spyOn()
- Fix vitest 4 compat: mockImplementation requires args, mock call tracking, await .rejects

CI:
- Update build step from ncc build → npm run build
- Update composite action to use npm run build

* Switch tsconfig to NodeNext module resolution

Change module/moduleResolution from ES2022/bundler to NodeNext/NodeNext
and target from ES2022 to ES2020.

- Add .js extensions to all relative imports across 59 source/test files
  (required by NodeNext module resolution)
- Add vitest/globals to tsconfig types array for global test API declarations

src/strategyHelpers/blueGreen/blueGreenHelper.test.ts

@@ -1,3 +1,5 @@
+import {vi} from 'vitest'
+import type {MockInstance} from 'vitest'
 import {
    deployWithLabel,
    deleteGreenObjects,
@@ -8,16 +10,16 @@ import {
    getNewBlueGreenObject,
    GREEN_LABEL_VALUE,
    isServiceRouted
-} from './blueGreenHelper'
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
-import * as bgHelper from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-import {K8sObject} from '../../types/k8sObject'
-import * as manifestUpdateUtils from '../../utilities/manifestUpdateUtils'
+} from './blueGreenHelper.js'
+import {BlueGreenDeployment} from '../../types/blueGreenTypes.js'
+import * as bgHelper from './blueGreenHelper.js'
+import {Kubectl} from '../../types/kubectl.js'
+import * as fileHelper from '../../utilities/fileUtils.js'
+import {K8sObject} from '../../types/k8sObject.js'
+import * as manifestUpdateUtils from '../../utilities/manifestUpdateUtils.js'
 import {ExecOutput} from '@actions/exec'
 
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 
 const kubectl = new Kubectl('')
 const TEST_TIMEOUT = '60s'
@@ -37,17 +39,17 @@ const MOCK_EXEC_OUTPUT = {
 describe('bluegreenhelper functions', () => {
    let testObjects
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.restoreAllMocks()
+      vi.mocked(Kubectl).mockClear()
       testObjects = getManifestObjects(['test/unit/manifests/test-ingress.yml'])
 
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
+      vi.spyOn(fileHelper, 'writeObjectsToFile').mockImplementationOnce(() => [
+         ''
+      ])
    })
 
    test('correctly deletes services and workloads according to label', async () => {
-      jest.spyOn(bgHelper, 'deleteObjects').mockReturnValue({} as Promise<void>)
+      vi.spyOn(bgHelper, 'deleteObjects').mockReturnValue({} as Promise<void>)
 
       const value = await deleteGreenObjects(
          kubectl,
@@ -65,21 +67,16 @@ describe('bluegreenhelper functions', () => {
    })
 
    test('handles timeout when deleting objects', async () => {
-      // Mock deleteObjects to prevent actual execution
-      const deleteSpy = jest
-         .spyOn(kubectl, 'delete')
-         .mockResolvedValue(MOCK_EXEC_OUTPUT)
+      const deleteMock = vi.fn().mockResolvedValue(MOCK_EXEC_OUTPUT)
+      kubectl.delete = deleteMock
 
-      await bgHelper.deleteObjects(
-         kubectl,
-         EXPECTED_GREEN_OBJECTS,
-         TEST_TIMEOUT
-      )
+      const deleteList = EXPECTED_GREEN_OBJECTS
 
-      // Verify kubectl.delete is called with timeout for each object in deleteList
-      expect(deleteSpy).toHaveBeenCalledTimes(EXPECTED_GREEN_OBJECTS.length)
-      EXPECTED_GREEN_OBJECTS.forEach(({name, kind}) => {
-         expect(deleteSpy).toHaveBeenCalledWith(
+      await bgHelper.deleteObjects(kubectl, deleteList, TEST_TIMEOUT)
+
+      expect(deleteMock).toHaveBeenCalledTimes(deleteList.length)
+      deleteList.forEach(({name, kind}) => {
+         expect(deleteMock).toHaveBeenCalledWith(
             [kind, name],
             undefined,
             TEST_TIMEOUT
@@ -135,7 +132,7 @@ describe('bluegreenhelper functions', () => {
    })
 
    test('correctly makes labeled workloads', async () => {
-      const kubectlApplySpy = jest.spyOn(kubectl, 'apply').mockResolvedValue({
+      const kubectlApplySpy = vi.spyOn(kubectl, 'apply').mockResolvedValue({
          stdout: 'deployment.apps/nginx-deployment created',
          stderr: '',
          exitCode: 0
@@ -179,9 +176,9 @@ describe('bluegreenhelper functions', () => {
          exitCode: 0
       }
 
-      jest
-         .spyOn(kubectl, 'getResource')
-         .mockImplementation(() => Promise.resolve(mockExecOutput))
+      vi.spyOn(kubectl, 'getResource').mockImplementation(() =>
+         Promise.resolve(mockExecOutput)
+      )
       const fetched = await fetchResource(
          kubectl,
          'nginx-deployment',
@@ -209,12 +206,12 @@ describe('bluegreenhelper functions', () => {
       ]
 
       for (const testCase of errorTestCases) {
-         const spy = jest.spyOn(kubectl, 'getResource')
+         const spy = vi.spyOn(kubectl, 'getResource')
 
          if (testCase.mockOutput) {
             spy.mockImplementation(() => Promise.resolve(testCase.mockOutput))
          } else {
-            spy.mockImplementation()
+            spy.mockResolvedValue(null)
          }
 
          const fetched = await fetchResource(
@@ -235,12 +232,13 @@ describe('bluegreenhelper functions', () => {
          stderr: ''
       } as ExecOutput
 
-      jest.spyOn(kubectl, 'getResource').mockResolvedValue(mockExecOutput)
-      jest
-         .spyOn(manifestUpdateUtils, 'UnsetClusterSpecificDetails')
-         .mockImplementation(() => {
-            throw new Error('test error')
-         })
+      vi.spyOn(kubectl, 'getResource').mockResolvedValue(mockExecOutput)
+      vi.spyOn(
+         manifestUpdateUtils,
+         'UnsetClusterSpecificDetails'
+      ).mockImplementation(() => {
+         throw new Error('test error')
+      })
 
       expect(
          await fetchResource(kubectl, 'nginx-deployment', 'Deployment')
@@ -267,7 +265,7 @@ describe('bluegreenhelper functions', () => {
 
    describe('deployObjects', () => {
       let mockObjects: any[]
-      let kubectlApplySpy: jest.SpyInstance
+      let kubectlApplySpy: MockInstance
 
       const mockSuccessResult: ExecOutput = {
          stdout: 'deployment.apps/nginx-deployment created',
@@ -285,11 +283,11 @@ describe('bluegreenhelper functions', () => {
          // //@ts-ignore
          // Kubectl.mockClear()
          mockObjects = [testObjects.deploymentEntityList[0]]
-         kubectlApplySpy = jest.spyOn(kubectl, 'apply')
+         kubectlApplySpy = vi.spyOn(kubectl, 'apply')
       })
 
       afterEach(() => {
-         jest.clearAllMocks()
+         vi.clearAllMocks()
       })
 
       it('should return execution result and manifest files when kubectl apply succeeds', async () => {

src/strategyHelpers/blueGreen/blueGreenHelper.ts

@@ -2,27 +2,27 @@ import * as core from '@actions/core'
 import * as fs from 'fs'
 import * as yaml from 'js-yaml'
 
-import {DeployResult} from '../../types/deployResult'
-import {K8sObject, K8sDeleteObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
+import {DeployResult} from '../../types/deployResult.js'
+import {K8sObject, K8sDeleteObject} from '../../types/k8sObject.js'
+import {Kubectl} from '../../types/kubectl.js'
 import {
    isDeploymentEntity,
    isIngressEntity,
    isServiceEntity,
    KubernetesWorkload
-} from '../../types/kubernetesTypes'
+} from '../../types/kubernetesTypes.js'
 import {
    BlueGreenDeployment,
    BlueGreenManifests
-} from '../../types/blueGreenTypes'
-import * as fileHelper from '../../utilities/fileUtils'
-import {updateSpecLabels} from '../../utilities/manifestSpecLabelUtils'
-import {checkForErrors} from '../../utilities/kubectlUtils'
+} from '../../types/blueGreenTypes.js'
+import * as fileHelper from '../../utilities/fileUtils.js'
+import {updateSpecLabels} from '../../utilities/manifestSpecLabelUtils.js'
+import {checkForErrors} from '../../utilities/kubectlUtils.js'
 import {
    UnsetClusterSpecificDetails,
    updateObjectLabels,
    updateSelectorLabels
-} from '../../utilities/manifestUpdateUtils'
+} from '../../utilities/manifestUpdateUtils.js'
 
 export const GREEN_LABEL_VALUE = 'green'
 export const NONE_LABEL_VALUE = 'None'

src/strategyHelpers/blueGreen/deploy.test.ts

@@ -1,21 +1,23 @@
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
+import {vi} from 'vitest'
+import type {MockInstance} from 'vitest'
+import {BlueGreenDeployment} from '../../types/blueGreenTypes.js'
 import {
    deployBlueGreen,
    deployBlueGreenIngress,
    deployBlueGreenService,
    deployBlueGreenSMI
-} from './deploy'
-import * as routeTester from './route'
-import {Kubectl} from '../../types/kubectl'
-import {RouteStrategy} from '../../types/routeStrategy'
-import * as TSutils from '../../utilities/trafficSplitUtils'
-import * as bgHelper from './blueGreenHelper'
-import * as smiHelper from './smiBlueGreenHelper'
+} from './deploy.js'
+import * as routeTester from './route.js'
+import {Kubectl} from '../../types/kubectl.js'
+import {RouteStrategy} from '../../types/routeStrategy.js'
+import * as TSutils from '../../utilities/trafficSplitUtils.js'
+import * as bgHelper from './blueGreenHelper.js'
+import * as smiHelper from './smiBlueGreenHelper.js'
 import {ExecOutput} from '@actions/exec'
 
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
 
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 
 // Shared variables and mock objects used across all test suites
 const mockDeployResult = {
@@ -30,7 +32,7 @@ const mockBgDeployment: BlueGreenDeployment = {
 
 describe('deploy tests', () => {
    let kubectl: Kubectl
-   let kubectlApplySpy: jest.SpyInstance
+   let kubectlApplySpy: MockInstance
 
    const mockSuccessResult: ExecOutput = {
       stdout: 'deployment.apps/nginx-deployment created',
@@ -45,21 +47,20 @@ describe('deploy tests', () => {
    }
 
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       kubectl = new Kubectl('')
-      kubectlApplySpy = jest.spyOn(kubectl, 'apply')
+      kubectlApplySpy = vi.spyOn(kubectl, 'apply')
    })
 
    test('correctly determines deploy type and acts accordingly', async () => {
       kubectlApplySpy.mockResolvedValue(mockSuccessResult)
 
-      jest
-         .spyOn(routeTester, 'routeBlueGreenForDeploy')
-         .mockImplementation(() => Promise.resolve(mockBgDeployment))
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve('v1alpha3'))
+      vi.spyOn(routeTester, 'routeBlueGreenForDeploy').mockImplementation(() =>
+         Promise.resolve(mockBgDeployment)
+      )
+      vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(() =>
+         Promise.resolve('v1alpha3')
+      )
 
       const ingressResult = await deployBlueGreen(
          kubectl,
@@ -112,12 +113,12 @@ describe('deploy tests', () => {
          fn: () =>
             deployBlueGreen(kubectl, ingressFilepath, RouteStrategy.INGRESS),
          setup: () => {
-            jest
-               .spyOn(routeTester, 'routeBlueGreenForDeploy')
-               .mockImplementation(() => Promise.resolve(mockBgDeployment))
-            jest
-               .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-               .mockImplementation(() => Promise.resolve('v1alpha3'))
+            vi.spyOn(routeTester, 'routeBlueGreenForDeploy').mockImplementation(
+               () => Promise.resolve(mockBgDeployment)
+            )
+            vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(
+               () => Promise.resolve('v1alpha3')
+            )
          }
       },
       {
@@ -125,24 +126,24 @@ describe('deploy tests', () => {
          fn: () =>
             deployBlueGreen(kubectl, ingressFilepath, RouteStrategy.SERVICE),
          setup: () => {
-            jest
-               .spyOn(routeTester, 'routeBlueGreenForDeploy')
-               .mockImplementation(() => Promise.resolve(mockBgDeployment))
-            jest
-               .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-               .mockImplementation(() => Promise.resolve('v1alpha3'))
+            vi.spyOn(routeTester, 'routeBlueGreenForDeploy').mockImplementation(
+               () => Promise.resolve(mockBgDeployment)
+            )
+            vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(
+               () => Promise.resolve('v1alpha3')
+            )
          }
       },
       {
          name: 'should throw error when kubectl apply fails during blue/green deployment with SMI strategy',
          fn: () => deployBlueGreen(kubectl, ingressFilepath, RouteStrategy.SMI),
          setup: () => {
-            jest
-               .spyOn(routeTester, 'routeBlueGreenForDeploy')
-               .mockImplementation(() => Promise.resolve(mockBgDeployment))
-            jest
-               .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-               .mockImplementation(() => Promise.resolve('v1alpha3'))
+            vi.spyOn(routeTester, 'routeBlueGreenForDeploy').mockImplementation(
+               () => Promise.resolve(mockBgDeployment)
+            )
+            vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(
+               () => Promise.resolve('v1alpha3')
+            )
          }
       },
       {
@@ -181,8 +182,7 @@ describe('deploy timeout tests', () => {
    let kubectl: Kubectl
 
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       kubectl = new Kubectl('')
    })
 
@@ -190,16 +190,16 @@ describe('deploy timeout tests', () => {
       const timeout = '300s'
 
       // Mock the helper functions that are actually called
-      const deployWithLabelSpy = jest
+      const deployWithLabelSpy = vi
          .spyOn(bgHelper, 'deployWithLabel')
          .mockResolvedValue(mockBgDeployment)
-      const deployObjectsSpy = jest
+      const deployObjectsSpy = vi
          .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue(mockDeployResult)
-      const setupSMISpy = jest
+      const setupSMISpy = vi
          .spyOn(smiHelper, 'setupSMI')
          .mockResolvedValue(mockBgDeployment)
-      const routeSpy = jest
+      const routeSpy = vi
          .spyOn(routeTester, 'routeBlueGreenForDeploy')
          .mockResolvedValue(mockBgDeployment)
 
@@ -258,10 +258,10 @@ describe('deploy timeout tests', () => {
       const timeout = '240s'
 
       // Mock the dependencies
-      const deployWithLabelSpy = jest
+      const deployWithLabelSpy = vi
          .spyOn(bgHelper, 'deployWithLabel')
          .mockResolvedValue(mockBgDeployment)
-      const deployObjectsSpy = jest
+      const deployObjectsSpy = vi
          .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue(mockDeployResult)
 
@@ -290,10 +290,10 @@ describe('deploy timeout tests', () => {
       const timeout = '180s'
 
       // Mock the dependencies
-      const deployWithLabelSpy = jest
+      const deployWithLabelSpy = vi
          .spyOn(bgHelper, 'deployWithLabel')
          .mockResolvedValue(mockBgDeployment)
-      const deployObjectsSpy = jest
+      const deployObjectsSpy = vi
          .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue(mockDeployResult)
 
@@ -322,13 +322,13 @@ describe('deploy timeout tests', () => {
       const timeout = '360s'
 
       // Mock the dependencies
-      const setupSMISpy = jest
+      const setupSMISpy = vi
          .spyOn(smiHelper, 'setupSMI')
          .mockResolvedValue(mockBgDeployment)
-      const deployObjectsSpy = jest
+      const deployObjectsSpy = vi
          .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue(mockDeployResult)
-      const deployWithLabelSpy = jest
+      const deployWithLabelSpy = vi
          .spyOn(bgHelper, 'deployWithLabel')
          .mockResolvedValue(mockBgDeployment)
 
@@ -354,10 +354,10 @@ describe('deploy timeout tests', () => {
    })
 
    test('deploy functions without timeout should pass undefined', async () => {
-      const deployWithLabelSpy = jest
+      const deployWithLabelSpy = vi
          .spyOn(bgHelper, 'deployWithLabel')
          .mockResolvedValue(mockBgDeployment)
-      const deployObjectsSpy = jest
+      const deployObjectsSpy = vi
          .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue(mockDeployResult)
 

src/strategyHelpers/blueGreen/deploy.ts

@@ -1,23 +1,23 @@
 import * as core from '@actions/core'
 
-import {Kubectl} from '../../types/kubectl'
+import {Kubectl} from '../../types/kubectl.js'
 import {
    BlueGreenDeployment,
    BlueGreenManifests
-} from '../../types/blueGreenTypes'
+} from '../../types/blueGreenTypes.js'
 
-import {RouteStrategy} from '../../types/routeStrategy'
+import {RouteStrategy} from '../../types/routeStrategy.js'
 
 import {
    deployWithLabel,
    getManifestObjects,
    GREEN_LABEL_VALUE,
    deployObjects
-} from './blueGreenHelper'
-import {setupSMI} from './smiBlueGreenHelper'
+} from './blueGreenHelper.js'
+import {setupSMI} from './smiBlueGreenHelper.js'
 
-import {routeBlueGreenForDeploy} from './route'
-import {DeployResult} from '../../types/deployResult'
+import {routeBlueGreenForDeploy} from './route.js'
+import {DeployResult} from '../../types/deployResult.js'
 
 export async function deployBlueGreen(
    kubectl: Kubectl,

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.test.ts

@@ -1,27 +1,27 @@
-import {getManifestObjects, GREEN_LABEL_VALUE} from './blueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
+import {vi} from 'vitest'
+import {getManifestObjects, GREEN_LABEL_VALUE} from './blueGreenHelper.js'
+import * as bgHelper from './blueGreenHelper.js'
 import {
    getUpdatedBlueGreenIngress,
    isIngressRouted,
    validateIngresses
-} from './ingressBlueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
+} from './ingressBlueGreenHelper.js'
+import {Kubectl} from '../../types/kubectl.js'
+import * as fileHelper from '../../utilities/fileUtils.js'
 
 const betaFilepath = ['test/unit/manifests/test-ingress.yml']
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
 const kubectl = new Kubectl('')
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 
 describe('ingress blue green helpers', () => {
    let testObjects
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       testObjects = getManifestObjects(ingressFilepath)
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
+      vi.spyOn(fileHelper, 'writeObjectsToFile').mockImplementationOnce(() => [
+         ''
+      ])
    })
 
    test('it should correctly classify ingresses', () => {
@@ -72,7 +72,7 @@ describe('ingress blue green helpers', () => {
 
    test('it should validate ingresses', async () => {
       // what if nothing gets returned from fetchResource?
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation()
+      vi.spyOn(bgHelper, 'fetchResource').mockResolvedValue(null)
       let validResponse = await validateIngresses(
          kubectl,
          testObjects.ingressEntityList,
@@ -89,9 +89,9 @@ describe('ingress blue green helpers', () => {
       const mockLabels = new Map<string, string>()
       mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = GREEN_LABEL_VALUE
       mockIngress.metadata.labels = mockLabels
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockIngress))
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+         Promise.resolve(mockIngress)
+      )
       validResponse = await validateIngresses(
          kubectl,
          testObjects.ingressEntityList,

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.ts

@@ -1,12 +1,12 @@
 import * as core from '@actions/core'
-import {K8sIngress} from '../../types/k8sObject'
+import {K8sIngress} from '../../types/k8sObject.js'
 import {
    addBlueGreenLabelsAndAnnotations,
    BLUE_GREEN_VERSION_LABEL,
    GREEN_LABEL_VALUE,
    fetchResource
-} from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
+} from './blueGreenHelper.js'
+import {Kubectl} from '../../types/kubectl.js'
 
 const BACKEND = 'backend'
 

src/strategyHelpers/blueGreen/promote.test.ts

@@ -1,20 +1,22 @@
-import {getManifestObjects} from './blueGreenHelper'
+import {vi} from 'vitest'
+import type {MockInstance} from 'vitest'
+import {getManifestObjects} from './blueGreenHelper.js'
 import {
    promoteBlueGreenIngress,
    promoteBlueGreenService,
    promoteBlueGreenSMI
-} from './promote'
-import {TrafficSplitObject} from '../../types/k8sObject'
-import * as servicesTester from './serviceBlueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import {MAX_VAL, MIN_VAL, TRAFFIC_SPLIT_OBJECT} from './smiBlueGreenHelper'
-import * as smiTester from './smiBlueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
+} from './promote.js'
+import {TrafficSplitObject} from '../../types/k8sObject.js'
+import * as servicesTester from './serviceBlueGreenHelper.js'
+import {Kubectl} from '../../types/kubectl.js'
+import {MAX_VAL, MIN_VAL, TRAFFIC_SPLIT_OBJECT} from './smiBlueGreenHelper.js'
+import * as smiTester from './smiBlueGreenHelper.js'
+import * as bgHelper from './blueGreenHelper.js'
 import {ExecOutput} from '@actions/exec'
 
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
 
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 
 // Shared variables used across all test suites
 let testObjects: any
@@ -42,13 +44,12 @@ const mockBgDeployment = {
 }
 
 describe('promote tests', () => {
-   let kubectlApplySpy: jest.SpyInstance
+   let kubectlApplySpy: MockInstance
 
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       testObjects = getManifestObjects(ingressFilepath)
-      kubectlApplySpy = jest.spyOn(kubectl, 'apply')
+      kubectlApplySpy = vi.spyOn(kubectl, 'apply')
    })
 
    test('promote blue/green ingress', async () => {
@@ -57,7 +58,7 @@ describe('promote tests', () => {
       const mockLabels = new Map<string, string>()
       mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.GREEN_LABEL_VALUE
 
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
          Promise.resolve({
             kind: 'Ingress',
             spec: {},
@@ -82,7 +83,7 @@ describe('promote tests', () => {
    test('fail to promote invalid blue/green ingress', async () => {
       const mockLabels = new Map<string, string>()
       mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.NONE_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
          Promise.resolve({
             kind: 'Ingress',
             spec: {},
@@ -100,7 +101,7 @@ describe('promote tests', () => {
 
       const mockLabels = new Map<string, string>()
       mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.GREEN_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
          Promise.resolve({
             kind: 'Service',
             spec: {selector: mockLabels},
@@ -120,16 +121,16 @@ describe('promote tests', () => {
    test('fail to promote invalid blue/green service', async () => {
       const mockLabels = new Map<string, string>()
       mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.NONE_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
          Promise.resolve({
             kind: 'Service',
             spec: {},
             metadata: {labels: mockLabels, name: 'nginx-ingress-green'}
          })
       )
-      jest
-         .spyOn(servicesTester, 'validateServicesState')
-         .mockImplementationOnce(() => Promise.resolve(false))
+      vi.spyOn(servicesTester, 'validateServicesState').mockImplementationOnce(
+         () => Promise.resolve(false)
+      )
 
       await expect(
          promoteBlueGreenService(kubectl, testObjects)
@@ -164,9 +165,9 @@ describe('promote tests', () => {
             ]
          }
       }
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockTsObject))
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+         Promise.resolve(mockTsObject)
+      )
 
       const deployResult = await promoteBlueGreenSMI(kubectl, testObjects)
 
@@ -182,11 +183,11 @@ describe('promote tests', () => {
    test('promote blue/green SMI with bad trafficsplit', async () => {
       const mockLabels = new Map<string, string>()
       mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.NONE_LABEL_VALUE
-      jest
-         .spyOn(smiTester, 'validateTrafficSplitsState')
-         .mockImplementation(() => Promise.resolve(false))
+      vi.spyOn(smiTester, 'validateTrafficSplitsState').mockImplementation(() =>
+         Promise.resolve(false)
+      )
 
-      expect(promoteBlueGreenSMI(kubectl, testObjects)).rejects.toThrow()
+      await expect(promoteBlueGreenSMI(kubectl, testObjects)).rejects.toThrow()
    })
 
    // Consolidated error tests
@@ -198,7 +199,7 @@ describe('promote tests', () => {
             const mockLabels = new Map<string, string>()
             mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] =
                bgHelper.GREEN_LABEL_VALUE
-            jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+            vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
                Promise.resolve({
                   kind: 'Ingress',
                   spec: {},
@@ -214,16 +215,16 @@ describe('promote tests', () => {
             const mockLabels = new Map<string, string>()
             mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] =
                bgHelper.GREEN_LABEL_VALUE
-            jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+            vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
                Promise.resolve({
                   kind: 'Service',
                   spec: {selector: mockLabels},
                   metadata: {labels: mockLabels, name: 'nginx-service-green'}
                })
             )
-            jest
-               .spyOn(servicesTester, 'validateServicesState')
-               .mockResolvedValue(true)
+            vi.spyOn(servicesTester, 'validateServicesState').mockResolvedValue(
+               true
+            )
          }
       },
       {
@@ -246,12 +247,10 @@ describe('promote tests', () => {
                   ]
                }
             }
-            jest
-               .spyOn(bgHelper, 'fetchResource')
-               .mockResolvedValue(mockTsObject)
-            jest
-               .spyOn(smiTester, 'validateTrafficSplitsState')
-               .mockResolvedValue(true)
+            vi.spyOn(bgHelper, 'fetchResource').mockResolvedValue(mockTsObject)
+            vi.spyOn(smiTester, 'validateTrafficSplitsState').mockResolvedValue(
+               true
+            )
          }
       }
    ])('$name', async ({fn, setup}) => {
@@ -279,15 +278,12 @@ describe('promote tests', () => {
 // Timeout tests
 describe('promote timeout tests', () => {
    beforeEach(() => {
-      // @ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       testObjects = getManifestObjects(ingressFilepath)
    })
 
    const mockDeployWithLabel = () =>
-      jest
-         .spyOn(bgHelper, 'deployWithLabel')
-         .mockResolvedValue(mockBgDeployment)
+      vi.spyOn(bgHelper, 'deployWithLabel').mockResolvedValue(mockBgDeployment)
 
    const setupFetchResource = (
       kind: string,
@@ -297,7 +293,7 @@ describe('promote timeout tests', () => {
       const mockLabels = new Map<string, string>()
       mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = labelValue
 
-      jest.spyOn(bgHelper, 'fetchResource').mockResolvedValue({
+      vi.spyOn(bgHelper, 'fetchResource').mockResolvedValue({
          kind,
          spec: {},
          metadata: {labels: mockLabels, name}
@@ -330,9 +326,9 @@ describe('promote timeout tests', () => {
                'nginx-service-green',
                bgHelper.GREEN_LABEL_VALUE
             )
-            jest
-               .spyOn(servicesTester, 'validateServicesState')
-               .mockResolvedValue(true)
+            vi.spyOn(servicesTester, 'validateServicesState').mockResolvedValue(
+               true
+            )
          }
       },
       {
@@ -359,12 +355,10 @@ describe('promote timeout tests', () => {
                }
             }
 
-            jest
-               .spyOn(bgHelper, 'fetchResource')
-               .mockResolvedValue(mockTsObject)
-            jest
-               .spyOn(smiTester, 'validateTrafficSplitsState')
-               .mockResolvedValue(true)
+            vi.spyOn(bgHelper, 'fetchResource').mockResolvedValue(mockTsObject)
+            vi.spyOn(smiTester, 'validateTrafficSplitsState').mockResolvedValue(
+               true
+            )
          }
       }
    ])('$name', async ({fn, timeout, setup}) => {

src/strategyHelpers/blueGreen/promote.ts

@@ -1,13 +1,13 @@
 import * as core from '@actions/core'
 
-import {Kubectl} from '../../types/kubectl'
+import {Kubectl} from '../../types/kubectl.js'
 
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
-import {deployWithLabel, NONE_LABEL_VALUE} from './blueGreenHelper'
+import {BlueGreenDeployment} from '../../types/blueGreenTypes.js'
+import {deployWithLabel, NONE_LABEL_VALUE} from './blueGreenHelper.js'
 
-import {validateIngresses} from './ingressBlueGreenHelper'
-import {validateServicesState} from './serviceBlueGreenHelper'
-import {validateTrafficSplitsState} from './smiBlueGreenHelper'
+import {validateIngresses} from './ingressBlueGreenHelper.js'
+import {validateServicesState} from './serviceBlueGreenHelper.js'
+import {validateTrafficSplitsState} from './smiBlueGreenHelper.js'
 
 export async function promoteBlueGreenIngress(
    kubectl: Kubectl,

src/strategyHelpers/blueGreen/reject.test.ts

@@ -1,21 +1,23 @@
-import {getManifestObjects} from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
+import {vi} from 'vitest'
+import type {MockInstance} from 'vitest'
+import {getManifestObjects} from './blueGreenHelper.js'
+import {Kubectl} from '../../types/kubectl.js'
 
-import * as TSutils from '../../utilities/trafficSplitUtils'
+import * as TSutils from '../../utilities/trafficSplitUtils.js'
 import {
    rejectBlueGreenIngress,
    rejectBlueGreenService,
    rejectBlueGreenSMI
-} from './reject'
-import * as bgHelper from './blueGreenHelper'
-import * as routeHelper from './route'
+} from './reject.js'
+import * as bgHelper from './blueGreenHelper.js'
+import * as routeHelper from './route.js'
 
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
 const kubectl = new Kubectl('')
 const TEST_TIMEOUT_SHORT = '60s'
 const TEST_TIMEOUT_LONG = '120s'
 
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 
 // Shared mock objects following DRY principle
 const mockSuccessResult = {
@@ -54,14 +56,13 @@ const mockDeleteResult = [
 
 describe('reject tests', () => {
    let testObjects: any
-   let kubectlApplySpy: jest.SpyInstance
+   let kubectlApplySpy: MockInstance
 
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-      jest.restoreAllMocks()
+      vi.mocked(Kubectl).mockClear()
+      vi.restoreAllMocks()
       testObjects = getManifestObjects(ingressFilepath)
-      kubectlApplySpy = jest.spyOn(kubectl, 'apply')
+      kubectlApplySpy = vi.spyOn(kubectl, 'apply')
    })
 
    test('reject blue/green ingress', async () => {
@@ -89,13 +90,13 @@ describe('reject tests', () => {
 
    test('reject blue/green ingress with timeout', async () => {
       // Mock routeBlueGreenIngressUnchanged and deleteGreenObjects
-      jest
-         .spyOn(routeHelper, 'routeBlueGreenIngressUnchanged')
-         .mockResolvedValue(mockBgDeployment)
+      vi.spyOn(routeHelper, 'routeBlueGreenIngressUnchanged').mockResolvedValue(
+         mockBgDeployment
+      )
 
-      jest
-         .spyOn(bgHelper, 'deleteGreenObjects')
-         .mockResolvedValue(mockDeleteResult)
+      vi.spyOn(bgHelper, 'deleteGreenObjects').mockResolvedValue(
+         mockDeleteResult
+      )
 
       const value = await rejectBlueGreenIngress(
          kubectl,
@@ -138,9 +139,9 @@ describe('reject tests', () => {
 
    test('reject blue/green service', async () => {
       kubectlApplySpy.mockResolvedValue(mockSuccessResult)
-      jest
-         .spyOn(bgHelper, 'deleteGreenObjects')
-         .mockResolvedValue(mockDeleteResult)
+      vi.spyOn(bgHelper, 'deleteGreenObjects').mockResolvedValue(
+         mockDeleteResult
+      )
 
       const value = await rejectBlueGreenService(
          kubectl,
@@ -163,7 +164,7 @@ describe('reject tests', () => {
 
    test('reject blue/green service with timeout', async () => {
       // Mock routeBlueGreenService and deleteGreenObjects
-      jest.spyOn(routeHelper, 'routeBlueGreenService').mockResolvedValue({
+      vi.spyOn(routeHelper, 'routeBlueGreenService').mockResolvedValue({
          deployResult: {
             execResult: {stdout: '', stderr: '', exitCode: 0},
             manifestFiles: []
@@ -180,11 +181,9 @@ describe('reject tests', () => {
          ]
       })
 
-      jest
-         .spyOn(bgHelper, 'deleteGreenObjects')
-         .mockResolvedValue([
-            {name: 'nginx-deployment-green', kind: 'Deployment'}
-         ])
+      vi.spyOn(bgHelper, 'deleteGreenObjects').mockResolvedValue([
+         {name: 'nginx-deployment-green', kind: 'Deployment'}
+      ])
 
       const value = await rejectBlueGreenService(
          kubectl,
@@ -213,9 +212,9 @@ describe('reject tests', () => {
       // Mock kubectl.apply to return successful result
       kubectlApplySpy.mockResolvedValue(mockSuccessResult)
 
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve('v1alpha3'))
+      vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(() =>
+         Promise.resolve('v1alpha3')
+      )
       const rejectResult = await rejectBlueGreenSMI(kubectl, testObjects)
       expect(rejectResult.deleteResult).toHaveLength(2)
    })
@@ -226,27 +225,27 @@ describe('reject tests', () => {
          name: 'should throw error when kubectl apply fails during blue/green ingress rejection',
          fn: () => rejectBlueGreenIngress(kubectl, testObjects),
          setup: () => {
-            jest
-               .spyOn(bgHelper, 'deleteGreenObjects')
-               .mockResolvedValue(mockDeleteResult)
+            vi.spyOn(bgHelper, 'deleteGreenObjects').mockResolvedValue(
+               mockDeleteResult
+            )
          }
       },
       {
          name: 'should throw error when kubectl apply fails during blue/green service rejection',
          fn: () => rejectBlueGreenService(kubectl, testObjects),
          setup: () => {
-            jest
-               .spyOn(bgHelper, 'deleteGreenObjects')
-               .mockResolvedValue(mockDeleteResult)
+            vi.spyOn(bgHelper, 'deleteGreenObjects').mockResolvedValue(
+               mockDeleteResult
+            )
          }
       },
       {
          name: 'should throw error when kubectl apply fails during blue/green SMI rejection',
          fn: () => rejectBlueGreenSMI(kubectl, testObjects),
          setup: () => {
-            jest
-               .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-               .mockImplementation(() => Promise.resolve('v1alpha3'))
+            vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(
+               () => Promise.resolve('v1alpha3')
+            )
          }
       }
    ])('$name', async ({fn, setup}) => {

src/strategyHelpers/blueGreen/reject.ts

@@ -1,14 +1,14 @@
-import {K8sDeleteObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
+import {K8sDeleteObject} from '../../types/k8sObject.js'
+import {Kubectl} from '../../types/kubectl.js'
 import {
    BlueGreenDeployment,
    BlueGreenManifests,
    BlueGreenRejectResult
-} from '../../types/blueGreenTypes'
-import {deleteGreenObjects, NONE_LABEL_VALUE} from './blueGreenHelper'
-import {routeBlueGreenSMI} from './route'
-import {cleanupSMI} from './smiBlueGreenHelper'
-import {routeBlueGreenIngressUnchanged, routeBlueGreenService} from './route'
+} from '../../types/blueGreenTypes.js'
+import {deleteGreenObjects, NONE_LABEL_VALUE} from './blueGreenHelper.js'
+import {routeBlueGreenSMI} from './route.js'
+import {cleanupSMI} from './smiBlueGreenHelper.js'
+import {routeBlueGreenIngressUnchanged, routeBlueGreenService} from './route.js'
 
 export async function rejectBlueGreenIngress(
    kubectl: Kubectl,

src/strategyHelpers/blueGreen/route.test.ts

@@ -1,24 +1,28 @@
-import {K8sIngress, TrafficSplitObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-import * as TSutils from '../../utilities/trafficSplitUtils'
-import {RouteStrategy} from '../../types/routeStrategy'
-import {BlueGreenManifests} from '../../types/blueGreenTypes'
+import {vi} from 'vitest'
+import type {MockInstance} from 'vitest'
+import {K8sIngress, TrafficSplitObject} from '../../types/k8sObject.js'
+import {Kubectl} from '../../types/kubectl.js'
+import * as fileHelper from '../../utilities/fileUtils.js'
+import * as TSutils from '../../utilities/trafficSplitUtils.js'
+import {RouteStrategy} from '../../types/routeStrategy.js'
+import {BlueGreenManifests} from '../../types/blueGreenTypes.js'
 
 import {
    BLUE_GREEN_VERSION_LABEL,
    getManifestObjects,
    GREEN_LABEL_VALUE
-} from './blueGreenHelper'
+} from './blueGreenHelper.js'
+import * as bgHelper from './blueGreenHelper.js'
+import * as smiHelper from './smiBlueGreenHelper.js'
 import {
    routeBlueGreenIngress,
    routeBlueGreenService,
    routeBlueGreenForDeploy,
    routeBlueGreenSMI,
    routeBlueGreenIngressUnchanged
-} from './route'
+} from './route.js'
 
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
 const kc = new Kubectl('')
 
@@ -37,16 +41,15 @@ const mockFailureResult = {
 
 describe('route function tests', () => {
    let testObjects: BlueGreenManifests
-   let kubectlApplySpy: jest.SpyInstance
+   let kubectlApplySpy: MockInstance
 
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       testObjects = getManifestObjects(ingressFilepath)
-      kubectlApplySpy = jest.spyOn(kc, 'apply')
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
+      kubectlApplySpy = vi.spyOn(kc, 'apply')
+      vi.spyOn(fileHelper, 'writeObjectsToFile').mockImplementationOnce(() => [
+         ''
+      ])
    })
 
    test('correctly prepares blue/green ingresses for deployment', async () => {
@@ -96,9 +99,9 @@ describe('route function tests', () => {
    })
 
    test('correctly identifies route pattern and acts accordingly', async () => {
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve('v1alpha3'))
+      vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(() =>
+         Promise.resolve('v1alpha3')
+      )
 
       const ingressResult = await routeBlueGreenForDeploy(
          kc,
@@ -164,9 +167,9 @@ describe('route function tests', () => {
                testObjects.serviceEntityList
             ),
          setup: () => {
-            jest
-               .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-               .mockImplementation(() => Promise.resolve('v1alpha3'))
+            vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(
+               () => Promise.resolve('v1alpha3')
+            )
          }
       },
       {
@@ -194,24 +197,23 @@ describe('route timeout tests', () => {
    let testObjects: BlueGreenManifests
 
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       testObjects = getManifestObjects(ingressFilepath)
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
+      vi.spyOn(fileHelper, 'writeObjectsToFile').mockImplementationOnce(() => [
+         ''
+      ])
    })
 
    afterEach(() => {
-      jest.restoreAllMocks()
+      vi.restoreAllMocks()
    })
 
    test('routeBlueGreenService with timeout', async () => {
       const timeout = '240s'
 
       // Mock deployObjects to capture timeout parameter
-      const deployObjectsSpy = jest
-         .spyOn(require('./blueGreenHelper'), 'deployObjects')
+      const deployObjectsSpy = vi
+         .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue({
             execResult: mockSuccessResult,
             manifestFiles: []
@@ -237,23 +239,29 @@ describe('route timeout tests', () => {
    test('routeBlueGreenSMI with timeout', async () => {
       const timeout = '300s'
 
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve('v1alpha3'))
+      vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(() =>
+         Promise.resolve('v1alpha3')
+      )
 
       // Mock deployObjects and createTrafficSplitObject to capture timeout parameter
-      const deployObjectsSpy = jest
-         .spyOn(require('./blueGreenHelper'), 'deployObjects')
+      const deployObjectsSpy = vi
+         .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue({
             execResult: mockSuccessResult,
             manifestFiles: []
          })
 
-      const createTrafficSplitSpy = jest
-         .spyOn(require('./smiBlueGreenHelper'), 'createTrafficSplitObject')
+      const createTrafficSplitSpy = vi
+         .spyOn(smiHelper, 'createTrafficSplitObject')
          .mockResolvedValue({
-            metadata: {name: 'nginx-service-trafficsplit'},
-            spec: {backends: []}
+            apiVersion: 'split.smi-spec.io/v1alpha3',
+            kind: 'TrafficSplit',
+            metadata: {
+               name: 'nginx-service-trafficsplit',
+               labels: new Map(),
+               annotations: new Map()
+            },
+            spec: {service: 'nginx-service', backends: []}
          })
 
       const value = await routeBlueGreenSMI(
@@ -284,8 +292,8 @@ describe('route timeout tests', () => {
       const timeout = '180s'
 
       // Mock deployObjects to capture timeout parameter
-      const deployObjectsSpy = jest
-         .spyOn(require('./blueGreenHelper'), 'deployObjects')
+      const deployObjectsSpy = vi
+         .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue({
             execResult: mockSuccessResult,
             manifestFiles: []
@@ -309,8 +317,8 @@ describe('route timeout tests', () => {
    })
 
    test('route functions without timeout should pass undefined', async () => {
-      const deployObjectsSpy = jest
-         .spyOn(require('./blueGreenHelper'), 'deployObjects')
+      const deployObjectsSpy = vi
+         .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue({
             execResult: mockSuccessResult,
             manifestFiles: []

src/strategyHelpers/blueGreen/route.ts

@@ -1,26 +1,26 @@
-import {sleep} from '../../utilities/timeUtils'
-import {RouteStrategy} from '../../types/routeStrategy'
-import {Kubectl} from '../../types/kubectl'
+import {sleep} from '../../utilities/timeUtils.js'
+import {RouteStrategy} from '../../types/routeStrategy.js'
+import {Kubectl} from '../../types/kubectl.js'
 import {
    BlueGreenDeployment,
    BlueGreenManifests
-} from '../../types/blueGreenTypes'
+} from '../../types/blueGreenTypes.js'
 import {
    getManifestObjects,
    GREEN_LABEL_VALUE,
    deployObjects
-} from './blueGreenHelper'
+} from './blueGreenHelper.js'
 
 import {
    getUpdatedBlueGreenIngress,
    isIngressRouted
-} from './ingressBlueGreenHelper'
-import {getUpdatedBlueGreenService} from './serviceBlueGreenHelper'
-import {createTrafficSplitObject} from './smiBlueGreenHelper'
+} from './ingressBlueGreenHelper.js'
+import {getUpdatedBlueGreenService} from './serviceBlueGreenHelper.js'
+import {createTrafficSplitObject} from './smiBlueGreenHelper.js'
 
 import * as core from '@actions/core'
-import {K8sObject, TrafficSplitObject} from '../../types/k8sObject'
-import {getBufferTime} from '../../inputUtils'
+import {K8sObject, TrafficSplitObject} from '../../types/k8sObject.js'
+import {getBufferTime} from '../../inputUtils.js'
 
 export async function routeBlueGreenForDeploy(
    kubectl: Kubectl,

src/strategyHelpers/blueGreen/serviceBlueGreenHelper.test.ts

@@ -1,26 +1,26 @@
+import {vi} from 'vitest'
 import * as core from '@actions/core'
 import {
    BLUE_GREEN_VERSION_LABEL,
    getManifestObjects,
    GREEN_LABEL_VALUE
-} from './blueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
+} from './blueGreenHelper.js'
+import * as bgHelper from './blueGreenHelper.js'
+import {Kubectl} from '../../types/kubectl.js'
 import {
    getServiceSpecLabel,
    getUpdatedBlueGreenService,
    validateServicesState
-} from './serviceBlueGreenHelper'
+} from './serviceBlueGreenHelper.js'
 
 let testObjects
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 const kubectl = new Kubectl('')
 
 describe('blue/green service helper tests', () => {
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
       testObjects = getManifestObjects(ingressFilepath)
    })
 
@@ -42,7 +42,7 @@ describe('blue/green service helper tests', () => {
       mockLabels[BLUE_GREEN_VERSION_LABEL] = bgHelper.GREEN_LABEL_VALUE
       const mockSelectors = new Map<string, string>()
       mockSelectors[BLUE_GREEN_VERSION_LABEL] = GREEN_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
          Promise.resolve({
             kind: 'Service',
             spec: {selector: mockSelectors},

src/strategyHelpers/blueGreen/serviceBlueGreenHelper.ts

@@ -1,12 +1,12 @@
 import * as core from '@actions/core'
-import {K8sServiceObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
+import {K8sServiceObject} from '../../types/k8sObject.js'
+import {Kubectl} from '../../types/kubectl.js'
 import {
    addBlueGreenLabelsAndAnnotations,
    BLUE_GREEN_VERSION_LABEL,
    fetchResource,
    GREEN_LABEL_VALUE
-} from './blueGreenHelper'
+} from './blueGreenHelper.js'
 
 // add green labels to configure existing service
 export function getUpdatedBlueGreenService(

src/strategyHelpers/blueGreen/smiBlueGreenHelper.test.ts

@@ -1,15 +1,16 @@
-import {TrafficSplitObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-import * as TSutils from '../../utilities/trafficSplitUtils'
+import {vi} from 'vitest'
+import {TrafficSplitObject} from '../../types/k8sObject.js'
+import {Kubectl} from '../../types/kubectl.js'
+import * as fileHelper from '../../utilities/fileUtils.js'
+import * as TSutils from '../../utilities/trafficSplitUtils.js'
 
-import {BlueGreenManifests} from '../../types/blueGreenTypes'
+import {BlueGreenManifests} from '../../types/blueGreenTypes.js'
 import {
    BLUE_GREEN_VERSION_LABEL,
    getManifestObjects,
    GREEN_LABEL_VALUE,
    NONE_LABEL_VALUE
-} from './blueGreenHelper'
+} from './blueGreenHelper.js'
 
 import {
    cleanupSMI,
@@ -21,10 +22,10 @@ import {
    setupSMI,
    TRAFFIC_SPLIT_OBJECT,
    validateTrafficSplitsState
-} from './smiBlueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
+} from './smiBlueGreenHelper.js'
+import * as bgHelper from './blueGreenHelper.js'
 
-jest.mock('../../types/kubectl')
+vi.mock('../../types/kubectl')
 
 const kc = new Kubectl('')
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
@@ -68,21 +69,20 @@ const mockTsObject: TrafficSplitObject = {
 describe('SMI Helper tests', () => {
    let testObjects: BlueGreenManifests
    beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
+      vi.mocked(Kubectl).mockClear()
 
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve(''))
+      vi.spyOn(TSutils, 'getTrafficSplitAPIVersion').mockImplementation(() =>
+         Promise.resolve('')
+      )
 
       testObjects = getManifestObjects(ingressFilepath)
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
+      vi.spyOn(fileHelper, 'writeObjectsToFile').mockImplementationOnce(() => [
+         ''
+      ])
    })
 
    test('setupSMI tests', async () => {
-      jest.spyOn(kc, 'apply').mockResolvedValue(mockSuccessResult)
+      vi.spyOn(kc, 'apply').mockResolvedValue(mockSuccessResult)
 
       const smiResults = await setupSMI(kc, testObjects.serviceEntityList)
 
@@ -174,9 +174,9 @@ describe('SMI Helper tests', () => {
    })
 
    test('validateTrafficSplitsState', async () => {
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockTsObject))
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+         Promise.resolve(mockTsObject)
+      )
 
       let valResult = await validateTrafficSplitsState(
          kc,
@@ -187,9 +187,9 @@ describe('SMI Helper tests', () => {
 
       const mockTsCopy = JSON.parse(JSON.stringify(mockTsObject))
       mockTsCopy.spec.backends[0].weight = MAX_VAL
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockTsCopy))
+      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+         Promise.resolve(mockTsCopy)
+      )
 
       valResult = await validateTrafficSplitsState(
          kc,
@@ -197,7 +197,7 @@ describe('SMI Helper tests', () => {
       )
       expect(valResult).toBe(false)
 
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation()
+      vi.spyOn(bgHelper, 'fetchResource').mockResolvedValue(null)
       valResult = await validateTrafficSplitsState(
          kc,
          testObjects.serviceEntityList
@@ -218,7 +218,7 @@ describe('SMI Helper tests', () => {
          name: 'should throw error when kubectl apply fails during SMI setup',
          fn: () => setupSMI(kc, testObjects.serviceEntityList),
          setup: () => {
-            jest.spyOn(kc, 'apply').mockResolvedValue(mockFailureResult)
+            vi.spyOn(kc, 'apply').mockResolvedValue(mockFailureResult)
          }
       }
    ])('$name', async ({fn, setup}) => {
@@ -229,7 +229,7 @@ describe('SMI Helper tests', () => {
 
    // Timeout-specific tests
    test('setupSMI with timeout test', async () => {
-      const deployObjectsSpy = jest
+      const deployObjectsSpy = vi
          .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue({
             execResult: mockSuccessResult,
@@ -257,7 +257,7 @@ describe('SMI Helper tests', () => {
    })
 
    test('createTrafficSplitObject with timeout test', async () => {
-      const deleteObjectsSpy = jest
+      const deleteObjectsSpy = vi
          .spyOn(bgHelper, 'deleteObjects')
          .mockResolvedValue()
 
@@ -288,7 +288,7 @@ describe('SMI Helper tests', () => {
    })
 
    test('createTrafficSplitObject with GREEN_LABEL_VALUE and timeout test', async () => {
-      const deleteObjectsSpy = jest
+      const deleteObjectsSpy = vi
          .spyOn(bgHelper, 'deleteObjects')
          .mockResolvedValue()
 
@@ -321,7 +321,7 @@ describe('SMI Helper tests', () => {
    })
 
    test('cleanupSMI with timeout test', async () => {
-      const deleteObjectsSpy = jest
+      const deleteObjectsSpy = vi
          .spyOn(bgHelper, 'deleteObjects')
          .mockResolvedValue()
 
@@ -352,7 +352,7 @@ describe('SMI Helper tests', () => {
    })
 
    test('setupSMI without timeout test', async () => {
-      const deployObjectsSpy = jest
+      const deployObjectsSpy = vi
          .spyOn(bgHelper, 'deployObjects')
          .mockResolvedValue({
             execResult: mockSuccessResult,
@@ -375,7 +375,7 @@ describe('SMI Helper tests', () => {
    })
 
    test('createTrafficSplitObject without timeout test', async () => {
-      const deleteObjectsSpy = jest
+      const deleteObjectsSpy = vi
          .spyOn(bgHelper, 'deleteObjects')
          .mockResolvedValue()
 
@@ -398,7 +398,7 @@ describe('SMI Helper tests', () => {
    })
 
    test('cleanupSMI without timeout test', async () => {
-      const deleteObjectsSpy = jest
+      const deleteObjectsSpy = vi
          .spyOn(bgHelper, 'deleteObjects')
          .mockResolvedValue()
 

src/strategyHelpers/blueGreen/smiBlueGreenHelper.ts

@@ -1,6 +1,6 @@
 import * as core from '@actions/core'
-import {Kubectl} from '../../types/kubectl'
-import * as kubectlUtils from '../../utilities/trafficSplitUtils'
+import {Kubectl} from '../../types/kubectl.js'
+import * as kubectlUtils from '../../utilities/trafficSplitUtils.js'
 import {
    deleteObjects,
    deployObjects,
@@ -11,15 +11,15 @@ import {
    GREEN_SUFFIX,
    NONE_LABEL_VALUE,
    STABLE_SUFFIX
-} from './blueGreenHelper'
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
+} from './blueGreenHelper.js'
+import {BlueGreenDeployment} from '../../types/blueGreenTypes.js'
 import {
    K8sDeleteObject,
    K8sObject,
    TrafficSplitObject
-} from '../../types/k8sObject'
-import {DeployResult} from '../../types/deployResult'
-import {inputAnnotations} from '../../inputUtils'
+} from '../../types/k8sObject.js'
+import {DeployResult} from '../../types/deployResult.js'
+import {inputAnnotations} from '../../inputUtils.js'
 
 export const TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX = '-trafficsplit'
 export const TRAFFIC_SPLIT_OBJECT = 'TrafficSplit'