build

.github/actions/minikube-setup/action.yml

@@ -1,53 +0,0 @@
-name: 'Setup Minikube Test Environment'
-description: 'Common setup steps for minikube integration tests'
-inputs:
-   install-smi:
-      description: 'Install Linkerd SMI for service mesh tests'
-      required: false
-      default: 'false'
-
-runs:
-   using: 'composite'
-   steps:
-      - name: Install dependencies
-        shell: bash
-        run: |
-           rm -rf node_modules/
-           npm install
-
-      - name: Build
-        shell: bash
-        run: npm run build
-
-      - name: Install conntrack
-        shell: bash
-        run: sudo apt-get install -y conntrack
-
-      - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
-        name: Install Kubectl
-
-      - id: setup-minikube
-        name: Setup Minikube
-        uses: medyagh/setup-minikube@e9e035a86bbc3caea26a450bd4dbf9d0c453682e # v0.0.21
-        with:
-           minikube-version: 1.37.0
-           kubernetes-version: 1.31.0
-           driver: 'docker'
-
-      - name: Install Linkerd and SMI
-        if: inputs.install-smi == 'true'
-        shell: bash
-        run: |
-           curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/install-edge | sh
-           export PATH=$PATH:/home/runner/.linkerd2/bin
-           curl -sL https://linkerd.github.io/linkerd-smi/install | sh
-           kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.2.0/standard-install.yaml
-
-           linkerd install --crds | kubectl apply -f -
-           linkerd install --set proxyInit.runAsRoot=true | kubectl apply -f -
-           linkerd smi install | kubectl apply -f -
-
-      - uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # 6.1.0
-        name: Install Python
-        with:
-           python-version: '3.x'

.github/workflows/codeql.yml

@@ -16,7 +16,7 @@ jobs:
 
       steps:
          - name: Checkout repository
-           uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd #v6.0.2
+           uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
            with:
               # We must fetch at least the immediate parents so that if this is
               # a pull request then we can checkout the head.
@@ -24,7 +24,7 @@ jobs:
 
          # Initializes the CodeQL tools for scanning.
          - name: Initialize CodeQL
-           uses: github/codeql-action/init@c793b717bc78562f491db7b0e93a3a178b099162 #v3.29.5
+           uses: github/codeql-action/init@51f77329afa6477de8c49fc9c7046c15b9a4e79d #v3.29.5
            # Override language selection by uncommenting this and choosing your languages
            # with:
            #   languages: go, javascript, csharp, python, cpp, java
@@ -32,7 +32,7 @@ jobs:
          # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
          # If this step fails, then you should remove it and run the build manually (see below)
          - name: Autobuild
-           uses: github/codeql-action/autobuild@c793b717bc78562f491db7b0e93a3a178b099162 #v3.29.5
+           uses: github/codeql-action/autobuild@51f77329afa6477de8c49fc9c7046c15b9a4e79d #v3.29.5
 
          # ℹ️ Command-line programs to run using the OS shell.
          # 📚 https://git.io/JvXDl
@@ -46,4 +46,4 @@ jobs:
          #   make release
 
          - name: Perform CodeQL Analysis
-           uses: github/codeql-action/analyze@c793b717bc78562f491db7b0e93a3a178b099162 #v3.29.5
+           uses: github/codeql-action/analyze@51f77329afa6477de8c49fc9c7046c15b9a4e79d #v3.29.5

.github/workflows/defaultLabels.yml

@@ -13,7 +13,7 @@ jobs:
 
       # Steps represent a sequence of tasks that will be executed as part of the job
       steps:
-         - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+         - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
            name: Setting issue as idle
            with:
               repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -24,7 +24,7 @@ jobs:
               operations-per-run: 100
               exempt-issue-labels: 'backlog'
 
-         - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+         - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
            name: Setting PR as idle
            with:
               repo-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/prettify-code.yml

@@ -10,7 +10,7 @@ jobs:
       runs-on: ubuntu-latest
       steps:
          - name: Checkout Repository
-           uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+           uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
          - name: install deps
            run: npm install
 

.github/workflows/run-integration-tests-basic.yml

@@ -18,15 +18,39 @@ jobs:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE: test-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
+           with:
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
 
          - name: Create namespace to run tests
            run: kubectl create ns ${{ env.NAMESPACE }}
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Service' 'all' ${{ env.NAMESPACE }}

.github/workflows/run-integration-tests-bluegreen-ingress.yml

@@ -12,21 +12,45 @@ on:
 
 jobs:
    run-integration-test:
-      name: Blue-Green Ingress Tests
+      name: Run Minikube Integration Tests
       runs-on: ubuntu-22.04
       env:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE: test-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
+           with:
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
 
          - name: Create namespace to run tests
            run: kubectl create ns ${{ env.NAMESPACE }}
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Service' 'nginx-service' ${{ env.NAMESPACE }}

.github/workflows/run-integration-tests-bluegreen-service.yml

@@ -12,21 +12,45 @@ on:
 
 jobs:
    run-integration-test:
-      name: Blue-Green Service Tests
+      name: Run Minikube Integration Tests
       runs-on: ubuntu-22.04
       env:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE: test-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
+           with:
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
 
          - name: Create namespace to run tests
            run: kubectl create ns ${{ env.NAMESPACE }}
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Service' 'all' ${{ env.NAMESPACE }}

.github/workflows/run-integration-tests-bluegreen-smi.yml

@@ -12,23 +12,56 @@ on:
 
 jobs:
    run-integration-test:
-      name: Blue-Green SMI Tests
+      name: Run Minikube Integration Tests
       runs-on: ubuntu-22.04
       env:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE: test-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
            with:
-              install-smi: 'true'
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
+
+         - name: Install linkerd and add controlplane to cluster
+           run: |
+              curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/install-edge | sh
+              export PATH=$PATH:/home/runner/.linkerd2/bin
+              curl -sL https://linkerd.github.io/linkerd-smi/install | sh
+              kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.2.0/standard-install.yaml
+
+              linkerd install --crds | kubectl apply -f -
+              linkerd install --set proxyInit.runAsRoot=true | kubectl apply -f -
+              linkerd smi install | kubectl apply -f -
 
          - name: Create namespace to run tests
            run: kubectl create ns ${{ env.NAMESPACE }}
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Service' 'all' ${{ env.NAMESPACE }}

.github/workflows/run-integration-tests-canary-pod.yml

@@ -12,21 +12,45 @@ on:
 
 jobs:
    run-integration-test:
-      name: Canary Pod Tests
+      name: Run Minikube Integration Tests
       runs-on: ubuntu-22.04
       env:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE: test-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
+           with:
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
 
          - name: Create namespace to run tests
            run: kubectl create ns ${{ env.NAMESPACE }}
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Service' 'all' ${{ env.NAMESPACE }}

.github/workflows/run-integration-tests-canary-smi.yml

@@ -12,23 +12,56 @@ on:
 
 jobs:
    run-integration-test:
-      name: Canary SMI Tests
+      name: Run Minikube Integration Tests
       runs-on: ubuntu-22.04
       env:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE: test-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
            with:
-              install-smi: 'true'
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
+
+         - name: Install Linkerd and SMI
+           run: |
+              curl --proto '=https' --tlsv1.2 -sSfL https://run.linkerd.io/install-edge | sh
+              export PATH=$PATH:/home/runner/.linkerd2/bin
+              curl -sL https://linkerd.github.io/linkerd-smi/install | sh
+              kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.2.0/standard-install.yaml
+
+              linkerd install --crds | kubectl apply -f -
+              linkerd install --set proxyInit.runAsRoot=true | kubectl apply -f -
+              linkerd smi install | kubectl apply -f -
 
          - name: Create namespace to run tests
            run: kubectl create ns ${{ env.NAMESPACE }}
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Service' 'all' ${{ env.NAMESPACE }}

.github/workflows/run-integration-tests-namespace-optional.yml

@@ -14,18 +14,37 @@ on:
 
 jobs:
    run-integration-test:
-      name: Namespace Optional Tests
+      name: Run Namespace Optional Integration Tests
       runs-on: ubuntu-22.04
       env:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE1: integration-test-namespace1-${{ github.run_id }}
          NAMESPACE2: integration-test-namespace2-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
+           with:
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
 
          - name: Create namespaces for tests
            run: |
@@ -33,6 +52,11 @@ jobs:
               kubectl create ns ${{ env.NAMESPACE2 }}
               kubectl create ns test-namespace
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Deployment' 'all' ${{ env.NAMESPACE1 }}

.github/workflows/run-integration-tests-private.yml

@@ -19,16 +19,16 @@ jobs:
          contents: read
          id-token: write
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
          - name: Install dependencies
            run: |
               rm -rf node_modules/
               npm install
-
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
          - name: Build
-           run: npm run build
+           run: ncc build src/run.ts -o lib
-
          - name: Azure login
            uses: azure/login@v2.3.0
            with:
@@ -51,7 +51,7 @@ jobs:
            run: |
               az aks command invoke --resource-group ${{ env.NAMESPACE }} --name ${{ env.NAMESPACE }} --command "kubectl create ns ${{ env.NAMESPACE }}"
 
-         - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # 6.2.0
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
            name: Install Python
            with:
               python-version: '3.x'

.github/workflows/run-integration-tests-resource-annotation.yml

@@ -12,21 +12,45 @@ on:
 
 jobs:
    run-integration-test:
-      name: Resource Annotation Tests
+      name: Run Minikube Integration Tests
       runs-on: ubuntu-22.04
       env:
          KUBECONFIG: /home/runner/.kube/config
          NAMESPACE: test-${{ github.run_id }}
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-         - uses: ./.github/actions/minikube-setup
+         - name: Install dependencies
-           name: Setup Minikube Environment
+           run: |
-           timeout-minutes: 5
+              rm -rf node_modules/
+              npm install
+         - name: Install ncc
+           run: npm i -g @vercel/ncc
+         - name: Install conntrack
+           run: sudo apt-get install -y conntrack
+         - name: Build
+           run: ncc build src/run.ts -o lib
+
+         - uses: Azure/setup-kubectl@776406bce94f63e41d621b960d78ee25c8b76ede # v4.0.1
+           name: Install Kubectl
+
+         - id: setup-minikube
+           name: Setup Minikube
+           uses: medyagh/setup-minikube@e3c7f79eb1e997eabccc536a6cf318a2b0fe19d9 # v0.0.20
+           with:
+              minikube-version: 1.34.0
+              kubernetes-version: 1.31.0
+              driver: 'none'
+           timeout-minutes: 3
 
          - name: Create namespace to run tests
            run: kubectl create ns ${{ env.NAMESPACE }}
 
