build.yml

name: 'Build & Test'
on:
  push:
    branches:
      - master
      - release/**
  pull_request:
  workflow_dispatch:
    inputs:
      commit:
        description: If the commit you want to test isn't the head of a branch, provide its SHA here
        required: false

# Cancel in progress workflows on pull_requests.
# https://docs.github.com/en/actions/using-jobs/using-concurrency#example-using-a-fallback-value
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true

env:
  HEAD_COMMIT: ${{ github.event.inputs.commit || github.sha }}

  CACHED_DEPENDENCY_PATHS: |
    ${{ github.workspace }}/node_modules
    ${{ github.workspace }}/packages/**/node_modules
    ~/.cache/ms-playwright/
    ~/.cache/mongodb-binaries/

  # DEPENDENCY_CACHE_KEY: can't be set here because we don't have access to yarn.lock

  # packages/utils/cjs and packages/utils/esm: Symlinks to the folders inside of `build`, needed for tests
  CACHED_BUILD_PATHS: |
    ${{ github.workspace }}/packages/*/build
    ${{ github.workspace }}/packages/ember/*.d.ts
    ${{ github.workspace }}/packages/ember/instance-initializers
    ${{ github.workspace }}/packages/gatsby/*.d.ts
    ${{ github.workspace }}/packages/core/src/version.ts
    ${{ github.workspace }}/packages/serverless
    ${{ github.workspace }}/packages/utils/cjs
    ${{ github.workspace }}/packages/utils/esm

  BUILD_CACHE_KEY: ${{ github.event.inputs.commit || github.sha }}

jobs:
  job_get_metadata:
    name: Get Metadata
    runs-on: ubuntu-latest
    permissions:
      pull-requests: read
    steps:
      - name: Check out current commit
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
          # We need to check out not only the fake merge commit between the PR and the base branch which GH creates, but
          # also its parents, so that we can pull the commit message from the head commit of the PR
          fetch-depth: 2
      - name: Get metadata
        id: get_metadata
        # We need to try a number of different options for finding the head commit, because each kind of trigger event
        # stores it in a different location
        run: |
          COMMIT_SHA=$(git rev-parse --short ${{ github.event.pull_request.head.sha || github.event.head_commit.id || env.HEAD_COMMIT }})
          echo "COMMIT_SHA=$COMMIT_SHA" >> $GITHUB_ENV
          echo "COMMIT_MESSAGE=$(git log -n 1 --pretty=format:%s $COMMIT_SHA)" >> $GITHUB_ENV

      - name: Determine changed packages
        uses: getsentry/paths-filter@v2.11.1
        id: changed
        with:
          filters: |
            shared: &shared
              - '*.{js,ts,json,yml,lock}'
              - 'CHANGELOG.md'
              - '.github/**'
              - 'jest/**'
              - 'rollup/**'
              - 'scripts/**'
              - 'packages/core/**'
              - 'packages/tracing/**'
              - 'packages/utils/**'
              - 'packages/types/**'
              - 'packages/integrations/**'
            browser:
              - *shared
              - 'packages/browser/**'
            browser_integration:
              - *shared
              - 'packages/browser/**'
              - 'packages/integration-tests/**'
            ember:
              - *shared
              - 'packages/ember/**'
              - 'packages/browser/**'
            nextjs:
              - *shared
              - 'packages/nextjs/**'
              - 'packages/node/**'
              - 'packages/react/**'
              - 'packages/browser/**'
            remix:
              - *shared
              - 'packages/remix/**'
              - 'packages/node/**'
              - 'packages/react/**'
              - 'packages/browser/**'
            node:
              - *shared
              - 'packages/node/**'
              - 'packages/node-integration-tests/**'

    outputs:
      commit_label: '${{ env.COMMIT_SHA }}: ${{ env.COMMIT_MESSAGE }}'
      changed_nextjs: ${{ steps.changed.outputs.nextjs }}
      changed_ember: ${{ steps.changed.outputs.ember }}
      changed_remix: ${{ steps.changed.outputs.remix }}
      changed_node: ${{ steps.changed.outputs.node }}
      changed_browser: ${{ steps.changed.outputs.browser }}
      changed_browser_integration: ${{ steps.changed.outputs.browser_integration }}

  job_install_deps:
    name: Install Dependencies
    needs: job_get_metadata
    runs-on: ubuntu-latest
    timeout-minutes: 15
    steps:
      - name: 'Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})'
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
        # we use a hash of yarn.lock as our cache key, because if it hasn't changed, our dependencies haven't changed,
        # so no need to reinstall them
      - name: Compute dependency cache key
        id: compute_lockfile_hash
        run: echo "hash=${{ hashFiles('yarn.lock') }}" >> "$GITHUB_OUTPUT"
      - name: Check dependency cache
        uses: actions/cache@v3
        id: cache_dependencies
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ steps.compute_lockfile_hash.outputs.hash }}
      - name: Install dependencies
        if: steps.cache_dependencies.outputs.cache-hit == ''
        run: yarn install --ignore-engines --frozen-lockfile
    outputs:
      dependency_cache_key: ${{ steps.compute_lockfile_hash.outputs.hash }}

  job_build:
    name: Build
    needs: [job_get_metadata, job_install_deps]
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_install_deps.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        id: cache_built_packages
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Build packages
        # Under normal circumstances, using the git SHA as a cache key, there shouldn't ever be a cache hit on the built
        # packages, and so `yarn build` should always run. This `if` check is therefore only there for testing CI issues
        # where the built packages are beside the point. In that case, you can change `BUILD_CACHE_KEY` (at the top of
        # this file) to a constant and skip rebuilding all of the packages each time CI runs.
        if: steps.cache_built_packages.outputs.cache-hit == ''
        run: yarn build
    outputs:
      # this needs to be passed on, because the `needs` context only looks at direct ancestors (so steps which depend on
      # `job_build` can't see `job_install_deps` and what it returned)
      dependency_cache_key: ${{ needs.job_install_deps.outputs.dependency_cache_key }}

  job_pack_aws_lambda_layer:
    name: Pack and Upload AWS Lambda Layer
    needs: [job_get_metadata, job_build]
    # only upload the zipped layer file if we're about to release
    if: startsWith(github.ref, 'refs/heads/release/')
    runs-on: ubuntu-latest
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Get SDK version
        # `jq` reads JSON files, and `tee` pipes its input to the given location and to stdout. (Adding `-a` is the
        # equivalent of using >> rather than >.)
        run: |
          export SDK_VERSION=$(cat packages/core/package.json | jq --raw-output '.version')
          echo "SDK_VERSION=$SDK_VERSION" | tee -a $GITHUB_ENV
      - name: Move dist-serverless to root directory (requirement for zipping action)
        run: |
          mv ./packages/serverless/build/aws/dist-serverless .
      - name: Create and upload final zip file
        uses: getsentry/action-build-aws-lambda-extension@v1
        with:
          artifact_name: ${{ env.HEAD_COMMIT }}
          zip_file_name: sentry-node-serverless-${{ env.SDK_VERSION }}.zip
          build_cache_paths: ${{ env.CACHED_BUILD_PATHS }}
          build_cache_key: ${{ env.BUILD_CACHE_KEY }}

  job_size_check:
    name: Size Check
    needs: [job_get_metadata, job_build]
    timeout-minutes: 15
    runs-on: ubuntu-latest
    # Size Check will error out outside of the context of a PR
    if: github.event_name == 'pull_request' || startsWith(github.ref, 'refs/heads/master/')
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: actions/setup-node@v3
        with:
          # The size limit action runs `yarn` and `yarn build` when this job is executed on
          # `master`. We can't change this without making changes to the action, so we'll
          # use Node 14 for now.
          node-version: '14'
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Check bundle sizes
        uses: getsentry/size-limit-action@v5
        # Don't run size check on release branches - at that point, we're already committed
        if: ${{ !startsWith(github.ref, 'refs/heads/release/') }}
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          skip_step: build

  job_lint:
    name: Lint
    # Even though the linter only checks source code, not built code, it needs the built code in order check that all
    # inter-package dependencies resolve cleanly.
    needs: [job_get_metadata, job_build]
    timeout-minutes: 10
    runs-on: ubuntu-latest
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run linter
        run: yarn lint

  job_circular_dep_check:
    name: Circular Dependency Check
    needs: [job_get_metadata, job_build]
    timeout-minutes: 10
    runs-on: ubuntu-latest
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run madge
        run: yarn circularDepCheck

  job_artifacts:
    name: Upload Artifacts
    needs: [job_get_metadata, job_build]
    runs-on: ubuntu-latest
    # Build artifacts are only needed for releasing workflow.
    if: startsWith(github.ref, 'refs/heads/release/')
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Pack
        run: yarn build:npm
      - name: Archive artifacts
        uses: actions/upload-artifact@v3.1.1
        with:
          name: ${{ github.sha }}
          path: |
            ${{ github.workspace }}/packages/browser/build/bundles/**
            ${{ github.workspace }}/packages/integrations/build/bundles/**
            ${{ github.workspace }}/packages/tracing/build/bundles/**
            ${{ github.workspace }}/packages/**/*.tgz

  job_unit_test:
    name: Test (Node ${{ matrix.node }})
    needs: [job_get_metadata, job_build]
    timeout-minutes: 30
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        node: [8, 10, 12, 14, 16, 18]
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node }}
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run tests
        env:
          NODE_VERSION: ${{ matrix.node }}
        run: |
          [[ $NODE_VERSION == 8 ]] && yarn add --dev --ignore-engines --ignore-scripts --ignore-workspace-root-check ts-node@8.10.2
          yarn test-ci
      - name: Compute test coverage
        uses: codecov/codecov-action@v3

  job_nextjs_integration_test:
    name: Test @sentry/nextjs on (Node ${{ matrix.node }})
    needs: [job_get_metadata, job_build]
    # Currently always runs because it is required for merging PRs
    timeout-minutes: 30
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        node: [10, 12, 14, 16, 18]
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node }}
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run tests
        env:
          NODE_VERSION: ${{ matrix.node }}
        run: |
          cd packages/nextjs
          yarn test:integration

  # Ember tests are separate from the rest because they are the slowest part of the test suite, and making them a
  # separate job allows them to run in parallel with the other tests.
  job_ember_tests:
    name: Test @sentry/ember
    needs: [job_get_metadata, job_build]
    if: needs.job_get_metadata.outputs.changed_ember == 'true' || github.event_name != 'pull_request'
    timeout-minutes: 10
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        scenario: [ember-release, embroider-optimized, ember-4.0]
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
          # TODO: removing `fetch-depth` below seems to have no effect, and the commit which added it had no description,
          # so it's not clear why it's necessary. That said, right now ember tests are xfail, so it's a little hard to
          # tell if it's safe to remove. Once ember tests are fixed, let's try again with it turned off, and if all goes
          # well, we can pull it out.
          fetch-depth: 0
      - name: Set up Node
        uses: actions/setup-node@v3
        with:
          # We support node 14+. If that works, we can safely assume that newer versions will also work.
          node-version: '14'
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run Ember tests
        run: |
          cd packages/ember
          yarn ember try:one ${{ matrix.scenario }} --skip-cleanup=true
      - name: Compute test coverage
        uses: codecov/codecov-action@v3

  job_browser_playwright_tests:
    name: Playwright - ${{ (matrix.tracing_only && 'Browser + Tracing') || 'Browser' }} (${{ matrix.bundle }})
    needs: [job_get_metadata, job_build]
    if: needs.job_get_metadata.outputs.changed_browser_integration == 'true' || github.event_name != 'pull_request'
    runs-on: ubuntu-latest
    strategy:
      matrix:
        bundle:
          - esm
          - cjs
          - bundle_es5
          - bundle_es5_min
          - bundle_es6
          - bundle_es6_min
        tracing_only:
          - true
          - false
        exclude:
          # `tracing_only` only makes a difference for bundles - tests of the esm and cjs builds always include the
          # tracing tests
          - bundle: esm
            tracing_only: false
          - bundle: cjs
            tracing_only: false
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run Playwright tests
        env:
          PW_BUNDLE: ${{ matrix.bundle }}
          PW_TRACING_ONLY: ${{ matrix.tracing_only }}
        run: |
          cd packages/integration-tests
          yarn run playwright install-deps webkit
          yarn test:ci

  job_browser_integration_tests:
    name: Old Browser Integration Tests (${{ matrix.browser }})
    needs: [job_get_metadata, job_build]
    if: needs.job_get_metadata.outputs.changed_browser == 'true' || github.event_name != 'pull_request'
    runs-on: ubuntu-latest
    timeout-minutes: 10
    strategy:
      fail-fast: false
      matrix:
        browser:
          - ChromeHeadless
          - FirefoxHeadless
          - WebkitHeadless
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run integration tests
        env:
          KARMA_BROWSER: ${{ matrix.browser }}
        run: |
          cd packages/browser
          [[ $KARMA_BROWSER == WebkitHeadless ]] && yarn run playwright install-deps webkit
          yarn test:integration

  job_browser_build_tests:
    name: Browser Build Tests
    needs: [job_get_metadata, job_build]
    runs-on: ubuntu-latest
    timeout-minutes: 5
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run browser build tests
        run: |
          cd packages/browser
          yarn test:package
      - name: Run utils build tests
        run: |
          cd packages/utils
          yarn test:package

  job_node_integration_tests:
    name: Node SDK Integration Tests (${{ matrix.node }})
    needs: [job_get_metadata, job_build]
    # Currently always runs because it is required for merging PRs
    runs-on: ubuntu-latest
    timeout-minutes: 10
    strategy:
      fail-fast: false
      matrix:
        node: [10, 12, 14, 16, 18]
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node }}
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run integration tests
        env:
          NODE_VERSION: ${{ matrix.node }}
        run: |
          cd packages/node-integration-tests
          yarn test

  job_remix_integration_tests:
    name: Remix SDK Integration Tests (${{ matrix.node }})
    needs: [job_get_metadata, job_build]
    if: needs.job_get_metadata.outputs.changed_remix == 'true' || github.event_name != 'pull_request'
    runs-on: ubuntu-latest
    timeout-minutes: 10
    strategy:
      fail-fast: false
      matrix:
        node: [14, 16, 18]
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node }}
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Run integration tests
        env:
          NODE_VERSION: ${{ matrix.node }}
        run: |
          cd packages/remix
          yarn test:integration:ci

  job_e2e_tests:
    name: E2E Tests
    # We only run E2E tests for non-fork PRs because the E2E tests require secrets to work and they can't be accessed from forks
    # Dependabot PRs sadly also don't have access to secrets, so we skip them as well
    if:
      (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) &&
      github.actor != 'dependabot[bot]'
    needs: [job_get_metadata, job_build]
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
      - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
        uses: actions/checkout@v3
        with:
          ref: ${{ env.HEAD_COMMIT }}
      - name: Set up Node
        uses: volta-cli/action@v4
      - name: Check dependency cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_DEPENDENCY_PATHS }}
          key: ${{ needs.job_build.outputs.dependency_cache_key }}
      - name: Check build cache
        uses: actions/cache@v3
        with:
          path: ${{ env.CACHED_BUILD_PATHS }}
          key: ${{ env.BUILD_CACHE_KEY }}
      - name: Get node version
        id: versions
        run: |
          echo "echo node=$(jq -r '.volta.node' package.json)" >> $GITHUB_OUTPUT
      - name: Run E2E tests
        env:
          E2E_TEST_PUBLISH_SCRIPT_NODE_VERSION: ${{ steps.versions.outputs.node }}
          E2E_TEST_AUTH_TOKEN: ${{ secrets.E2E_TEST_AUTH_TOKEN }}
          E2E_TEST_DSN: ${{ secrets.E2E_TEST_DSN }}
        run: |
          cd packages/e2e-tests
          yarn test:e2e

  job_required_tests:
    name: All required tests passed or skipped
    needs:
      [
        job_build,
        job_browser_build_tests,
        job_unit_test,
        job_nextjs_integration_test,
        job_node_integration_tests,
        job_browser_playwright_tests,
        job_browser_integration_tests,
        job_remix_integration_tests,
        job_ember_tests,
      ]
    # Always run this, even if a dependent job failed
    if: always()
    runs-on: ubuntu-latest
    steps:
      - name: Check for failures
        if: contains(needs.*.result, 'failure')
        run: |
          echo "One of the dependent jobs have failed. You may need to re-run it." && exit 1