test-all-packages.yml

name: Test all Packages

# run on all PRs (even the ones that target other branches)

on:
  pull_request:
  merge_group:
  push:
    branches: [master]

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
env:
  AGORIC_AVA_USE_TAP: true
  TEST_COLLECT: 'tee -a _testoutput.txt'
  NODE_V8_COVERAGE: coverage
# this is required, since explicitly setting bash as shell enables pipefail, which is not
# on by default.  This is required to fail correctly when teeing output to a file to collect
# test instrumentation
defaults:
  run:
    shell: bash

# set ESM_DISABLE_CACHE=true (will be JSON parsed)
jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: ['16.x', '18.x']
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: 'true'
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ matrix.node-version }}

  ##################
  # Lint tests
  # We run per package bc of https://github.com/typescript-eslint/typescript-eslint/issues/1192
  # We split the package tests into two jobs because type linting
  # is inefficient and slow https://github.com/typescript-eslint/typescript-eslint/issues/2094
  lint-primary:
    timeout-minutes: 10
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: '18.x'

      # first job also does repo-level linting
      - name: lint repo format
        run: yarn lint:format
      # eslint
      - name: yarn lint primary
        run: ./scripts/lint-with-types.sh primary

  lint-rest:
    timeout-minutes: 10
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: '18.x'

      - name: yarn lint rest
        run: ./scripts/lint-with-types.sh rest

  ##################
  # Fast-running tests run as a group:
  test-quick:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV

      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE

      # We run separate steps for each package, to make it easier to drill down
      # into errors. If we wanted to just run everything, run 'yarn test' from
      # the top level.
      #
      # This list should include all packages, except ones that are in another
      #  category here, or that don't have a package.json.
      #- name: yarn test (everything)
      #  run: yarn ${{ steps.vars.outputs.test }}
      - name: yarn test (access-token)
        run: cd packages/access-token && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (assert)
        run: cd packages/assert && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (deployment)
        run: cd packages/deployment && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (ERTP)
        run: cd packages/ERTP && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (governance)
        run: cd packages/governance && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (import-manager)
        run: cd packages/import-manager && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (notifier)
        run: cd packages/notifier && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (same-structure)
        run: cd packages/same-structure && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (sharing-service)
        run: cd packages/sharing-service && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (sparse-ints)
        run: cd packages/sparse-ints && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (spawner)
        run: cd packages/spawner && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (stat-logger)
        run: cd packages/stat-logger && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (store)
        run: cd packages/store && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swing-store)
        run: cd packages/swing-store && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (web-components)
        run: cd packages/web-components && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (wallet-connection)
        run: cd packages/wallet-connection && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (cosmic-proto)
        run: cd packages/cosmic-proto && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-quick2:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV
      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (agoric-cli)
        run: cd packages/agoric-cli && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (cosmos)
        run: cd golang/cosmos && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (cache)
        run: cd packages/cache && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (casting)
        run: cd packages/casting && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (internal)
        run: cd packages/internal && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (pegasus)
        run: cd packages/pegasus && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (smart-wallet)
        run: cd packages/smart-wallet && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swingset-runner)
        run: cd packages/swingset-runner && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (telemetry)
        run: cd packages/telemetry && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (deploy-script-support)
        run: cd packages/deploy-script-support && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (ui-components)
        run: cd packages/ui-components && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (wallet)
        run: cd packages/wallet && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (wallet/api)
        run: cd packages/wallet/api && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (eslint-config)
        run: cd packages/eslint-config && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (vat-data)
        run: cd packages/vat-data && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (time)
        run: cd packages/time && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swingset-liveslots)
        run: cd packages/swingset-liveslots && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swingset-xsnap-supervisor)
        run: cd packages/swingset-xsnap-supervisor && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (zone)
        run: cd packages/zone && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT

        # The meta-test!
      - name: Check for untested packages
        run: node ./scripts/check-untested-packages.mjs

      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  ##############
  # Long-running tests are executed individually.
  test-solo:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # test:xs is noop in solo/package.json
        engine: ['16.x', '18.x']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV

      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (solo)
        run: cd packages/solo && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-cosmic-swingset:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # test:xs is noop in cosmic-swingset/package.json
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV

      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - uses: ./.github/actions/restore-golang
        with:
          go-version: '1.20'
      - name: yarn test (cosmic-swingset)
        run: cd packages/cosmic-swingset && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-inter-protocol:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # test:xs is noop in inter-protocol/package.json
        engine: ['16.x', '18.x']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV

      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (inter-protocol)
        run: cd packages/inter-protocol && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-vats:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV

      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (vats)
        run: cd packages/vats && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  # The test-swingset* tests are split by alphabetical test name.
  test-swingset:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV

      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (SwingSet)
        run: cd packages/SwingSet && yarn ${{ steps.vars.outputs.test }} 'test/**/test-[A-Da-d]*.js' | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-swingset2:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV

      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (SwingSet)
        run: cd packages/SwingSet && yarn ${{ steps.vars.outputs.test }} 'test/**/test-[E-Ie-i]*.js' | $TEST_COLLECT
      - name: yarn test (xsnap-lockdown)
        run: cd packages/xsnap-lockdown && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (xsnap)
        run: cd packages/xsnap && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      # explicitly test the XS worker, for visibility
      - name: yarn test (SwingSet XS Worker)
        if: matrix.engine != 'xs'
        run: cd packages/SwingSet && yarn test:xs-worker | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-swingset3:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV
      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (SwingSet)
        run: cd packages/SwingSet && yarn ${{ steps.vars.outputs.test }} 'test/**/test-[J-Rj-r]*.js' | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-swingset4:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs' || 'test' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV
      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE

      - name: yarn test (SwingSet)
        run: cd packages/SwingSet && yarn ${{ steps.vars.outputs.test }} 'test/**/test-[S-Zs-z0-9]*.js' | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-zoe-unit:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        # END-TEST-BOILERPLATE
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs-unit' || 'test:unit' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV
        # BEGIN-TEST-BOILERPLATE
      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (zoe)
        timeout-minutes: 30
        run: cd packages/zoe && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-zoe-swingset:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['16.x', '18.x', 'xs']
    steps:
      - name: set vars
        id: vars
        # END-TEST-BOILERPLATE
        run: |
          echo "node-version=${{ matrix.engine == 'xs' && '18.x' || matrix.engine }}" >> $GITHUB_OUTPUT
          echo "test=${{ matrix.engine == 'xs' && 'test:xs-worker' || 'test:swingset' }}" >> $GITHUB_OUTPUT
          echo "GH_ENGINE=${{ matrix.engine }}" >> $GITHUB_ENV
        # BEGIN-TEST-BOILERPLATE
      - uses: actions/checkout@v3
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (zoe)
        timeout-minutes: 30
        run: cd packages/zoe && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}
          codecov-token: ${{ secrets.CODECOV_TOKEN }}

  test-docker-build:
    runs-on: ubuntu-latest
    timeout-minutes: 60
    steps:
      - name: free up additional worker space
        run: |
          # Workaround to provide additional free space for testing.
          #   https://github.com/actions/virtual-environments/issues/2840
          df -h
          sudo rm -rf /usr/share/dotnet
          sudo rm -rf /opt/ghc
          sudo rm -rf "/usr/local/share/boost"
          sudo rm -rf "$AGENT_TOOLSDIRECTORY"
          df -h

      - uses: actions/checkout@v3
      - name: docker build (sdk)
        # run: cd packages/deployment && ./scripts/test-docker-build.sh | $TEST_COLLECT
        # XXX skip TAP test output and collection for now; it hides the output from the logs
        run: cd packages/deployment && make docker-build-sdk
      - name: docker build upgrade test
        run: cd packages/deployment/upgrade-test && docker build --build-arg DEST_IMAGE=ghcr.io/agoric/agoric-sdk:latest -t docker-upgrade-test:latest -f Dockerfile upgrade-test-scripts
      - name: docker run upgrade final stage
        run: docker run --env "DEST=0" docker-upgrade-test:latest
      - uses: ./.github/actions/post-test
        if: (success() || failure())
        continue-on-error: true
        timeout-minutes: 4
        with:
          datadog-token: ${{ secrets.DATADOG_API_KEY }}