+         - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # 5.6.0
+           name: Install Python
+           with:
+              python-version: '3.x'
+
          - name: Cleaning any previously created items
            run: |
               python test/integration/k8s-deploy-delete.py 'Service' 'all' ${{ env.NAMESPACE }}

.github/workflows/unit-tests.yml

@@ -14,7 +14,7 @@ jobs:
       name: Run Unit Tests
       runs-on: ubuntu-latest
       steps:
-         - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+         - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
          - run: |
               npm install
               npm test

.husky/pre-commit

@@ -1,9 +1,3 @@
-npm run typecheck || {
-  echo ""
-  echo "❌ Type check failed."
-  echo "💡 Run 'npm run typecheck' to see errors."
-  exit 1
-}
 npm test
 npm run format-check || {
   echo ""

CHANGELOG.md

@@ -1,14 +1,5 @@
 # Changelog
 
-## [5.1.0] - 2026-03-03
-
-### Added
-
-- #458 [Ensure error messages display the correct namespace](https://github.com/Azure/k8s-deploy/pull/458)
-- #482 [docker driver](https://github.com/Azure/k8s-deploy/pull/482)
-- #492 [Migrate to esbuild/Vitest and upgrade @actions/\* to ESM-only versions](https://github.com/Azure/k8s-deploy/pull/492)
-- #498 [Add typecheck to build script](https://github.com/Azure/k8s-deploy/pull/498)
-
 ## [5.0.4] - 2025-08-05
 
 ### Added

jest.config.js

@@ -0,0 +1,20 @@
+module.exports = {
+   moduleFileExtensions: ['js', 'ts'],
+   testEnvironment: 'node',
+   testMatch: ['**/*.test.ts'],
+   transform: {
+      '\\.[jt]sx?$': 'babel-jest'
+   },
+   transformIgnorePatterns: [
+      'node_modules/(?!' +
+         [
+            '@octokit',
+            'universal-user-agent',
+            'before-after-hook',
+            'minimist'
+         ].join('|') +
+         ')'
+   ],
+   verbose: true,
+   testTimeout: 9000
+}

package.json

@@ -1,36 +1,40 @@
 {
    "name": "k8s-deploy-action",
-   "version": "5.1.0",
+   "version": "5.0.0",
    "author": "Deepak Sattiraju",
    "license": "MIT",
-   "type": "module",
    "scripts": {
-      "build": "tsc --noEmit && esbuild src/run.ts --bundle --platform=node --target=node20 --format=esm --outfile=lib/index.js --banner:js=\"import { createRequire } from 'module';const require = createRequire(import.meta.url);\"",
+      "prebuild": "npm i @vercel/ncc",
-      "typecheck": "tsc --noEmit",
+      "build": "ncc build src/run.ts -o lib",
-      "test": "vitest run",
+      "test": "jest",
-      "coverage": "vitest run --coverage",
+      "coverage": "jest --coverage=true",
       "format": "prettier --write .",
       "format-check": "prettier --check .",
       "prepare": "husky"
    },
    "dependencies": {
-      "@actions/core": "^3.0.0",
+      "@actions/core": "^1.11.1",
-      "@actions/exec": "^3.0.0",
+      "@actions/exec": "^1.0.0",
-      "@actions/io": "^3.0.2",
+      "@actions/io": "^1.1.3",
-      "@actions/tool-cache": "4.0.0",
+      "@actions/tool-cache": "2.0.2",
-      "@octokit/core": "^7.0.6",
+      "@babel/preset-env": "^7.28.0",
-      "@octokit/plugin-retry": "^8.1.0",
+      "@babel/preset-typescript": "^7.27.1",
-      "js-yaml": "4.1.1",
+      "@octokit/core": "^7.0.3",
+      "@octokit/plugin-retry": "^8.0.1",
+      "@types/minipass": "^3.3.5",
+      "husky": "^9.1.7",
+      "js-yaml": "4.1.0",
       "minimist": "^1.2.8"
    },
    "devDependencies": {
+      "@types/jest": "^30.0.0",
       "@types/js-yaml": "^4.0.9",
       "@types/minimist": "^1.2.5",
-      "@types/node": "^25.3.3",
+      "@types/node": "^24.2.0",
-      "esbuild": "^0.27",
+      "@vercel/ncc": "^0.38.3",
-      "husky": "^9.1.7",
+      "jest": "^30.0.5",
-      "prettier": "^3.8.1",
+      "prettier": "^3.6.2",
-      "typescript": "5.9.3",
+      "ts-jest": "^29.4.1",
-      "vitest": "^4"
+      "typescript": "5.9.2"
    }
 }

src/actions/deploy.ts

@@ -1,19 +1,19 @@
 import * as core from '@actions/core'
-import * as models from '../types/kubernetesTypes.js'
+import * as models from '../types/kubernetesTypes'
-import * as KubernetesConstants from '../types/kubernetesTypes.js'
+import * as KubernetesConstants from '../types/kubernetesTypes'
-import {Kubectl, Resource} from '../types/kubectl.js'
+import {Kubectl, Resource} from '../types/kubectl'
 import {
    getResources,
    updateManifestFiles
-} from '../utilities/manifestUpdateUtils.js'
+} from '../utilities/manifestUpdateUtils'
 import {
    annotateAndLabelResources,
    checkManifestStability,
    deployManifests
-} from '../strategyHelpers/deploymentHelper.js'
+} from '../strategyHelpers/deploymentHelper'
-import {DeploymentStrategy} from '../types/deploymentStrategy.js'
+import {DeploymentStrategy} from '../types/deploymentStrategy'
-import {parseTrafficSplitMethod} from '../types/trafficSplitMethod.js'
+import {parseTrafficSplitMethod} from '../types/trafficSplitMethod'
-import {ClusterType} from '../inputUtils.js'
+import {ClusterType} from '../inputUtils'
 export const ResourceTypeManagedCluster =
    'Microsoft.ContainerService/managedClusters'
 export const ResourceTypeFleet = 'Microsoft.ContainerService/fleets'

src/actions/promote.ts

@@ -1,44 +1,44 @@
 import * as core from '@actions/core'
-import * as canaryDeploymentHelper from '../strategyHelpers/canary/canaryHelper.js'
+import * as canaryDeploymentHelper from '../strategyHelpers/canary/canaryHelper'
-import * as SMICanaryDeploymentHelper from '../strategyHelpers/canary/smiCanaryHelper.js'
+import * as SMICanaryDeploymentHelper from '../strategyHelpers/canary/smiCanaryHelper'
-import * as PodCanaryHelper from '../strategyHelpers/canary/podCanaryHelper.js'
+import * as PodCanaryHelper from '../strategyHelpers/canary/podCanaryHelper'
 import {
    getResources,
    updateManifestFiles
-} from '../utilities/manifestUpdateUtils.js'
+} from '../utilities/manifestUpdateUtils'
-import {annotateAndLabelResources} from '../strategyHelpers/deploymentHelper.js'
+import {annotateAndLabelResources} from '../strategyHelpers/deploymentHelper'
-import * as models from '../types/kubernetesTypes.js'
+import * as models from '../types/kubernetesTypes'
-import * as KubernetesManifestUtility from '../utilities/manifestStabilityUtils.js'
+import * as KubernetesManifestUtility from '../utilities/manifestStabilityUtils'
 import {
    deleteGreenObjects,
    getManifestObjects,
    NONE_LABEL_VALUE
-} from '../strategyHelpers/blueGreen/blueGreenHelper.js'
+} from '../strategyHelpers/blueGreen/blueGreenHelper'
 
-import {BlueGreenManifests} from '../types/blueGreenTypes.js'
+import {BlueGreenManifests} from '../types/blueGreenTypes'
-import {DeployResult} from '../types/deployResult.js'
+import {DeployResult} from '../types/deployResult'
 
 import {
    promoteBlueGreenIngress,
    promoteBlueGreenService,
    promoteBlueGreenSMI
-} from '../strategyHelpers/blueGreen/promote.js'
+} from '../strategyHelpers/blueGreen/promote'
 
 import {
    routeBlueGreenService,
    routeBlueGreenIngressUnchanged,
    routeBlueGreenSMI
-} from '../strategyHelpers/blueGreen/route.js'
+} from '../strategyHelpers/blueGreen/route'
 
