snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

.github/workflows/server-test-template.yml

@@ -0,0 +1,305 @@
+name: Server Test Template
+on:
+  workflow_call:
+    inputs:
+      name:
+        required: true
+        type: string
+      datasource:
+        required: true
+        type: string
+      drivername:
+        required: true
+        type: string
+      logsartifact:
+        required: true
+        type: string
+      fullyparallel:
+        required: false
+        type: boolean
+        default: true
+      allow-failure:
+        required: false
+        type: boolean
+        default: false
+      enablecoverage:
+        required: false
+        type: boolean
+        default: false
+      build-server-tag:
+        description: "Build image tag (e.g. go1.26.3-node24.11.1)"
+        required: true
+        type: string
+      fips-enabled:
+        required: false
+        default: false
+        type: boolean
+      elasticsearch-version:
+        required: false
+        type: string
+        default: "9.0.0"
+      opensearch-version:
+        required: false
+        type: string
+        default: "3.0.0"
+      test-target:
+        required: false
+        type: string
+        default: "test-server"
+      # -- Test sharding inputs (leave defaults for non-sharded callers) --
+      shard-index:
+        required: false
+        type: number
+        default: -1 # -1 = no sharding; run all tests
+      shard-total:
+        required: false
+        type: number
+        default: 1
+      runner:
+        description: "GitHub-hosted runner label (default: ubuntu-latest-8-cores)"
+        required: false
+        type: string
+        default: "ubuntu-latest-8-cores"
+      race-enabled:
+        description: "Run tests with Go race detector (-race)"
+        required: false
+        type: boolean
+        default: false
+    secrets:
+      # Only if enablecoverage is true
+      CODECOV_TOKEN:
+        required: false
+      # Only if fips-enabled is true
+      DOCKERHUB_USERNAME:
+        required: false
+      DOCKERHUB_TOKEN:
+        required: false
+
+permissions:
+  contents: read
+  actions: read    # for load-buildenv artifact listing
+
+jobs:
+  test:
+    name: ${{ inputs.name }}
+    runs-on: ${{ inputs.runner }}
+    continue-on-error: ${{ inputs.allow-failure }} # Used to avoid blocking PRs in case of flakiness
+    env:
+      COMPOSE_PROJECT_NAME: ghactions
+      INPUT_DATASOURCE: ${{ inputs.datasource }}
+      INPUT_DRIVERNAME: ${{ inputs.drivername }}
+      INPUT_ENABLECOVERAGE: ${{ inputs.enablecoverage }}
+      INPUT_FIPS_ENABLED: ${{ inputs.fips-enabled }}
+      INPUT_FULLYPARALLEL: ${{ inputs.fullyparallel }}
+      INPUT_LOGSARTIFACT: ${{ inputs.logsartifact }}
+      INPUT_NAME: ${{ inputs.name }}
+      INPUT_PR_NUMBER: ${{ github.event.pull_request.number }}
+      INPUT_RACE_ENABLED: ${{ inputs.race-enabled }}
+      INPUT_SHARD_TOTAL: ${{ inputs.shard-total }}
+      INPUT_TEST_TARGET: ${{ inputs.test-target }}
+    steps:
+      - name: buildenv/docker-login
+        # Only FIPS requires login for private build container. (Forks won't have credentials.)
+        if: inputs.fips-enabled
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Checkout mattermost project
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+      - name: buildenv/load
+        id: buildenv
+        uses: ./.github/actions/load-buildenv
+        with:
+          build-server-tag: ${{ inputs.build-server-tag }}
+          fips-enabled: ${{ inputs.fips-enabled }}
+
+      - name: Restore Go cache
+        id: go-cache
+        uses: ./.github/actions/restore-go-cache
+
+      - name: Restore test timing data
+        if: inputs.shard-total > 1
+        id: timing-cache
+        uses: actions/cache/restore@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
+        with:
+          path: |
+            server/prev-report.xml
+            server/prev-gotestsum.json
+          # Always restore from master — timing is only saved on the default
+          # branch and is stable enough for shard balancing.
+          # NOTE: the v2 prefix invalidates pre-existing caches that were
+          # poisoned by shard failures (a killed shard loses its gotestsum.json,
+          # so the merged report was missing those packages' timings; on the
+          # next run they all defaulted to 1ms and bin-packed onto the lightest
+          # shard, overloading it and perpetuating the cycle). See also the
+          # all-shards-passed guard in server-test-merge-template.yml.
+          key: server-test-timing-v2-master
+          restore-keys: |
+            server-test-timing-v2-
+
+      - name: Setup log artifact name
+        id: log-artifact
+        run: |
+          if [[ "$INPUT_FIPS_ENABLED" == 'true' ]]; then
+            echo "LOG_ARTIFACT_NAME=${INPUT_LOGSARTIFACT}-fips" >> "${GITHUB_OUTPUT}"
+          else
+            echo "LOG_ARTIFACT_NAME=${INPUT_LOGSARTIFACT}" >> "${GITHUB_OUTPUT}"
+          fi
+
+      - name: Store required variables for publishing results
+        run: |
+          echo "$INPUT_NAME" > server/test-name
+          echo "$INPUT_PR_NUMBER" > server/pr-number
+
+      - name: Run docker compose
+        env:
+          ELASTICSEARCH_VERSION: ${{ inputs.elasticsearch-version }}
+          OPENSEARCH_VERSION: ${{ inputs.opensearch-version }}
+          POSTGRES_PASSWORD: 'mostest_password'
+        run: |
+          cd server/build
+          docker compose --ansi never run --rm start_dependencies
+          cat ../tests/custom-schema-objectID.ldif | docker compose --ansi never exec -T openldap bash -c 'ldapadd -Y EXTERNAL -H ldapi:/// -w mostest_password || true';
+          cat ../tests/custom-schema-cpa.ldif | docker compose --ansi never exec -T openldap bash -c 'ldapadd -Y EXTERNAL -H ldapi:/// -w mostest_password || true';
+          cat ../tests/test-data.ldif | docker compose --ansi never exec -T openldap bash -c 'ldapadd -x -D "cn=admin,dc=mm,dc=test,dc=com" -w mostest_password';
+          docker compose --ansi never exec -T minio sh -c 'mkdir -p /data/mattermost-test';
+          docker compose --ansi never ps
+
+      # ── Test-level sharding ────────────────────────────────────────────
+      # When shard-total > 1, we split tests across N parallel runners.
+      #
+      # Two-tier splitting strategy:
+      #   - "Light" packages (< 5 min): assigned whole to a shard
+      #   - "Heavy" packages (≥ 5 min, e.g. api4, app): individual tests
+      #     are distributed across shards using -run regex filters
+      #
+      # See server/scripts/shard-split.js for the full algorithm.
+      # ─────────────────────────────────────────────────────────────────────
+
+      - name: Setup Go for test discovery
+        if: inputs.shard-total > 1
+        uses: actions/setup-go@4b73464bb391d4059bd26b0524d20df3927bd417 # v6.3.0
+        with:
+          go-version-file: server/.go-version
+
+      - name: Split tests across shards
+        if: inputs.shard-total > 1
+        id: test_split
+        working-directory: server
+        env:
+          SHARD_INDEX: ${{ inputs.shard-index }}
+          SHARD_TOTAL: ${{ inputs.shard-total }}
+          # `go work` and shard-split.js's `go test -list` run on the host, so
+          # they need the restored caches that the container gets via -e.
+          GOMODCACHE: ${{ steps.go-cache.outputs.gomodcache }}
+          GOCACHE: ${{ steps.go-cache.outputs.gocache }}
+        run: |
+          set -euo pipefail
+
+          # ── List all test packages ──
+          echo "::group::Listing test packages"
+          TE_PKGS=$(find ./public/ ./ -name '*_test.go' -not -path './enterprise/*' -not -path './cmd/mmctl/*' 2>/dev/null \
+            | sed 's|/[^/]*$||' | sort -u \
+            | sed 's|^\./|github.com/mattermost/mattermost/server/v8/|' \
+            | sed 's|github.com/mattermost/mattermost/server/v8/public/|github.com/mattermost/mattermost/server/public/|')
+          EE_PKGS=$(find ./enterprise/ -name '*_test.go' 2>/dev/null \
+            | sed 's|/[^/]*$||' | sort -u \
+            | sed 's|^\./|github.com/mattermost/mattermost/server/v8/|')
+          ALL_PKGS=$(printf '%s\n%s' "$TE_PKGS" "$EE_PKGS" | grep -v '^$' | sort -u)
+          TOTAL_PKGS=$(echo "$ALL_PKGS" | wc -l)
+          echo "Found $TOTAL_PKGS test packages"
+          echo "::endgroup::"
+
+          if [[ "$TOTAL_PKGS" -eq 0 ]]; then
+            echo "WARNING: No test packages found"
+            echo "has_packages=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          echo "$ALL_PKGS" > all-packages.txt
+
+          # ── Create go.work for test discovery ──
+          # Without it, `go test -list` in shard-split.js resolves
+          # github.com/mattermost/mattermost/server/public against the published
+          # module version from server/go.mod, which lags HEAD and causes build
+          # failures when heavy packages reference new symbols in ./public.
+          go work init
+          go work use . ./public
+
+          # ── Run shard solver ──
+          node scripts/shard-split.js
+
+          echo "has_packages=true" >> "$GITHUB_OUTPUT"
+
+      - name: Run Tests
+        env:
+          BUILD_IMAGE: ${{ steps.buildenv.outputs.image }}
+        run: |
+          RACE_MODE=""
+          if [[ "$INPUT_RACE_ENABLED" == "true" ]]; then
+            RACE_MODE="-race"
+          fi
+
+          TEST_TARGET="${INPUT_TEST_TARGET}${RACE_MODE}"
+          BUILD_NUMBER="${GITHUB_HEAD_REF}-${GITHUB_RUN_ID}"
+          DOCKER_CMD="make ${TEST_TARGET}"
+
+          # When sharding is active, use the multi-run wrapper script.
+          # run-shard-tests.sh detects heavy runs itself and falls back to
+          # light-only mode when shard-heavy-runs.txt is absent or empty.
+          if [[ "$INPUT_SHARD_TOTAL" -gt 1 && -f server/shard-te-packages.txt ]]; then
+            cp server/scripts/run-shard-tests.sh server/run-shard-tests.sh
+            chmod +x server/run-shard-tests.sh
+            DOCKER_CMD="/mattermost/server/run-shard-tests.sh"
+          fi
+
+          docker run --net ghactions_mm-test \
+            --ulimit nofile=8096:8096 \
+            --env-file=server/build/dotenv/test.env \
+            --env MM_SQLSETTINGS_DRIVERNAME="$INPUT_DRIVERNAME" \
+            --env MM_SQLSETTINGS_DATASOURCE="$INPUT_DATASOURCE" \
+            --env TEST_DATABASE_POSTGRESQL_DSN="$INPUT_DATASOURCE" \
+            --env ENABLE_FULLY_PARALLEL_TESTS="$INPUT_FULLYPARALLEL" \
+            --env ENABLE_COVERAGE="$INPUT_ENABLECOVERAGE" \
+            --env FIPS_ENABLED="$INPUT_FIPS_ENABLED" \
+            --env RACE_MODE \
+            --env TEST_TARGET \
+            --env BUILD_NUMBER \
+            --env GOMODCACHE=/gocache/mod \
+            --env GOCACHE=/gocache/build \
+            --env GOBIN=/mattermost/server/bin \
+            -v "${RUNNER_TEMP}/go-cache:/gocache" \
+            -v $PWD:/mattermost \
+            -w /mattermost/server \
+            $BUILD_IMAGE \
+            $DOCKER_CMD
+      - name: Upload coverage to Codecov
+        if: ${{ inputs.enablecoverage }}
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          disable_search: true
+          files: server/cover.out
+          flags: server
+
+      - name: Stop docker compose
+        run: |
+          cd server/build
+          docker compose --ansi never stop
+
+      - name: Archive logs
+        if: ${{ always() }}
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: ${{ steps.log-artifact.outputs.LOG_ARTIFACT_NAME }}
+          path: |
+            server/gotestsum.json
+            server/report.xml
+            server/cover.out
+            server/test-name
+            server/pr-number
+