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]
  schedule:
    # We start a little earlier to give our build cache time to populate.
    - cron: '47 5 * * *'

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: ['18.x', '20.x']
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: 'true'
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ matrix.node-version }}

  dependency-graph:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install graphviz
        run: sudo apt install -y graphviz

      # This is now redundant with Lerna's --reject-cycles but keep it here so we have
      # test coverage of this script we use for visualizing the dep graph.
      - name: Check for cycles
        run: scripts/check-dependency-cycles.sh

      # install node_modules
      - uses: ./.github/actions/restore-node

      # Releasing SDK builds all packages in this order during `lerna publish`.
      # Due to ambient types, certain build orders (from the dependency graph)
      # may break the type resolution. Run this in the PR to find out before
      # attempting to merge to master. This takes about 1min locally and since
      # this job is about 30s in CI doing it here doesn't add to wall wait for
      # CI resolution.
      #
      # We prepack only because full pack removes the declarations, relying on
      # ambient resolution in the repo filesystem which will not be available
      # when the packages are pulled from npm.
      #
      # After that test, we postpack to avoid putting the prepack artifacts in
      # the cache maintained by restore-node, since they are not .gitignored and
      # thus will fail restore-node's check for a clean repo when the cache is
      # restored.
      - name: Pack packages without ambient type resolution
        run: |
          yarn lerna run --reject-cycles --concurrency 1 prepack
          yarn lerna run postpack

  ##################
  # 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: 15
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - 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
      # build the API docs to verify it works
      - name: build API docs
        run: yarn docs
      # build the API docs in markdown for agoric/documentation repo to verify it works
      - name: build API docs in markdown
        run: yarn docs:markdown-for-agoric-documentation-repo

  lint-rest:
    timeout-minutes: 15
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - 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: ['18.x', '20.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@v4
      - 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)
        if: (success() || failure())
        run: cd packages/access-token && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (benchmark)
        if: (success() || failure())
        run: cd packages/benchmark && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (deployment)
        if: (success() || failure())
        run: cd packages/deployment && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (ERTP)
        if: (success() || failure())
        run: cd packages/ERTP && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (import-manager)
        if: (success() || failure())
        run: cd packages/import-manager && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (notifier)
        if: (success() || failure())
        run: cd packages/notifier && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (orchestration)
        if: (success() || failure())
        run: cd packages/orchestration && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (sparse-ints)
        if: (success() || failure())
        run: cd packages/sparse-ints && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (spawner)
        if: (success() || failure())
        run: cd packages/spawner && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (stat-logger)
        if: (success() || failure())
        run: cd packages/stat-logger && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (store)
        if: (success() || failure())
        run: cd packages/store && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swing-store)
        if: (success() || failure())
        run: cd packages/swing-store && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (cosmic-proto)
        if: (success() || failure())
        run: cd packages/cosmic-proto && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (vow)
        if: (success() || failure())
        run: cd packages/vow && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (xsnap-lockdown)
        if: (success() || failure())
        run: cd packages/xsnap-lockdown && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (xsnap)
        if: (success() || failure())
        run: cd packages/xsnap && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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: ['18.x', '20.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@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (agoric-cli)
        if: (success() || failure())
        run: cd packages/agoric-cli && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (async-flow)
        if: (success() || failure())
        run: cd packages/async-flow && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (base-zone)
        if: (success() || failure())
        run: cd packages/base-zone && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (builders)
        if: (success() || failure())
        run: cd packages/builders && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (cosmos)
        if: (success() || failure())
        run: cd golang/cosmos && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (cache)
        if: (success() || failure())
        run: cd packages/cache && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (casting)
        if: (success() || failure())
        run: cd packages/casting && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (create-dapp)
        run: cd packages/create-dapp && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (internal)
        if: (success() || failure())
        run: cd packages/internal && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (kmarshal)
        if: (success() || failure())
        run: cd packages/kmarshal && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (network)
        if: (success() || failure())
        run: cd packages/network && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (pegasus)
        if: (success() || failure())
        run: cd packages/pegasus && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (smart-wallet)
        if: (success() || failure())
        run: cd packages/smart-wallet && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swingset-runner)
        if: (success() || failure())
        run: cd packages/swingset-runner && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (telemetry)
        if: (success() || failure())
        run: cd packages/telemetry && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (deploy-script-support)
        if: (success() || failure())
        run: cd packages/deploy-script-support && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (wallet)
        if: (success() || failure())
        run: cd packages/wallet && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (wallet/api)
        if: (success() || failure())
        run: cd packages/wallet/api && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (eslint-config)
        if: (success() || failure())
        run: cd packages/eslint-config && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (vat-data)
        if: (success() || failure())
        run: cd packages/vat-data && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (time)
        if: (success() || failure())
        run: cd packages/time && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swingset-liveslots)
        if: (success() || failure())
        run: cd packages/swingset-liveslots && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (swingset-xsnap-supervisor)
        if: (success() || failure())
        run: cd packages/swingset-xsnap-supervisor && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (vats)
        if: (success() || failure())
        run: cd packages/vats && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (vm-config)
        if: (success() || failure())
        run: cd packages/vm-config && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: yarn test (zone)
        if: (success() || failure())
        run: cd packages/zone && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT

        # The meta-test!
      - name: Check for untested packages
        if: (success() || failure())
        run: node ./scripts/check-untested-packages.mjs

      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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-governance:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # test:xs is noop in governance/package.json
        engine: ['18.x', '20.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@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (governance)
        if: (success() || failure())
        run: cd packages/governance && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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-solo:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # test:xs is noop in solo/package.json
        engine: ['18.x', '20.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@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (solo)
        if: (success() || failure())
        run: cd packages/solo && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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: ['18.x', '20.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@v4
      - 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)
        if: (success() || failure())
        run: cd packages/cosmic-swingset && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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: ['18.x', '20.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@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (inter-protocol)
        if: (success() || failure())
        run: cd packages/inter-protocol && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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-boot:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 40
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['18.x', '20.x', 'xs']
        # Run parallel testing jobs, each executing a subset.
        node_index: [0, 1, 2, 3]
        total_nodes: [4] # the total number of nodes
    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
          echo "CI_NODE_INDEX=${{ matrix.node_index }}" >> $GITHUB_ENV
          echo "CI_NODE_TOTAL=${{ matrix.total_nodes }}" >> $GITHUB_ENV

      - uses: actions/checkout@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (boot)
        if: (success() || failure())
        run: cd packages/boot && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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-swingset:
    # BEGIN-TEST-BOILERPLATE
    timeout-minutes: 30
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        engine: ['18.x', '20.x', 'xs']
        # Run parallel testing jobs, each executing a subset.
        node_index: [0, 1, 2, 3, 4]
        total_nodes: [5] # the total number of nodes
    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
          echo "CI_NODE_INDEX=${{ matrix.node_index }}" >> $GITHUB_ENV
          echo "CI_NODE_TOTAL=${{ matrix.total_nodes }}" >> $GITHUB_ENV

      - uses: actions/checkout@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
        id: restore-node
      - run: echo "ENDO_BRANCH=${{ steps.restore-node.outputs.endo-branch }}" >> $GITHUB_ENV
      # END-TEST-BOILERPLATE
      - name: yarn test (SwingSet)
        if: (success() || failure())
        run: cd packages/SwingSet && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      # explicitly test the XS worker, for visibility
      - name: yarn test (SwingSet XS Worker)
        if: (success() || failure()) && matrix.engine != 'xs'
        run: cd packages/SwingSet && yarn test:xs-worker | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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: ['18.x', '20.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@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (zoe)
        if: (success() || failure())
        timeout-minutes: 30
        run: cd packages/zoe && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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: ['18.x', '20.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@v4
      - uses: ./.github/actions/restore-node
        with:
          node-version: ${{ steps.vars.outputs.node-version }}
      # END-TEST-BOILERPLATE
      - name: yarn test (zoe)
        if: (success() || failure())
        timeout-minutes: 30
        run: cd packages/zoe && yarn ${{ steps.vars.outputs.test }} | $TEST_COLLECT
      - name: notify on failure
        if: failure() && github.event_name != 'pull_request'
        uses: ./.github/actions/notify-status
        with:
          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
          from: ${{ secrets.NOTIFY_EMAIL_FROM }}
          to: ${{ secrets.NOTIFY_EMAIL_TO }}
          password: ${{ secrets.NOTIFY_EMAIL_PASSWORD }}
      - 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 }}