-import {cleanupSMI} from '../strategyHelpers/blueGreen/smiBlueGreenHelper.js'
+import {cleanupSMI} from '../strategyHelpers/blueGreen/smiBlueGreenHelper'
-import {Kubectl, Resource} from '../types/kubectl.js'
+import {Kubectl, Resource} from '../types/kubectl'
-import {DeploymentStrategy} from '../types/deploymentStrategy.js'
+import {DeploymentStrategy} from '../types/deploymentStrategy'
 import {
    parseTrafficSplitMethod,
    TrafficSplitMethod
-} from '../types/trafficSplitMethod.js'
+} from '../types/trafficSplitMethod'
-import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy.js'
+import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
-import {ClusterType} from '../inputUtils.js'
+import {ClusterType} from '../inputUtils'
 
 export async function promote(
    kubectl: Kubectl,

src/actions/reject.ts

@@ -1,20 +1,20 @@
 import * as core from '@actions/core'
-import * as canaryDeploymentHelper from '../strategyHelpers/canary/canaryHelper.js'
+import * as canaryDeploymentHelper from '../strategyHelpers/canary/canaryHelper'
-import * as SMICanaryDeploymentHelper from '../strategyHelpers/canary/smiCanaryHelper.js'
+import * as SMICanaryDeploymentHelper from '../strategyHelpers/canary/smiCanaryHelper'
-import {Kubectl} from '../types/kubectl.js'
+import {Kubectl} from '../types/kubectl'
-import {BlueGreenManifests} from '../types/blueGreenTypes.js'
+import {BlueGreenManifests} from '../types/blueGreenTypes'
 import {
    rejectBlueGreenIngress,
    rejectBlueGreenService,
    rejectBlueGreenSMI
-} from '../strategyHelpers/blueGreen/reject.js'
+} from '../strategyHelpers/blueGreen/reject'
-import {getManifestObjects} from '../strategyHelpers/blueGreen/blueGreenHelper.js'
+import {getManifestObjects} from '../strategyHelpers/blueGreen/blueGreenHelper'
-import {DeploymentStrategy} from '../types/deploymentStrategy.js'
+import {DeploymentStrategy} from '../types/deploymentStrategy'
 import {
    parseTrafficSplitMethod,
    TrafficSplitMethod
-} from '../types/trafficSplitMethod.js'
+} from '../types/trafficSplitMethod'
-import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy.js'
+import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
 
 export async function reject(
    kubectl: Kubectl,

src/inputUtils.test.ts

@@ -1,8 +1,5 @@
-import {parseResourceTypeInput} from './inputUtils.js'
+import {parseResourceTypeInput} from './inputUtils'
-import {
+import {ResourceTypeFleet, ResourceTypeManagedCluster} from './actions/deploy'
-   ResourceTypeFleet,
-   ResourceTypeManagedCluster
-} from './actions/deploy.js'
 
 describe('InputUtils', () => {
    describe('parseResourceTypeInput', () => {

src/inputUtils.ts

@@ -1,9 +1,6 @@
 import * as core from '@actions/core'
-import {parseAnnotations} from './types/annotations.js'
+import {parseAnnotations} from './types/annotations'
-import {
+import {ResourceTypeFleet, ResourceTypeManagedCluster} from './actions/deploy'
-   ResourceTypeFleet,
-   ResourceTypeManagedCluster
-} from './actions/deploy.js'
 
 export const inputAnnotations = parseAnnotations(
    core.getInput('annotations', {required: false})

src/run.ts

@@ -1,19 +1,19 @@
 import * as core from '@actions/core'
-import {getKubectlPath, Kubectl} from './types/kubectl.js'
+import {getKubectlPath, Kubectl} from './types/kubectl'
 import {
    deploy,
    ResourceTypeFleet,
    ResourceTypeManagedCluster
-} from './actions/deploy.js'
+} from './actions/deploy'
-import {ClusterType} from './inputUtils.js'
+import {ClusterType} from './inputUtils'
-import {promote} from './actions/promote.js'
+import {promote} from './actions/promote'
-import {reject} from './actions/reject.js'
+import {reject} from './actions/reject'
-import {Action, parseAction} from './types/action.js'
+import {Action, parseAction} from './types/action'
-import {parseDeploymentStrategy} from './types/deploymentStrategy.js'
+import {parseDeploymentStrategy} from './types/deploymentStrategy'
-import {getFilesFromDirectoriesAndURLs} from './utilities/fileUtils.js'
+import {getFilesFromDirectoriesAndURLs} from './utilities/fileUtils'
-import {PrivateKubectl} from './types/privatekubectl.js'
+import {PrivateKubectl} from './types/privatekubectl'
-import {parseResourceTypeInput} from './inputUtils.js'
+import {parseResourceTypeInput} from './inputUtils'
-import {parseDuration} from './utilities/durationUtils.js'
+import {parseDuration} from './utilities/durationUtils'
 
 export async function run() {
    // verify kubeconfig is set

src/strategyHelpers/blueGreen/blueGreenHelper.test.ts

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

src/strategyHelpers/blueGreen/deploy.test.ts

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

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.test.ts

@@ -1,27 +1,27 @@
-import {vi} from 'vitest'
+import {getManifestObjects, GREEN_LABEL_VALUE} from './blueGreenHelper'
-import {getManifestObjects, GREEN_LABEL_VALUE} from './blueGreenHelper.js'
+import * as bgHelper from './blueGreenHelper'
-import * as bgHelper from './blueGreenHelper.js'
 import {
    getUpdatedBlueGreenIngress,
    isIngressRouted,
    validateIngresses
-} from './ingressBlueGreenHelper.js'
+} from './ingressBlueGreenHelper'
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils.js'
+import * as fileHelper from '../../utilities/fileUtils'
 
 const betaFilepath = ['test/unit/manifests/test-ingress.yml']
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
 const kubectl = new Kubectl('')
-vi.mock('../../types/kubectl')
+jest.mock('../../types/kubectl')
 
 describe('ingress blue green helpers', () => {
    let testObjects
    beforeEach(() => {
-      vi.mocked(Kubectl).mockClear()
+      //@ts-ignore
+      Kubectl.mockClear()
       testObjects = getManifestObjects(ingressFilepath)
-      vi.spyOn(fileHelper, 'writeObjectsToFile').mockImplementationOnce(() => [
+      jest
-         ''
+         .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?
-      vi.spyOn(bgHelper, 'fetchResource').mockResolvedValue(null)
+      jest.spyOn(bgHelper, 'fetchResource').mockImplementation()
       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
-      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+      jest
-         Promise.resolve(mockIngress)
+         .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.js'
+import {K8sIngress} from '../../types/k8sObject'
 import {
    addBlueGreenLabelsAndAnnotations,
    BLUE_GREEN_VERSION_LABEL,
    GREEN_LABEL_VALUE,
    fetchResource
-} from './blueGreenHelper.js'
+} from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 
 const BACKEND = 'backend'
 

src/strategyHelpers/blueGreen/promote.test.ts

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

src/strategyHelpers/blueGreen/reject.test.ts

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

src/strategyHelpers/blueGreen/route.test.ts

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

src/strategyHelpers/blueGreen/route.ts

@@ -1,26 +1,26 @@
-import {sleep} from '../../utilities/timeUtils.js'
+import {sleep} from '../../utilities/timeUtils'
-import {RouteStrategy} from '../../types/routeStrategy.js'
+import {RouteStrategy} from '../../types/routeStrategy'
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import {
    BlueGreenDeployment,
    BlueGreenManifests
-} from '../../types/blueGreenTypes.js'
+} from '../../types/blueGreenTypes'
 import {
    getManifestObjects,
    GREEN_LABEL_VALUE,
    deployObjects
-} from './blueGreenHelper.js'
+} from './blueGreenHelper'
 
 import {
    getUpdatedBlueGreenIngress,
    isIngressRouted
-} from './ingressBlueGreenHelper.js'
+} from './ingressBlueGreenHelper'
-import {getUpdatedBlueGreenService} from './serviceBlueGreenHelper.js'
+import {getUpdatedBlueGreenService} from './serviceBlueGreenHelper'
-import {createTrafficSplitObject} from './smiBlueGreenHelper.js'
+import {createTrafficSplitObject} from './smiBlueGreenHelper'
 
 import * as core from '@actions/core'
-import {K8sObject, TrafficSplitObject} from '../../types/k8sObject.js'
+import {K8sObject, TrafficSplitObject} from '../../types/k8sObject'
-import {getBufferTime} from '../../inputUtils.js'
+import {getBufferTime} from '../../inputUtils'
 
 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.js'
+} from './blueGreenHelper'
-import * as bgHelper from './blueGreenHelper.js'
+import * as bgHelper from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import {
    getServiceSpecLabel,
    getUpdatedBlueGreenService,
    validateServicesState
-} from './serviceBlueGreenHelper.js'
+} from './serviceBlueGreenHelper'
 
 let testObjects
 const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-vi.mock('../../types/kubectl')
+jest.mock('../../types/kubectl')
 const kubectl = new Kubectl('')
 
 describe('blue/green service helper tests', () => {
    beforeEach(() => {
-      vi.mocked(Kubectl).mockClear()
+      //@ts-ignore
+      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
-      vi.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
+      jest.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.js'
+import {K8sServiceObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import {
    addBlueGreenLabelsAndAnnotations,
    BLUE_GREEN_VERSION_LABEL,
    fetchResource,
    GREEN_LABEL_VALUE
-} from './blueGreenHelper.js'
+} from './blueGreenHelper'
 
 // add green labels to configure existing service
 export function getUpdatedBlueGreenService(

src/strategyHelpers/blueGreen/smiBlueGreenHelper.test.ts

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

src/strategyHelpers/blueGreen/smiBlueGreenHelper.ts

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

src/strategyHelpers/canary/canaryHelper.ts

@@ -1,4 +1,4 @@
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import * as fs from 'fs'
 import * as yaml from 'js-yaml'
 import * as core from '@actions/core'
@@ -7,15 +7,15 @@ import {
    isDeploymentEntity,
    isServiceEntity,
    KubernetesWorkload
-} from '../../types/kubernetesTypes.js'
+} from '../../types/kubernetesTypes'
-import * as utils from '../../utilities/manifestUpdateUtils.js'
+import * as utils from '../../utilities/manifestUpdateUtils'
 import {
    updateObjectAnnotations,
    updateObjectLabels,
    updateSelectorLabels
-} from '../../utilities/manifestUpdateUtils.js'
+} from '../../utilities/manifestUpdateUtils'
-import {updateSpecLabels} from '../../utilities/manifestSpecLabelUtils.js'
+import {updateSpecLabels} from '../../utilities/manifestSpecLabelUtils'
-import {checkForErrors} from '../../utilities/kubectlUtils.js'
+import {checkForErrors} from '../../utilities/kubectlUtils'
 
 export const CANARY_VERSION_LABEL = 'workflow/version'
 const BASELINE_SUFFIX = '-baseline'

src/strategyHelpers/canary/podCanaryHelper.test.ts

@@ -1,15 +1,11 @@
-import {vi} from 'vitest'
-import type {MockInstance} from 'vitest'
-vi.mock('@actions/core')
-
 import * as core from '@actions/core'
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import {
    deployPodCanary,
    calculateReplicaCountForCanary
-} from './podCanaryHelper.js'
+} from './podCanaryHelper'
 
-vi.mock('../../types/kubectl')
+jest.mock('../../types/kubectl')
 
 const kc = new Kubectl('')
 
@@ -39,17 +35,18 @@ const TIMEOUT_300S = '300s'
 
 describe('Pod Canary Helper tests', () => {
    let mockFilePaths: string[]
-   let kubectlApplySpy: MockInstance
+   let kubectlApplySpy: jest.SpyInstance
 
    beforeEach(() => {
-      vi.mocked(Kubectl).mockClear()
+      //@ts-ignore
-      vi.restoreAllMocks()
+      Kubectl.mockClear()
+      jest.restoreAllMocks()
 
       mockFilePaths = testManifestFiles
-      kubectlApplySpy = vi.spyOn(kc, 'apply')
+      kubectlApplySpy = jest.spyOn(kc, 'apply')
 
       // Mock core.getInput with default values
-      vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+      jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
          switch (name) {
             case 'percentage':
                return VALID_PERCENTAGE.toString()
@@ -64,7 +61,7 @@ describe('Pod Canary Helper tests', () => {
    })
 
    afterEach(() => {
-      vi.restoreAllMocks()
+      jest.restoreAllMocks()
       kubectlApplySpy.mockClear()
    })
 
@@ -117,7 +114,7 @@ describe('Pod Canary Helper tests', () => {
       })
 
       test('should throw error for invalid low percentage', async () => {
-         vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+         jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
             if (name === 'percentage') return INVALID_LOW_PERCENTAGE.toString()
             return ''
          })
@@ -130,7 +127,7 @@ describe('Pod Canary Helper tests', () => {
       })
 
       test('should throw error for invalid high percentage', async () => {
-         vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+         jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
             if (name === 'percentage') return INVALID_HIGH_PERCENTAGE.toString()
             return ''
          })
@@ -146,7 +143,7 @@ describe('Pod Canary Helper tests', () => {
          kubectlApplySpy.mockResolvedValue(mockSuccessResult)
 
          // Test minimum valid percentage
-         vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+         jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
             if (name === 'percentage') return MIN_PERCENTAGE.toString()
             return ''
          })
@@ -155,7 +152,7 @@ describe('Pod Canary Helper tests', () => {
          expect(resultMin.execResult).toEqual(mockSuccessResult)
 
          // Test maximum valid percentage
-         vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+         jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
             if (name === 'percentage') return MAX_PERCENTAGE.toString()
             return ''
          })
@@ -165,7 +162,7 @@ describe('Pod Canary Helper tests', () => {
       })
 
       test('should handle force deployment option', async () => {
-         vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+         jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
             switch (name) {
                case 'percentage':
                   return VALID_PERCENTAGE.toString()
@@ -189,7 +186,7 @@ describe('Pod Canary Helper tests', () => {
       })
 
       test('should handle server-side apply option', async () => {
-         vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+         jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
             switch (name) {
                case 'percentage':
                   return VALID_PERCENTAGE.toString()

src/strategyHelpers/canary/podCanaryHelper.ts

@@ -1,15 +1,15 @@
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import * as core from '@actions/core'
 import * as fs from 'fs'
 import * as yaml from 'js-yaml'
 
-import * as fileHelper from '../../utilities/fileUtils.js'
+import * as fileHelper from '../../utilities/fileUtils'
-import * as canaryDeploymentHelper from './canaryHelper.js'
+import * as canaryDeploymentHelper from './canaryHelper'
-import {isDeploymentEntity} from '../../types/kubernetesTypes.js'
+import {isDeploymentEntity} from '../../types/kubernetesTypes'
-import {getReplicaCount} from '../../utilities/manifestUpdateUtils.js'
+import {getReplicaCount} from '../../utilities/manifestUpdateUtils'
-import {DeployResult} from '../../types/deployResult.js'
+import {DeployResult} from '../../types/deployResult'
-import {K8sObject} from '../../types/k8sObject.js'
+import {K8sObject} from '../../types/k8sObject'
-import {checkForErrors} from '../../utilities/kubectlUtils.js'
+import {checkForErrors} from '../../utilities/kubectlUtils'
 
 export async function deployPodCanary(
    filePaths: string[],

src/strategyHelpers/canary/smiCanaryHelper.test.ts

@@ -1,34 +1,13 @@
-import {vi} from 'vitest'
-import type {MockInstance} from 'vitest'
-vi.mock('@actions/core', async (importOriginal) => {
-   const actual: any = await importOriginal()
-   return {
-      ...actual,
-      getInput: vi.fn().mockReturnValue(''),
-      debug: vi.fn(),
-      info: vi.fn(),
-      warning: vi.fn(),
-      error: vi.fn(),
-      setFailed: vi.fn(),
-      setOutput: vi.fn(),
-      group: vi
-         .fn()
-         .mockImplementation(
-            async (_name: string, fn: () => Promise<void>) => await fn()
-         )
-   }
-})
-
 import * as core from '@actions/core'
 import * as fs from 'fs'
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import {
    deploySMICanary,
    redirectTrafficToCanaryDeployment,
    redirectTrafficToStableDeployment
-} from './smiCanaryHelper.js'
+} from './smiCanaryHelper'
 
-vi.mock('../../types/kubectl')
+jest.mock('../../types/kubectl')
 
 const kc = new Kubectl('')
 
@@ -61,21 +40,22 @@ const TIMEOUT_240S = '240s'
 
 describe('SMI Canary Helper tests', () => {
    let mockFilePaths: string[]
-   let kubectlApplySpy: MockInstance
+   let kubectlApplySpy: jest.SpyInstance
-   let kubectlExecuteCommandSpy: MockInstance
+   let kubectlExecuteCommandSpy: jest.SpyInstance
 
    beforeEach(() => {
-      vi.mocked(Kubectl).mockClear()
+      //@ts-ignore
-      vi.restoreAllMocks()
+      Kubectl.mockClear()
+      jest.restoreAllMocks()
 
       mockFilePaths = testManifestFiles
-      kubectlApplySpy = vi.spyOn(kc, 'apply')
+      kubectlApplySpy = jest.spyOn(kc, 'apply')
-      kubectlExecuteCommandSpy = vi
+      kubectlExecuteCommandSpy = jest
          .spyOn(kc, 'executeCommand')
          .mockResolvedValue(mockExecuteCommandResult)
 
       // Mock core.getInput with default values
-      vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+      jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
          switch (name) {
             case 'percentage':
                return '50'
@@ -92,7 +72,7 @@ describe('SMI Canary Helper tests', () => {
    })
 
    afterEach(() => {
-      vi.restoreAllMocks()
+      jest.restoreAllMocks()
       kubectlApplySpy.mockClear()
    })
 
@@ -126,7 +106,7 @@ describe('SMI Canary Helper tests', () => {
       })
 
       test('should handle custom replica count from input', async () => {
-         vi.spyOn(core, 'getInput').mockImplementation((name: string) => {
+         jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
             switch (name) {
                case 'baseline-and-canary-replicas':
                   return VALID_REPLICA_COUNT.toString()

src/strategyHelpers/canary/smiCanaryHelper.ts

@@ -1,20 +1,17 @@
-import {Kubectl} from '../../types/kubectl.js'
+import {Kubectl} from '../../types/kubectl'
 import * as core from '@actions/core'
 import * as fs from 'fs'
 import * as yaml from 'js-yaml'
 
-import * as fileHelper from '../../utilities/fileUtils.js'
+import * as fileHelper from '../../utilities/fileUtils'
-import * as kubectlUtils from '../../utilities/trafficSplitUtils.js'
+import * as kubectlUtils from '../../utilities/trafficSplitUtils'
-import * as canaryDeploymentHelper from './canaryHelper.js'
+import * as canaryDeploymentHelper from './canaryHelper'
-import * as podCanaryHelper from './podCanaryHelper.js'
+import * as podCanaryHelper from './podCanaryHelper'
-import {
+import {isDeploymentEntity, isServiceEntity} from '../../types/kubernetesTypes'
-   isDeploymentEntity,
+import {checkForErrors} from '../../utilities/kubectlUtils'
-   isServiceEntity
+import {inputAnnotations} from '../../inputUtils'
-} from '../../types/kubernetesTypes.js'
+import {DeployResult} from '../../types/deployResult'
-import {checkForErrors} from '../../utilities/kubectlUtils.js'
+import {K8sObject} from '../../types/k8sObject'
-import {inputAnnotations} from '../../inputUtils.js'
-import {DeployResult} from '../../types/deployResult.js'
-import {K8sObject} from '../../types/k8sObject.js'
 
 const TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX = '-workflow-rollout'
 const TRAFFIC_SPLIT_OBJECT = 'TrafficSplit'

src/strategyHelpers/deploymentHelper.ts

@@ -1,41 +1,41 @@
 import * as fs from 'fs'
 import * as yaml from 'js-yaml'
-import * as canaryDeploymentHelper from './canary/canaryHelper.js'
+import * as canaryDeploymentHelper from './canary/canaryHelper'
-import * as models from '../types/kubernetesTypes.js'
+import * as models from '../types/kubernetesTypes'
-import {isDeploymentEntity} from '../types/kubernetesTypes.js'
+import {isDeploymentEntity} from '../types/kubernetesTypes'
-import * as fileHelper from '../utilities/fileUtils.js'
+import * as fileHelper from '../utilities/fileUtils'
-import * as KubernetesManifestUtility from '../utilities/manifestStabilityUtils.js'
+import * as KubernetesManifestUtility from '../utilities/manifestStabilityUtils'
-import {Kubectl, Resource} from '../types/kubectl.js'
+import {Kubectl, Resource} from '../types/kubectl'
 
-import {deployPodCanary} from './canary/podCanaryHelper.js'
+import {deployPodCanary} from './canary/podCanaryHelper'
-import {deploySMICanary} from './canary/smiCanaryHelper.js'
+import {deploySMICanary} from './canary/smiCanaryHelper'
-import {DeploymentConfig} from '../types/deploymentConfig.js'
+import {DeploymentConfig} from '../types/deploymentConfig'
-import {deployBlueGreen} from './blueGreen/deploy.js'
+import {deployBlueGreen} from './blueGreen/deploy'
-import {DeploymentStrategy} from '../types/deploymentStrategy.js'
+import {DeploymentStrategy} from '../types/deploymentStrategy'
 import * as core from '@actions/core'
 import {
    parseTrafficSplitMethod,
    TrafficSplitMethod
-} from '../types/trafficSplitMethod.js'
+} from '../types/trafficSplitMethod'
-import {parseRouteStrategy} from '../types/routeStrategy.js'
+import {parseRouteStrategy} from '../types/routeStrategy'
 import {ExecOutput} from '@actions/exec'
 import {
    getWorkflowAnnotationKeyLabel,
    getWorkflowAnnotations,
    cleanLabel
-} from '../utilities/workflowAnnotationUtils.js'
+} from '../utilities/workflowAnnotationUtils'
 import {
    annotateChildPods,
    checkForErrors,
    getLastSuccessfulRunSha
-} from '../utilities/kubectlUtils.js'
+} from '../utilities/kubectlUtils'
 import {
    getWorkflowFilePath,
    normalizeWorkflowStrLabel
-} from '../utilities/githubUtils.js'
+} from '../utilities/githubUtils'
-import {getDeploymentConfig} from '../utilities/dockerUtils.js'
+import {getDeploymentConfig} from '../utilities/dockerUtils'
-import {DeployResult} from '../types/deployResult.js'
+import {DeployResult} from '../types/deployResult'
-import {ClusterType} from '../inputUtils.js'
+import {ClusterType} from '../inputUtils'
 
 export async function deployManifests(
    files: string[],

src/types/action.test.ts

@@ -1,4 +1,4 @@
-import {Action, parseAction} from './action.js'
+import {Action, parseAction} from './action'
 
 describe('Action type', () => {
    test('it has required values', () => {

src/types/blueGreenTypes.ts

@@ -1,5 +1,5 @@
-import {DeployResult} from './deployResult.js'
+import {DeployResult} from './deployResult'
-import {K8sObject, K8sDeleteObject} from './k8sObject.js'
+import {K8sObject, K8sDeleteObject} from './k8sObject'
 
 export interface BlueGreenDeployment {
    deployResult: DeployResult

src/types/deploymentStrategy.test.ts

@@ -1,7 +1,4 @@
-import {
+import {DeploymentStrategy, parseDeploymentStrategy} from './deploymentStrategy'
-   DeploymentStrategy,
-   parseDeploymentStrategy
-} from './deploymentStrategy.js'
 
 describe('Deployment strategy type', () => {
    test('it has required values', () => {

src/types/docker.test.ts

@@ -1,7 +1,4 @@
-import {vi} from 'vitest'
+import {DockerExec} from './docker'
-vi.mock('@actions/exec')
-
-import {DockerExec} from './docker.js'
 import * as actions from '@actions/exec'
 
 const dockerPath = 'dockerPath'
@@ -15,7 +12,7 @@ describe('Docker class', () => {
       const execReturn = {exitCode: 0, stdout: 'Output', stderr: ''}
 
       beforeEach(() => {
-         vi.spyOn(actions, 'getExecOutput').mockImplementation(async () => {
+         jest.spyOn(actions, 'getExecOutput').mockImplementation(async () => {
             return execReturn
          })
       })
@@ -63,7 +60,7 @@ describe('Docker class', () => {
       const execReturn = {exitCode: 3, stdout: '', stderr: ''}
 
       beforeEach(() => {
-         vi.spyOn(actions, 'getExecOutput').mockImplementation(async () => {
+         jest.spyOn(actions, 'getExecOutput').mockImplementation(async () => {
             return execReturn
          })
       })
@@ -83,7 +80,7 @@ describe('Docker class', () => {
       const execReturn = {exitCode: 0, stdout: '', stderr: 'Output'}
 
       beforeEach(() => {
-         vi.spyOn(actions, 'getExecOutput').mockImplementation(async () => {
+         jest.spyOn(actions, 'getExecOutput').mockImplementation(async () => {
             return execReturn
          })
       })

src/types/kubectl.test.ts

@@ -1,10 +1,4 @@
-import {vi} from 'vitest'
+import {getKubectlPath, Kubectl} from './kubectl'
-vi.mock('@actions/exec')
-vi.mock('@actions/io')
-vi.mock('@actions/core')
-vi.mock('@actions/tool-cache')
-
-import {getKubectlPath, Kubectl} from './kubectl.js'
 import * as exec from '@actions/exec'
 import * as io from '@actions/io'
 import * as core from '@actions/core'
@@ -15,27 +9,27 @@ describe('Kubectl path', () => {
    const path = 'path'
 
    it('gets the kubectl path', async () => {
-      vi.spyOn(core, 'getInput').mockImplementationOnce(() => '')
+      jest.spyOn(core, 'getInput').mockImplementationOnce(() => '')
-      vi.spyOn(io, 'which').mockImplementationOnce(async () => path)
+      jest.spyOn(io, 'which').mockImplementationOnce(async () => path)
 
       expect(await getKubectlPath()).toBe(path)
    })
 
    it('gets the kubectl path with version', async () => {
-      vi.spyOn(core, 'getInput').mockImplementationOnce(() => version)
+      jest.spyOn(core, 'getInput').mockImplementationOnce(() => version)
-      vi.spyOn(toolCache, 'find').mockImplementationOnce(() => path)
+      jest.spyOn(toolCache, 'find').mockImplementationOnce(() => path)
 
       expect(await getKubectlPath()).toBe(path)
    })
 
    it('throws if kubectl not found', async () => {
       // without version
-      vi.spyOn(io, 'which').mockImplementationOnce(async () => '')
+      jest.spyOn(io, 'which').mockImplementationOnce(async () => '')
       await expect(() => getKubectlPath()).rejects.toThrow()
 
       // with verision
-      vi.spyOn(core, 'getInput').mockImplementationOnce(() => '')
+      jest.spyOn(core, 'getInput').mockImplementationOnce(() => '')
-      vi.spyOn(io, 'which').mockImplementationOnce(async () => '')
+      jest.spyOn(io, 'which').mockImplementationOnce(async () => '')
       await expect(() => getKubectlPath()).rejects.toThrow()
    })
 })
@@ -52,7 +46,7 @@ describe('Kubectl class', () => {
       const mockExecReturn = {exitCode: 0, stdout: 'Output', stderr: ''}
 
       beforeEach(() => {
-         vi.spyOn(exec, 'getExecOutput').mockImplementation(async () => {
+         jest.spyOn(exec, 'getExecOutput').mockImplementation(async () => {
             return mockExecReturn
          })
       })
@@ -643,7 +637,7 @@ describe('Kubectl class', () => {
          stderr: ''
       }
 
-      vi.spyOn(exec, 'getExecOutput').mockImplementationOnce(async () => {
+      jest.spyOn(exec, 'getExecOutput').mockImplementationOnce(async () => {
          return describeReturn
       })
 
@@ -656,7 +650,7 @@ describe('Kubectl class', () => {
       const skipTls = true
       const kubectl = new Kubectl(kubectlPath, testNamespace, skipTls)
 
-      vi.spyOn(exec, 'getExecOutput').mockImplementation(async () => {
+      jest.spyOn(exec, 'getExecOutput').mockImplementation(async () => {
          return {exitCode: 0, stderr: '', stdout: ''}
       })
 
@@ -683,7 +677,7 @@ describe('Kubectl namespace handling', () => {
    const execReturn = {exitCode: 0, stdout: 'Output', stderr: ''}
 
    beforeEach(() => {
-      vi.spyOn(exec, 'getExecOutput').mockResolvedValue(execReturn)
+      jest.spyOn(exec, 'getExecOutput').mockResolvedValue(execReturn)
    })
 
    const runApply = async (namespace?: string) => {

src/types/kubectl.ts

@@ -1,5 +1,5 @@
 import {ExecOutput, getExecOutput} from '@actions/exec'
-import {createInlineArray} from '../utilities/arrayUtils.js'
+import {createInlineArray} from '../utilities/arrayUtils'
 import * as core from '@actions/core'
 import * as toolCache from '@actions/tool-cache'
 import * as io from '@actions/io'
@@ -238,17 +238,13 @@ export class Kubectl {
       })
    }
 
-   public getNamespace(namespaceOverride?: string): string {
-      return namespaceOverride || this.namespace
-   }
-
    protected getFlags(namespaceOverride?: string): string[] {
       const flags = []
       if (this.ignoreSSLErrors) {
          flags.push('--insecure-skip-tls-verify')
       }
 
-      const ns = this.getNamespace(namespaceOverride)
+      const ns = namespaceOverride || this.namespace
       if (ns) {
          flags.push('--namespace', ns)
       }

src/types/kubernetesTypes.test.ts

@@ -10,7 +10,7 @@ import {
    ServiceTypes,
    WORKLOAD_TYPES,
    WORKLOAD_TYPES_WITH_ROLLOUT_STATUS
-} from './kubernetesTypes.js'
+} from './kubernetesTypes'
 
 describe('Kubernetes types', () => {
    it('contains kubernetes workloads', () => {

src/types/privatekubectl.test.ts

@@ -1,13 +1,10 @@
-import {vi} from 'vitest'
+import * as fileUtils from '../utilities/fileUtils'
-vi.mock('@actions/exec')
-
-import * as fileUtils from '../utilities/fileUtils.js'
 import fs from 'node:fs'
 import {
    PrivateKubectl,
    extractFileNames,
    replaceFileNamesWithShallowNamesRelativeToTemp
-} from './privatekubectl.js'
+} from './privatekubectl'
 import * as exec from '@actions/exec'
 
 describe('Private kubectl', () => {
@@ -20,14 +17,14 @@ describe('Private kubectl', () => {
       'resourceName'
    )
 
-   const spy = vi
+   const spy = jest
       .spyOn(fileUtils, 'getTempDirectory')
       .mockImplementation(() => {
          return '/tmp'
       })
 
-   vi.spyOn(fs, 'writeFileSync').mockImplementation(() => {})
+   jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {})
-   vi.spyOn(fs, 'readFileSync').mockImplementation((filename) => {
+   jest.spyOn(fs, 'readFileSync').mockImplementation((filename) => {
       return 'test contents'
    })
 
@@ -51,7 +48,7 @@ describe('Private kubectl', () => {
 
    test('Should throw well defined Error on error from Azure', async () => {
       const errorMsg = 'An error message'
-      vi.spyOn(exec, 'getExecOutput').mockImplementation(async () => {
+      jest.spyOn(exec, 'getExecOutput').mockImplementation(async () => {
          return {exitCode: 1, stdout: '', stderr: errorMsg}
       })
 

src/types/privatekubectl.ts

@@ -1,10 +1,10 @@
-import {Kubectl} from './kubectl.js'
+import {Kubectl} from './kubectl'
 import minimist from 'minimist'
 import {ExecOptions, ExecOutput, getExecOutput} from '@actions/exec'
 import * as core from '@actions/core'
 import fs from 'node:fs'
 import * as path from 'path'
-import {getTempDirectory} from '../utilities/fileUtils.js'
+import {getTempDirectory} from '../utilities/fileUtils'
 
 export class PrivateKubectl extends Kubectl {
    protected async execute(args: string[], silent: boolean = false) {

src/types/routeStrategy.test.ts

@@ -1,4 +1,4 @@
-import {parseRouteStrategy, RouteStrategy} from './routeStrategy.js'
+import {parseRouteStrategy, RouteStrategy} from './routeStrategy'
 
 describe('Route strategy type', () => {
    test('it has required values', () => {

src/types/trafficSplitMethod.test.ts

@@ -1,7 +1,4 @@
-import {
+import {parseTrafficSplitMethod, TrafficSplitMethod} from './trafficSplitMethod'
-   parseTrafficSplitMethod,
-   TrafficSplitMethod
-} from './trafficSplitMethod.js'
 
 describe('Traffic split method type', () => {
    test('it has required values', () => {

src/utilities/arrayUtils.test.ts

@@ -1,4 +1,4 @@
-import {createInlineArray} from './arrayUtils.js'
+import {createInlineArray} from './arrayUtils'
 
 describe('array utilities', () => {
    it('creates an inline array', () => {

src/utilities/dockerUtils.test.ts

@@ -1,18 +1,15 @@
-import {vi} from 'vitest'
-vi.mock('@actions/io')
-
 import * as io from '@actions/io'
-import {checkDockerPath} from './dockerUtils.js'
+import {checkDockerPath} from './dockerUtils'
 
 describe('docker utilities', () => {
    it('checks if docker is installed', async () => {
       // docker installed
       const path = 'path'
-      vi.spyOn(io, 'which').mockImplementationOnce(async () => path)
+      jest.spyOn(io, 'which').mockImplementationOnce(async () => path)
       expect(() => checkDockerPath()).not.toThrow()
 
       // docker not installed
-      vi.spyOn(io, 'which').mockImplementationOnce(async () => {
+      jest.spyOn(io, 'which').mockImplementationOnce(async () => {
          throw new Error('not found')
       })
       await expect(() => checkDockerPath()).rejects.toThrow()

src/utilities/dockerUtils.ts

@@ -1,8 +1,8 @@
 import * as io from '@actions/io'
-import {DeploymentConfig} from '../types/deploymentConfig.js'
+import {DeploymentConfig} from '../types/deploymentConfig'
 import * as core from '@actions/core'
-import {DockerExec} from '../types/docker.js'
+import {DockerExec} from '../types/docker'
-import {getNormalizedPath} from './githubUtils.js'
+import {getNormalizedPath} from './githubUtils'
 
 export async function getDeploymentConfig(): Promise<DeploymentConfig> {
    let helmChartPaths: string[] =

src/utilities/durationUtils.test.ts

@@ -1,10 +1,9 @@
-import {vi, type Mocked} from 'vitest'
+import {parseDuration} from './durationUtils'
-import {parseDuration} from './durationUtils.js'
 import * as core from '@actions/core'
 
 // Mock core.debug
-vi.mock('@actions/core')
+jest.mock('@actions/core')
-const mockCore = core as Mocked<typeof core>
+const mockCore = core as jest.Mocked<typeof core>
 
 // Test data constants
 const VALID_TIMEOUTS = {
@@ -47,7 +46,7 @@ const expectInvalidTimeout = (input: string, expectedError: string) => {
 
 describe('validateTimeoutDuration', () => {
    beforeEach(() => {
-      vi.clearAllMocks()
+      jest.clearAllMocks()
    })
 
    describe('valid timeout formats', () => {
@@ -91,7 +90,7 @@ describe('validateTimeoutDuration', () => {
             'No unit specified for timeout "5", assuming minutes'
          )
 
-         vi.clearAllMocks()
+         jest.clearAllMocks()
 
          parseDuration('30s')
          expect(mockCore.debug).not.toHaveBeenCalled()

src/utilities/fileUtils.test.ts

@@ -1,10 +1,9 @@
-import {vi} from 'vitest'
+import * as fileUtils from './fileUtils'
-import * as fileUtils from './fileUtils.js'
 
 import * as yaml from 'js-yaml'
 import fs from 'node:fs'
 import * as path from 'path'
-import {K8sObject} from '../types/k8sObject.js'
+import {K8sObject} from '../types/k8sObject'
 
 const sampleYamlUrl =
    'https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/controllers/nginx-deployment.yaml'
@@ -70,7 +69,7 @@ describe('File utils', () => {
          'manifest_test_dir'
       )
 
-      await expect(
+      expect(
          fileUtils.getFilesFromDirectoriesAndURLs([badPath, goodPath])
       ).rejects.toThrow()
    })
@@ -109,8 +108,8 @@ describe('File utils', () => {
 
 describe('moving files to temp', () => {
    it('correctly moves the contents of a file to the temporary directory', () => {
-      vi.spyOn(fs, 'writeFileSync').mockImplementation(() => {})
+      jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {})
-      vi.spyOn(fs, 'readFileSync').mockImplementation((filename) => {
+      jest.spyOn(fs, 'readFileSync').mockImplementation((filename) => {
          return 'test contents'
       })
       const originalFilePath = path.join('path', 'in', 'repo')

src/utilities/fileUtils.ts

@@ -4,10 +4,10 @@ import * as path from 'path'
 import * as core from '@actions/core'
 import * as os from 'os'
 import * as yaml from 'js-yaml'
-import {Errorable, succeeded, failed, Failed} from '../types/errorable.js'
+import {Errorable, succeeded, failed, Failed} from '../types/errorable'
-import {getCurrentTime} from './timeUtils.js'
+import {getCurrentTime} from './timeUtils'
-import {isHttpUrl} from './githubUtils.js'
+import {isHttpUrl} from './githubUtils'
-import {K8sObject} from '../types/k8sObject.js'
+import {K8sObject} from '../types/k8sObject'
 
 export const urlFileKind = 'urlfile'
 

src/utilities/githubUtils.test.ts

@@ -2,7 +2,7 @@ import {
    getNormalizedPath,
    isHttpUrl,
    normalizeWorkflowStrLabel
-} from './githubUtils.js'
+} from './githubUtils'
 
 describe('Github utils', () => {
    it('normalizes workflow string labels', () => {

src/utilities/githubUtils.ts

@@ -1,4 +1,4 @@
-import {GitHubClient, OkStatusCode} from '../types/githubClient.js'
+import {GitHubClient, OkStatusCode} from '../types/githubClient'
 import * as core from '@actions/core'
 
 export async function getWorkflowFilePath(

src/utilities/kubectlUtils.test.ts

@@ -1,9 +1,6 @@
-import {vi} from 'vitest'
-vi.mock('@actions/core')
-
 import * as core from '@actions/core'
 import {ExecOutput} from '@actions/exec'
-import {checkForErrors} from './kubectlUtils.js'
+import {checkForErrors} from './kubectlUtils'
 
 describe('Kubectl utils', () => {
    it('checks for errors', () => {
@@ -42,8 +39,7 @@ describe('Kubectl utils', () => {
       ).toThrow()
 
       // with warn behavior
-      const warnSpy = vi.spyOn(core, 'warning').mockImplementation(() => {})
+      jest.spyOn(core, 'warning').mockImplementation(() => {})
-      warnSpy.mockClear()
       let warningCalls = 0
       expect(() => checkForErrors([success], true)).not.toThrow()
       expect(core.warning).toHaveBeenCalledTimes(warningCalls)

src/utilities/kubectlUtils.ts

@@ -1,6 +1,6 @@
 import * as core from '@actions/core'
 import {ExecOutput} from '@actions/exec'
-import {Kubectl} from '../types/kubectl.js'
+import {Kubectl} from '../types/kubectl'
 
 const NAMESPACE = 'namespace'
 

src/utilities/manifestPullSecretUtils.ts

@@ -1,4 +1,4 @@
-import {KubernetesWorkload} from '../types/kubernetesTypes.js'
+import {KubernetesWorkload} from '../types/kubernetesTypes'
 
 export function getImagePullSecrets(inputObject: any) {
    const kind = inputObject?.kind?.toLowerCase()

src/utilities/manifestSpecLabelUtils.ts

@@ -3,7 +3,7 @@ import {
    isServiceEntity,
    KubernetesWorkload,
    NullInputObjectError
-} from '../types/kubernetesTypes.js'
+} from '../types/kubernetesTypes'
 
 export function updateSpecLabels(
    inputObject: any,

src/utilities/manifestStabilityUtils.test.ts

@@ -1,29 +1,10 @@
-import {vi} from 'vitest'
+import * as manifestStabilityUtils from './manifestStabilityUtils'
-import type {MockInstance} from 'vitest'
+import {Kubectl} from '../types/kubectl'
-vi.mock('@actions/core', async (importOriginal) => {
+import {ResourceTypeFleet, ResourceTypeManagedCluster} from '../actions/deploy'
-   const actual: any = await importOriginal()
-   return {
-      ...actual,
-      getInput: vi.fn().mockReturnValue(''),
-      debug: vi.fn(),
-      info: vi.fn(),
-      warning: vi.fn(),
-      error: vi.fn(),
-      setFailed: vi.fn(),
-      setOutput: vi.fn()
-   }
-})
-
-import * as manifestStabilityUtils from './manifestStabilityUtils.js'
-import {Kubectl} from '../types/kubectl.js'
-import {
-   ResourceTypeFleet,
-   ResourceTypeManagedCluster
-} from '../actions/deploy.js'
 import {ExecOutput} from '@actions/exec'
 import {exitCode, stdout} from 'process'
 import * as core from '@actions/core'
-import * as timeUtils from './timeUtils.js'
+import * as timeUtils from './timeUtils'
 
 describe('manifestStabilityUtils', () => {
    const kc = new Kubectl('')
@@ -36,8 +17,8 @@ describe('manifestStabilityUtils', () => {
    ]
 
    it('should return immediately if the resource type is fleet', async () => {
-      const spy = vi.spyOn(manifestStabilityUtils, 'checkManifestStability')
+      const spy = jest.spyOn(manifestStabilityUtils, 'checkManifestStability')
-      const checkRolloutStatusSpy = vi.spyOn(kc, 'checkRolloutStatus')
+      const checkRolloutStatusSpy = jest.spyOn(kc, 'checkRolloutStatus')
       await manifestStabilityUtils.checkManifestStability(
          kc,
          resources,
@@ -49,8 +30,8 @@ describe('manifestStabilityUtils', () => {
    })
 
    it('should run fully if the resource type is managedCluster', async () => {
-      const spy = vi.spyOn(manifestStabilityUtils, 'checkManifestStability')
+      const spy = jest.spyOn(manifestStabilityUtils, 'checkManifestStability')
-      const checkRolloutStatusSpy = vi
+      const checkRolloutStatusSpy = jest
          .spyOn(kc, 'checkRolloutStatus')
          .mockImplementation(() => {
             return new Promise<ExecOutput>((resolve, reject) => {
@@ -73,7 +54,7 @@ describe('manifestStabilityUtils', () => {
 
    it('should pass timeout to checkRolloutStatus when provided', async () => {
       const timeout = '300s'
-      const checkRolloutStatusSpy = vi
+      const checkRolloutStatusSpy = jest
          .spyOn(kc, 'checkRolloutStatus')
          .mockImplementation(() => {
             return new Promise<ExecOutput>((resolve, reject) => {
@@ -101,7 +82,7 @@ describe('manifestStabilityUtils', () => {
    })
 
    it('should call checkRolloutStatus without timeout when not provided', async () => {
-      const checkRolloutStatusSpy = vi
+      const checkRolloutStatusSpy = jest
          .spyOn(kc, 'checkRolloutStatus')
          .mockImplementation(() => {
             return new Promise<ExecOutput>((resolve, reject) => {
@@ -130,76 +111,34 @@ describe('manifestStabilityUtils', () => {
 
 describe('checkManifestStability failure and resource-specific scenarios', () => {
    let kc: Kubectl
-   let coreErrorSpy: MockInstance
+   let coreErrorSpy: jest.SpyInstance
-   let coreInfoSpy: MockInstance
+   let coreInfoSpy: jest.SpyInstance
-   let coreWarningSpy: MockInstance
+   let coreWarningSpy: jest.SpyInstance
 
    beforeEach(() => {
-      kc = new Kubectl('', 'default')
+      kc = new Kubectl('')
-      coreErrorSpy = vi.spyOn(core, 'error').mockImplementation(() => {})
+      coreErrorSpy = jest.spyOn(core, 'error').mockImplementation()
-      coreInfoSpy = vi.spyOn(core, 'info').mockImplementation(() => {})
+      coreInfoSpy = jest.spyOn(core, 'info').mockImplementation()
-      coreWarningSpy = vi.spyOn(core, 'warning').mockImplementation(() => {})
+      coreWarningSpy = jest.spyOn(core, 'warning').mockImplementation()
    })
 
    afterEach(() => {
-      vi.restoreAllMocks()
+      jest.restoreAllMocks()
    })
 
    it('should call describe and collect errors when a rollout fails', async () => {
       const resources = [
-         {type: 'deployment', name: 'failing-app', namespace: 'app-ns-123'}
+         {type: 'deployment', name: 'failing-app', namespace: 'default'}
       ]
       const rolloutError = new Error('Progress deadline exceeded')
       const describeOutput =
          'Events:\n  Type\tReason\tMessage\n  Normal\tScalingReplicaSet\tScaled up replica set failing-app-123 to 1'
 
       // Arrange: Mock rollout to fail and describe to succeed
-      const checkRolloutStatusSpy = vi
+      const checkRolloutStatusSpy = jest
          .spyOn(kc, 'checkRolloutStatus')
          .mockRejectedValue(rolloutError)
-      const describeSpy = vi.spyOn(kc, 'describe').mockResolvedValue({
+      const describeSpy = jest.spyOn(kc, 'describe').mockResolvedValue({
-         stdout: describeOutput,
-         stderr: '',
-         exitCode: 0
-      })
-
-      // Act & Assert: Expect the function to throw the final aggregated error
-      const expectedErrorMessage = `Rollout failed for deployment/failing-app in namespace app-ns-123: ${rolloutError.message}`
-      await expect(
-         manifestStabilityUtils.checkManifestStability(
-            kc,
-            resources,
-            ResourceTypeManagedCluster
-         )
-      ).rejects.toThrow(
-         `Rollout status failed for the following resources:\n${expectedErrorMessage}`
-      )
-
-      // Assert that the correct functions were called
-      expect(checkRolloutStatusSpy).toHaveBeenCalledTimes(1)
-      expect(coreErrorSpy).toHaveBeenCalledWith(expectedErrorMessage)
-      expect(describeSpy).toHaveBeenCalledWith(
-         'deployment',
-         'failing-app',
-         false,
-         'app-ns-123'
-      )
-      expect(coreInfoSpy).toHaveBeenCalledWith(
-         `Describe output for deployment/failing-app:\n${describeOutput}`
-      )
-   })
-
-   it('should use the default kubectl namespace when none is provided', async () => {
-      const resources = [{type: 'deployment', name: 'failing-app'}]
-      const rolloutError = new Error('Progress deadline exceeded')
-      const describeOutput =
-         'Events:\n  Type\tReason\tMessage\n  Normal\tScalingReplicaSet\tScaled up replica set failing-app-123 to 1'
-
-      // Arrange: Mock rollout to fail and describe to succeed
-      const checkRolloutStatusSpy = vi
-         .spyOn(kc, 'checkRolloutStatus')
-         .mockRejectedValue(rolloutError)
-      const describeSpy = vi.spyOn(kc, 'describe').mockResolvedValue({
          stdout: describeOutput,
          stderr: '',
          exitCode: 0
@@ -224,7 +163,7 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
          'deployment',
          'failing-app',
          false,
-         undefined
+         'default'
       )
       expect(coreInfoSpy).toHaveBeenCalledWith(
          `Describe output for deployment/failing-app:\n${describeOutput}`
@@ -235,10 +174,10 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
       const resources = [{type: 'Pod', name: 'test-pod', namespace: 'default'}]
 
       // Arrange: Spy on checkPodStatus and checkRolloutStatus
-      const checkPodStatusSpy = vi
+      const checkPodStatusSpy = jest
          .spyOn(manifestStabilityUtils, 'checkPodStatus')
          .mockResolvedValue() // Assume pod becomes ready
-      const checkRolloutStatusSpy = vi.spyOn(kc, 'checkRolloutStatus')
+      const checkRolloutStatusSpy = jest.spyOn(kc, 'checkRolloutStatus')
 
       // Act
       await manifestStabilityUtils.checkManifestStability(
@@ -259,10 +198,10 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
       const podError = new Error('Pod rollout failed')
 
       // Arrange: Mock checkPodStatus to fail
-      const checkPodStatusSpy = vi
+      const checkPodStatusSpy = jest
          .spyOn(manifestStabilityUtils, 'checkPodStatus')
          .mockRejectedValue(podError)
-      const describeSpy = vi.spyOn(kc, 'describe').mockResolvedValue({
+      const describeSpy = jest.spyOn(kc, 'describe').mockResolvedValue({
          stdout: 'describe output',
          stderr: '',
          exitCode: 0
@@ -290,7 +229,7 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
 
    it('should wait for external IP for a LoadBalancer service', async () => {
       //Spying on sleep to avoid actual delays in tests
-      vi.spyOn(timeUtils, 'sleep').mockResolvedValue(undefined)
+      jest.spyOn(timeUtils, 'sleep').mockResolvedValue(undefined)
       const resources = [
          {type: 'service', name: 'test-svc', namespace: 'default'}
       ]
@@ -304,7 +243,7 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
       }
 
       // Arrange: Mock getResource to simulate the IP being assigned on the second poll
-      const getResourceSpy = vi
+      const getResourceSpy = jest
          .spyOn(kc, 'getResource')
          // First call: Initial service check
          .mockResolvedValueOnce({
@@ -347,10 +286,10 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
 
       // Arrange: Mock getService to fail, and describe to succeed
       // Note: We mock getResource because getService is a private helper
-      const getResourceSpy = vi
+      const getResourceSpy = jest
          .spyOn(kc, 'getResource')
          .mockRejectedValue(getServiceError)
-      const describeSpy = vi.spyOn(kc, 'describe').mockResolvedValue({
+      const describeSpy = jest.spyOn(kc, 'describe').mockResolvedValue({
          stdout: 'describe output',
          stderr: '',
          exitCode: 0
@@ -388,7 +327,7 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
       }
 
       // Arrange
-      const getResourceSpy = vi.spyOn(kc, 'getResource').mockResolvedValue({
+      const getResourceSpy = jest.spyOn(kc, 'getResource').mockResolvedValue({
          stdout: JSON.stringify(clusterIpService),
          stderr: '',
          exitCode: 0
@@ -411,19 +350,19 @@ describe('checkManifestStability failure and resource-specific scenarios', () =>
 
 describe('checkManifestStability additional scenarios', () => {
    let kc: Kubectl
-   let coreErrorSpy: MockInstance
+   let coreErrorSpy: jest.SpyInstance
-   let coreInfoSpy: MockInstance
+   let coreInfoSpy: jest.SpyInstance
-   let coreWarningSpy: MockInstance
+   let coreWarningSpy: jest.SpyInstance
 
    beforeEach(() => {
       kc = new Kubectl('')
-      coreErrorSpy = vi.spyOn(core, 'error').mockImplementation(() => {})
+      coreErrorSpy = jest.spyOn(core, 'error').mockImplementation()
-      coreInfoSpy = vi.spyOn(core, 'info').mockImplementation(() => {})
+      coreInfoSpy = jest.spyOn(core, 'info').mockImplementation()
-      coreWarningSpy = vi.spyOn(core, 'warning').mockImplementation(() => {})
+      coreWarningSpy = jest.spyOn(core, 'warning').mockImplementation()
    })
 
    afterEach(() => {
-      vi.restoreAllMocks()
+      jest.restoreAllMocks()
    })
 
    it('should aggregate errors from deployment and pod failures', async () => {
@@ -435,15 +374,15 @@ describe('checkManifestStability additional scenarios', () => {
       const podError = new Error('Pod not ready in time')
 
       // Arrange: Mock failures
-      const checkRolloutStatusSpy = vi
+      const checkRolloutStatusSpy = jest
          .spyOn(kc, 'checkRolloutStatus')
          .mockRejectedValue(deploymentError)
       // For pod: simulate a pod check failure
-      const checkPodStatusSpy = vi
+      const checkPodStatusSpy = jest
          .spyOn(manifestStabilityUtils, 'checkPodStatus')
          .mockRejectedValue(podError)
       // For both, simulate a successful describe call to provide additional details
-      const describeSpy = vi.spyOn(kc, 'describe').mockResolvedValue({
+      const describeSpy = jest.spyOn(kc, 'describe').mockResolvedValue({
          stdout: 'describe aggregated output',
          stderr: '',
          exitCode: 0
@@ -482,25 +421,25 @@ describe('checkManifestStability additional scenarios', () => {
 
       // Arrange:
       // Deployment rollout succeeds
-      vi.spyOn(kc, 'checkRolloutStatus').mockResolvedValue({
+      jest.spyOn(kc, 'checkRolloutStatus').mockResolvedValue({
          exitCode: 0,
          stderr: '',
          stdout: ''
       })
       // Pod becomes ready
-      vi.spyOn(manifestStabilityUtils, 'checkPodStatus').mockResolvedValue()
+      jest.spyOn(manifestStabilityUtils, 'checkPodStatus').mockResolvedValue()
       // Simulate a LoadBalancer service that already has an external IP
       const stableService = {
          spec: {type: 'LoadBalancer'},
          status: {loadBalancer: {ingress: [{ip: '1.2.3.4'}]}}
       }
-      vi.spyOn(kc, 'getResource').mockResolvedValue({
+      jest.spyOn(kc, 'getResource').mockResolvedValue({
          stdout: JSON.stringify(stableService),
          stderr: '',
          exitCode: 0
       })
       // Provide a describe result to avoid warnings
-      vi.spyOn(kc, 'describe').mockResolvedValue({
+      jest.spyOn(kc, 'describe').mockResolvedValue({
          stdout: 'describe output stable',
          stderr: '',
          exitCode: 0

src/utilities/manifestStabilityUtils.ts

@@ -1,10 +1,10 @@
 import * as core from '@actions/core'
-import * as KubernetesConstants from '../types/kubernetesTypes.js'
+import * as KubernetesConstants from '../types/kubernetesTypes'
-import {Kubectl, Resource} from '../types/kubectl.js'
+import {Kubectl, Resource} from '../types/kubectl'
-import {checkForErrors} from './kubectlUtils.js'
+import {checkForErrors} from './kubectlUtils'
-import {sleep} from './timeUtils.js'
+import {sleep} from './timeUtils'
-import {ResourceTypeFleet} from '../actions/deploy.js'
+import {ResourceTypeFleet} from '../actions/deploy'
-import {ClusterType} from '../inputUtils.js'
+import {ClusterType} from '../inputUtils'
 
 const IS_SILENT = false
 const POD = 'pod'
@@ -46,7 +46,7 @@ export async function checkManifestStability(
             )
             checkForErrors([result])
          } catch (ex) {
-            const errorMessage = `Rollout failed for ${resource.type}/${resource.name} in namespace ${kubectl.getNamespace(resource.namespace)}: ${ex.message || ex}`
+            const errorMessage = `Rollout failed for ${resource.type}/${resource.name} in namespace ${resource.namespace}: ${ex.message || ex}`
             core.error(errorMessage)
             rolloutErrors.push(errorMessage)
 
@@ -106,7 +106,7 @@ export async function checkManifestStability(
                }
             }
          } catch (ex) {
-            const errorMessage = `Could not determine service status of: ${resource.name} in namespace ${kubectl.getNamespace(resource.namespace)}. Error: ${ex.message || ex}`
+            const errorMessage = `Could not determine service status of: ${resource.name} in namespace ${resource.namespace}. Error: ${ex.message || ex}`
             core.warning(errorMessage)
 
             try {

src/utilities/manifestUpdateUtils.test.ts

@@ -1,17 +1,14 @@
-import {vi} from 'vitest'
+import * as fileUtils from './fileUtils'
-vi.mock('fs')
+import * as manifestUpdateUtils from './manifestUpdateUtils'
-
-import * as fileUtils from './fileUtils.js'
-import * as manifestUpdateUtils from './manifestUpdateUtils.js'
 import * as path from 'path'
 import * as fs from 'fs'
 
 describe('manifestUpdateUtils', () => {
-   vi.spyOn(fileUtils, 'moveFileToTmpDir').mockImplementation((filename) => {
+   jest.spyOn(fileUtils, 'moveFileToTmpDir').mockImplementation((filename) => {
       return path.join('/tmp', filename)
    })
-   vi.spyOn(fs, 'writeFileSync').mockImplementation(() => {})
+   jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {})
-   vi.spyOn(fs, 'readFileSync').mockImplementation((filename) => {
+   jest.spyOn(fs, 'readFileSync').mockImplementation((filename) => {
       return 'test contents'
    })
 

src/utilities/manifestUpdateUtils.ts

@@ -2,25 +2,25 @@ import * as core from '@actions/core'
 import * as fs from 'fs'
 import * as yaml from 'js-yaml'
 import * as path from 'path'
-import * as fileHelper from './fileUtils.js'
+import * as fileHelper from './fileUtils'
-import {moveFileToTmpDir} from './fileUtils.js'
+import {moveFileToTmpDir} from './fileUtils'
 import {
    InputObjectKindNotDefinedError,
    InputObjectMetadataNotDefinedError,
    isWorkloadEntity,
    KubernetesWorkload,
    NullInputObjectError
-} from '../types/kubernetesTypes.js'
+} from '../types/kubernetesTypes'
 import {
    getSpecSelectorLabels,
    setSpecSelectorLabels
-} from './manifestSpecLabelUtils.js'
+} from './manifestSpecLabelUtils'
 import {
    getImagePullSecrets,
    setImagePullSecrets
-} from './manifestPullSecretUtils.js'
+} from './manifestPullSecretUtils'
-import {Resource} from '../types/kubectl.js'
+import {Resource} from '../types/kubectl'
-import {K8sObject} from '../types/k8sObject.js'
+import {K8sObject} from '../types/k8sObject'
 
 export function updateManifestFiles(manifestFilePaths: string[]) {
    if (manifestFilePaths?.length === 0) {

src/utilities/scaledjob.test.ts

@@ -1,12 +1,11 @@
 import {
    getImagePullSecrets,
    setImagePullSecrets
-} from './manifestPullSecretUtils.js'
+} from './manifestPullSecretUtils'
-import {updateSpecLabels} from './manifestSpecLabelUtils.js'
+import {updateSpecLabels} from './manifestSpecLabelUtils'
-import {getReplicaCount} from './manifestUpdateUtils.js'
+import {getReplicaCount} from './manifestUpdateUtils'
 import * as yaml from 'js-yaml'
 import * as fs from 'fs'
-import {isWorkloadEntity, isDeploymentEntity} from '../types/kubernetesTypes.js'
 
 describe('ScaledJob Support', () => {
    let scaledJobObject: any
@@ -58,11 +57,13 @@ describe('ScaledJob Support', () => {
 
    describe('Workload Classification', () => {
       it('should classify ScaledJob as workload entity', () => {
+         const {isWorkloadEntity} = require('../types/kubernetesTypes')
          expect(isWorkloadEntity('ScaledJob')).toBe(true)
          expect(isWorkloadEntity('scaledjob')).toBe(true)
       })
 
       it('should not classify ScaledJob as deployment entity', () => {
+         const {isDeploymentEntity} = require('../types/kubernetesTypes')
          expect(isDeploymentEntity('scaledjob')).toBe(false)
          expect(isDeploymentEntity('ScaledJob')).toBe(false)
       })

src/utilities/trafficSplitUtils.ts

@@ -1,4 +1,4 @@
-import {Kubectl} from '../types/kubectl.js'
+import {Kubectl} from '../types/kubectl'
 
 const trafficSplitAPIVersionPrefix = 'split.smi-spec.io'
 

src/utilities/workflowAnnotationUtils.test.ts

@@ -2,7 +2,7 @@ import {
    cleanLabel,
    removeInvalidLabelCharacters,
    VALID_LABEL_REGEX
-} from '../utilities/workflowAnnotationUtils.js'
+} from '../utilities/workflowAnnotationUtils'
 
 describe('WorkflowAnnotationUtils', () => {
    describe('cleanLabel', () => {

src/utilities/workflowAnnotationUtils.ts

@@ -1,4 +1,4 @@
-import {DeploymentConfig} from '../types/deploymentConfig.js'
+import {DeploymentConfig} from '../types/deploymentConfig'
 
 const ANNOTATION_PREFIX = 'actions.github.com'
 

tsconfig.json

@@ -1,15 +1,8 @@
 {
    "compilerOptions": {
-      "target": "ES2020",
+      "target": "ES6",
-      "module": "NodeNext",
+      "module": "commonjs",
-      "moduleResolution": "NodeNext",
+      "esModuleInterop": true
-      "types": ["vitest/globals"],
-      "esModuleInterop": true,
-      "strict": false,
-      "skipLibCheck": true,
-      "resolveJsonModule": true,
-      "declaration": false,
-      "sourceMap": true
    },
-   "exclude": ["node_modules", "test", "lib"]
+   "exclude": ["node_modules", "test", "src/**/*.test.ts"]
 }

vitest.config.ts

@@ -1,11 +0,0 @@
-import {defineConfig} from 'vitest/config'
-
-export default defineConfig({
-   test: {
-      globals: true,
-      environment: 'node',
-      include: ['**/*.test.ts'],
-      testTimeout: 9000,
-      clearMocks: true
-   }
-})