galaxyproject/galaxy (opens in new tab)

name: API tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_DEPENDENCIES_INSTALL_WEASYPRINT: '1'
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
  GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
  GALAXY_TEST_REQUIRE_ALL_NEEDED_TOOLS: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
        chunk: [0, 1]
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-api
      - name: Run tests
        run: ./run_tests.sh --coverage --skip_flakey_fails -api lib/galaxy_test/api -- --num-shards=2 --shard-id=${{ matrix.chunk }}
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: api
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: API test results (${{ matrix.python-version }}, ${{ matrix.chunk }})
          path: 'galaxy root/run_api_tests.html'

name: BioBlend Tests
on:
  pull_request:
    paths:
      - .github/workflows/bioblend.yaml
      - lib/galaxy/schema/**
      - lib/galaxy/webapps/galaxy/api/**
      - lib/galaxy/webapps/galaxy/services/**
  workflow_dispatch:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:18
        # Provide the password for postgres
        env:
          POSTGRES_PASSWORD: postgres
        # Set health checks to wait until postgres has started
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 5432:5432
    strategy:
      fail-fast: false
      matrix:
        tox_env: [py314]
        galaxy_python_version: ['3.10']
    steps:
      - name: Checkout Galaxy
        uses: actions/checkout@v6
        with:
          fetch-depth: 1
          path: galaxy
          persist-credentials: false
      - name: Checkout Bioblend
        uses: actions/checkout@v6
        with:
          repository: galaxyproject/bioblend
          path: bioblend
          persist-credentials: false
      - name: Calculate Python version for BioBlend from tox_env
        id: get_bioblend_python_version
        run: echo "bioblend_python_version=$(echo "${{ matrix.tox_env }}" | sed -e 's/^py\([3-9]\)\([0-9]\+\)/\1.\2/')" >> $GITHUB_OUTPUT
      - name: Set up Python for BioBlend
        uses: actions/setup-python@v6
        with:
          python-version: ${{ steps.get_bioblend_python_version.outputs.bioblend_python_version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Set up Python for Galaxy
        uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.galaxy_python_version }}
      - name: Run tests
        env:
          PGPASSWORD: postgres
          PGPORT: 5432
          PGHOST: localhost
        run: |
          # Create a PostgreSQL database for Galaxy. The default SQLite3 database makes test fail randomly because of "database locked" error.
          createdb -U postgres galaxy
          export DATABASE_CONNECTION=postgresql+psycopg://postgres:@localhost/galaxy
          ./bioblend/run_bioblend_tests.sh -g galaxy -v python${{ matrix.galaxy_python_version }} -e ${{ matrix.tox_env }}
      - name: The job has failed
        if: ${{ failure() }}
        run: |
          cat galaxy/*.log

name: Build client for selenium tests
on:
  workflow_call:
    outputs:
      commit-id:
        description: Commit ID
        value: ${{ jobs.build-client.outputs.commit-id }}
jobs:
  build-client:
    runs-on: ubuntu-latest
    outputs:
      commit-id: ${{ steps.client-commit.outputs.commit }}
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - name: Read Node.js version
        id: node-version
        run: echo "version=$(cat 'galaxy root/client/.node_version')" >> $GITHUB_OUTPUT
      - uses: actions/setup-node@v6
        with:
          node-version: ${{ steps.node-version.outputs.version }}
      - name: Setup pnpm
        uses: pnpm/action-setup@v5
        with:
          package_json_file: 'galaxy root/package.json'
      - name: get client commit
        id: client-commit
        shell: bash
        run: echo "commit=$(git rev-parse HEAD 2>/dev/null)" >> $GITHUB_OUTPUT
        working-directory: 'galaxy root'
      - name: cache client build
        uses: actions/cache@v5
        id: cache
        with:
          key: galaxy-static-${{ steps.client-commit.outputs.commit }}
          path: 'galaxy root/static'
      - name: Build client
        if: steps.cache.outputs.cache-hit != 'true'
        env:
          GALAXY_PLUGIN_BUILD_FAIL_ON_ERROR: 1
          NODE_OPTIONS: --max-old-space-size=4096
        run: make client
        working-directory: 'galaxy root'

name: Build Container Image
on:
  push:
    branches:
      - dev
      - release_*
    tags:
      - v*
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  ghcrbuild:
    name: Build container image for GHCR
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      # https://stackoverflow.com/questions/59810838/how-to-get-the-short-sha-for-the-github-workflow
      - name: Set outputs
        id: commit
        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
      - name: Set branch name
        id: branch
        run: |
          if [[ "$GITHUB_REF" == "refs/tags/"* ]]; then
            echo "name=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
          elif [[ "$GITHUB_REF" == "refs/heads/dev" ]]; then
            echo "name=dev" >> $GITHUB_OUTPUT
          elif [[ "$GITHUB_REF" == "refs/heads/release_"* ]]; then
            echo "name=${GITHUB_REF#refs/heads/release_}-auto" >> $GITHUB_OUTPUT
          fi
        shell: bash
      - name: Extract metadata for container image
        id: meta
        uses: docker/metadata-action@v6
        with:
          images: ghcr.io/${{ github.repository }}
          tags: |
            type=raw,value=${{steps.branch.outputs.name}}
      - name: Build args
        id: buildargs
        run: |
            echo "gitcommit=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT 
            echo "builddate=$(date -u +'%Y-%m-%dT%H:%M:%SZ')"  >> $GITHUB_OUTPUT
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v4
        with:
          platforms: linux/amd64

      - name: Login to GHCR
        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push container image to ghcr
        uses: docker/build-push-action@v7
        with:
          build-args: |
              GIT_COMMIT=${{ steps.buildargs.outputs.gitcommit }}
              BUILD_DATE=${{ steps.buildargs.outputs.builddate }}
              IMAGE_TAG=${{ steps.branch.outputs.name }}
          file: .k8s_ci.Dockerfile
          push: true
          context: .
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          platforms: linux/amd64

  build:
    name: Build container image for Galaxy repos
    runs-on: ubuntu-latest
    if: github.repository_owner == 'galaxyproject'
    outputs:
      tag: ${{ steps.branch.outputs.name }}
      version: ${{ steps.version.outputs.version }}
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: '3.12'
      # https://stackoverflow.com/questions/59810838/how-to-get-the-short-sha-for-the-github-workflow
      - name: Set outputs
        id: commit
        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
      - name: Set branch name
        id: branch
        run: |
          if [[ "$GITHUB_REF" == "refs/tags/"* ]]; then
            echo "name=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
          elif [[ "$GITHUB_REF" == "refs/heads/dev" ]]; then
            echo "name=dev" >> $GITHUB_OUTPUT
          elif [[ "$GITHUB_REF" == "refs/heads/release_"* ]]; then
            echo "name=${GITHUB_REF#refs/heads/release_}-auto" >> $GITHUB_OUTPUT
          fi
        shell: bash
      - name: Get the current Galaxy version
        id: version
        run: |
          version=$(python3 -c "import lib.galaxy.version; print(lib.galaxy.version.VERSION)")
          echo "version=$version" >> $GITHUB_OUTPUT
      - name: Build args
        id: buildargs
        run: |
          echo "gitcommit=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
          echo "builddate=$(date -u +'%Y-%m-%dT%H:%M:%SZ')" >> $GITHUB_OUTPUT
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v4
      - name: Login to quay.io
        uses: docker/login-action@v4
        with:
          registry: quay.io
          username: ${{ secrets.QUAY_USERNAME }}
          password: ${{ secrets.QUAY_PASSWORD }}
      - name: Login to DockerHub
        uses: docker/login-action@v4
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_PASSWORD }}
      - name: Build and push galaxy-min image
        uses: docker/build-push-action@v7
        with:
          context: .
          file: .k8s_ci.Dockerfile
          push: true
          build-args: |
            GIT_COMMIT=${{ steps.buildargs.outputs.gitcommit }}
            BUILD_DATE=${{ steps.buildargs.outputs.builddate }}
            IMAGE_TAG=${{ steps.branch.outputs.name }}
          tags: |
            galaxy/galaxy-min:${{ steps.branch.outputs.name }}
            quay.io/galaxyproject/galaxy-min:${{ steps.branch.outputs.name }}
      - name: Create Dockerfile for auto-expiring image
        run: echo "FROM galaxy/galaxy-min:${{ steps.branch.outputs.name }}" > /tmp/Dockerfile.auto
      - name: Build and push auto-expiring per-commit image
        uses: docker/build-push-action@v7
        with:
          file: /tmp/Dockerfile.auto
          push: true
          tags: quay.io/galaxyproject/galaxy-k8s-auto:${{ steps.commit.outputs.sha_short }}
          labels: quay.expires-after=90d

  smoke-test:
    name: Try installing the new image
    runs-on: ubuntu-latest
    needs: [ build ]
    steps:
      - name: Start k8s locally
        uses: jupyterhub/action-k3s-helm@v4
        with:
          k3s-version: v1.32.0+k3s1  # releases:  https://github.com/k3s-io/k3s/tags
          metrics-enabled: false
          traefik-enabled: false
      - name: Verify function of k8s, kubectl, and helm
        run: |
          echo "kubeconfig: $KUBECONFIG"
          kubectl version
          kubectl get pods --all-namespaces
          helm version
          helm list
      - name: Add the Galaxy Helm repository
        run: helm repo add galaxy https://github.com/CloudVE/helm-charts/raw/master
      - name: Install the Galaxy dependencies
        run: |
          helm install galaxy-deps galaxy/galaxy-deps \
          --namespace galaxy-deps \
          --create-namespace \
          --set cvmfs.cvmfscsi.cache.alien.enabled=false \
          --wait \
          --timeout=1200s
      - name: Install Galaxy using the image we just pushed
        run: |
          helm install galaxy galaxy/galaxy \
          --namespace galaxy \
          --create-namespace \
          --set persistence.accessMode="ReadWriteOnce" \
          --set resources.requests.memory=0Mi,resources.requests.cpu=0m \
          --set image.tag=${{ needs.build.outputs.tag }} \
          --wait \
          --timeout=1200s
      - name: Debug deployment on failure
        if: failure()
        run: |
          echo "=== Deployment failed, gathering debug information ==="

          echo "=== All pods in galaxy namespace ==="
          kubectl get pods -n galaxy -o wide

          echo "=== All pods in galaxy-deps namespace ==="
          kubectl get pods -n galaxy-deps -o wide

          echo "=== CSI Drivers ==="
          kubectl get csidriver

          echo "=== Storage Classes ==="
          kubectl get sc

          echo "=== PVCs in galaxy namespace ==="
          kubectl get pvc -n galaxy

          echo "=== PVCs in galaxy-deps namespace ==="
          kubectl get pvc -n galaxy-deps

          echo "=== Recent events in galaxy namespace ==="
          kubectl get events -n galaxy --sort-by='.lastTimestamp' | tail -50

          echo "=== Recent events in galaxy-deps namespace ==="
          kubectl get events -n galaxy-deps --sort-by='.lastTimestamp' | tail -50

          echo "=== Describe pending/failed pods in galaxy namespace ==="
          for pod in $(kubectl get pods -n galaxy --field-selector=status.phase!=Running,status.phase!=Succeeded -o name 2>/dev/null); do
            echo "--- Describing $pod ---"
            kubectl describe -n galaxy $pod
          done

          echo "=== Describe pending/failed pods in galaxy-deps namespace ==="
          for pod in $(kubectl get pods -n galaxy-deps --field-selector=status.phase!=Running,status.phase!=Succeeded -o name 2>/dev/null); do
            echo "--- Describing $pod ---"
            kubectl describe -n galaxy-deps $pod
          done
      - name: Check the version
        run: |
          kubectl get svc -n galaxy
          kubectl describe svc -n galaxy galaxy-nginx
          address=$(kubectl get svc -n galaxy galaxy-nginx -o jsonpath="http://{.spec.clusterIP}:{.spec.ports[0].port}/galaxy/api/version")
          echo "Address is $address"
          appVersion=${{ needs.build.outputs.version }}
          apiVersion=$(curl $address | jq -r '"\(.version_major).\(.version_minor)"')
          echo "appVersion: $appVersion"
          echo "apiVersion: $apiVersion"
          if [ "$appVersion" != "$apiVersion" ]; then
            exit 1
          fi
      - name: Check client build is served
        run: |
          base_url=$(kubectl get svc -n galaxy galaxy-nginx -o jsonpath="http://{.spec.clusterIP}:{.spec.ports[0].port}")
          css_url="${base_url}/galaxy/static/dist/base.css"
          echo "Checking client build at $css_url"
          status_code=$(curl -s -o /dev/null -w "%{http_code}" "$css_url")
          echo "Status code: $status_code"
          if [ "$status_code" != "200" ]; then
            echo "ERROR: Failed to fetch base.css (status: $status_code)"
            echo "This indicates the client build was not properly included in the image"
            exit 1
          fi
          echo "Client build is properly served"

  pr:
    name: Create a PR to update the Galaxy Helm chart when a release is tagged
    runs-on: ubuntu-latest
    needs: [smoke-test, build]
    if: startsWith(github.ref, 'refs/tags/')
    steps:
      - name: Checkout Galaxy Helm chart
        uses: actions/checkout@v6
        with:
          repository: galaxyproject/galaxy-helm
          persist-credentials: false

      - name: Update Chart.yaml appVersion
        run: |
          sed -i "s/^appVersion:.*/appVersion: \"${{ needs.build.outputs.version }}\"/" galaxy/Chart.yaml

      - name: Update values.yaml image.tag
        run: |
          sed -i "s/^  tag:.*/  tag: \"${{ needs.build.outputs.tag }}\"/" galaxy/values.yaml

      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v8
        with:
          token: ${{ secrets.GALAXY_HELM_PULL_REQUEST_TOKEN }}
          commit-message: "Update Galaxy to version ${{ needs.build.outputs.version }}"
          title: "Update Galaxy to version ${{ needs.build.outputs.version }}"
          body: |
            This PR updates the Galaxy Helm chart to use the new Galaxy release.

            Changes:
            - appVersion: ${{ needs.build.outputs.version }}
            - image.tag: ${{ needs.build.outputs.tag }}

            Triggered by: ${{ github.ref }}
          branch: update-galaxy-${{ needs.build.outputs.version }}
          delete-branch: true
          labels: patch

  notify-failure:
    name: Notify Slack on failure
    runs-on: ubuntu-latest
    needs: [build, smoke-test]
    if: ${{ always() && (needs.build.result == 'failure' || needs.smoke-test.result == 'failure') }}
    steps:
      - name: Determine which job failed
        id: failure-info
        run: |
          if [[ "${{ needs.build.result }}" == "failure" ]]; then
            echo "failed_job=Docker image build" >> $GITHUB_OUTPUT
          elif [[ "${{ needs.smoke-test.result }}" == "failure" ]]; then
            echo "failed_job=Smoke test" >> $GITHUB_OUTPUT
          fi

      - name: Send Slack notification
        uses: slackapi/slack-github-action@v3.0.1
        with:
          webhook: ${{ secrets.K8S_SLACK_WEBHOOK_URL }}
          webhook-type: incoming-webhook
          payload: |
            {
              "text": ":x: *Build Container Image Failed*",
              "blocks": [
                {
                  "type": "header",
                  "text": {
                    "type": "plain_text",
                    "text": ":x: Build Container Image Failed",
                    "emoji": true
                  }
                },
                {
                  "type": "section",
                  "fields": [
                    {
                      "type": "mrkdwn",
                      "text": "*Repository:*\n${{ github.repository }}"
                    },
                    {
                      "type": "mrkdwn",
                      "text": "*Branch/Tag:*\n${{ github.ref_name }}"
                    },
                    {
                      "type": "mrkdwn",
                      "text": "*Failed Job:*\n${{ steps.failure-info.outputs.failed_job }}"
                    },
                    {
                      "type": "mrkdwn",
                      "text": "*Triggered by:*\n${{ github.actor }}"
                    }
                  ]
                },
                {
                  "type": "actions",
                  "elements": [
                    {
                      "type": "button",
                      "text": {
                        "type": "plain_text",
                        "text": "View Workflow Run",
                        "emoji": true
                      },
                      "url": "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
                    }
                  ]
                }
              ]
            }

name: Check test class names
on:
  pull_request:
    paths:
      - '.ci/check_test_class_names.sh'
      - 'lib/galaxy_test/**'
      - 'test/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Install Python dependencies
        run: uv pip install --system -r requirements.txt -r lib/galaxy/dependencies/pinned-test-requirements.txt
      - name: Run tests
        run: .ci/check_test_class_names.sh

name: Client API Testing
on:
  push:
    paths:
      - 'client-api/**'
      - 'client/src/api/**'
      - '.github/workflows/client-api-test.yaml'
  pull_request:
    paths:
      - 'client-api/**'
      - 'client/src/api/**'
      - '.github/workflows/client-api-test.yaml'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  client-api-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      - name: Read Node.js version
        id: node-version
        run: echo "version=$(cat 'client/.node_version')" >> $GITHUB_OUTPUT
      - name: Setup node
        uses: actions/setup-node@v6
        with:
          node-version: ${{ steps.node-version.outputs.version }}
      - name: Setup pnpm
        uses: pnpm/action-setup@v5
      - name: Install client dependencies
        run: pnpm install --frozen-lockfile
        working-directory: client
      - name: Install client-api dependencies
        run: pnpm install --frozen-lockfile
        working-directory: client-api
      - name: Build client-api
        run: pnpm run build
        working-directory: client-api
      - name: Run client-api tests
        run: pnpm test
        working-directory: client-api

name: Client Unit Testing
on:
  push:
    paths:
      - 'client/**'
      - '.github/workflows/client-unit.yaml'
  pull_request:
    paths:
      - 'client/**'
      - '.github/workflows/client-unit.yaml'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  client-unit-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      - name: Read Node.js version
        id: node-version
        run: echo "version=$(cat 'client/.node_version')" >> $GITHUB_OUTPUT
      - name: Setup node
        uses: actions/setup-node@v6
        with:
          node-version: ${{ steps.node-version.outputs.version }}
      - name: Setup pnpm
        uses: pnpm/action-setup@v5
      - run: pnpm install --frozen-lockfile
        working-directory: client
      - name: Pre-build (icons and plugins)
        run: node scripts/build.mjs
        working-directory: client
      - name: Run Vitest Unit Tests
        run: pnpm test
        working-directory: client

# For most projects, this workflow file will not need changing; you simply need
# to commit it to your repository.
#
# You may wish to alter this file to override the set of languages analyzed,
# or to provide custom queries or build logic.
#
# ******** NOTE ********
# We have attempted to detect the languages in your repository. Please check
# the `language` matrix defined below to confirm you have the correct set of
# supported CodeQL languages.
#
name: "CodeQL"

on:
  push:
    branches: [ dev ]
  pull_request:
    # The branches below must be a subset of the branches above
    branches: [ dev ]
  schedule:
    - cron: '16 6 * * 0'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  analyze:
    name: Analyze
    runs-on: ubuntu-latest
    permissions:
      actions: read
      contents: read
      security-events: write

    strategy:
      fail-fast: false
      matrix:
        language: ['javascript-typescript', 'python']
        # CodeQL supports [ 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift' ]
        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support

    steps:
      - name: Checkout repository
        uses: actions/checkout@v6
        with:
          persist-credentials: false

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
        uses: github/codeql-action/init@v4
        with:
          languages: ${{ matrix.language }}
          # If you wish to specify custom queries, you can do so here or in a config file.
          # By default, queries listed here will override any specified in a config file.
          # Prefix the list here with "+" to use these queries and those in the config file.

          # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
          # queries: security-extended,security-and-quality

          config-file: ./.github/codeql/codeql-config.yml


      # 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@v4

      # ℹ️ Command-line programs to run using the OS shell.
      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun

      #   If the Autobuild fails above, remove it and uncomment the following three lines
      #   modify them (or add more) to build your code if your project
      #   uses a compiled language

      #- run: |
      #   make bootstrap
      #   make release

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v4

name: Converter tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - name: Clone galaxyproject/galaxy-test-data
        uses: actions/checkout@v6
        with:
          repository: galaxyproject/galaxy-test-data
          path: galaxy-test-data
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Move test data
        run: rsync -av --remove-source-files --exclude .git galaxy-test-data/ 'galaxy root/test-data/'
      - name: Install planemo
        run: uv tool install planemo
      - name: Determine converters to check
        run: |
          ls 'galaxy root'/lib/galaxy/datatypes/converters/*xml | grep -v -f 'galaxy root'/lib/galaxy/datatypes/converters/.tt_skip > tool_list.txt
          echo "Skipping checks for the following converters:"
          ls 'galaxy root'/lib/galaxy/datatypes/converters/*xml | grep -f 'galaxy root'/lib/galaxy/datatypes/converters/.tt_skip
          echo "Checking only the following converters:"
          cat tool_list.txt
      - name: Lint converters
        run: |
          mapfile -t TOOL_ARRAY < tool_list.txt
          planemo lint --skip CitationsMissing,HelpEmpty,HelpMissing --report_level warn "${TOOL_ARRAY[@]}"
      - name: Run tests
        run: |
          mapfile -t TOOL_ARRAY < tool_list.txt
          planemo test --biocontainers --galaxy_python_version ${{ matrix.python-version }} --galaxy_root 'galaxy root' "${TOOL_ARRAY[@]}"
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Converter test results (${{ matrix.python-version }})
          path: tool_test_output.html

name: CWL conformance
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
env:
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    if: ${{ false }}
    runs-on: ubuntu-latest
    continue-on-error: ${{ startsWith(matrix.marker, 'red') }}
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
        marker: ['green', 'red and required', 'red and not required']
        conformance-version: ['cwl_conformance_v1_0'] #, 'cwl_conformance_v1_1', 'cwl_conformance_v1_2']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-api
      - name: Run tests
        run: ./run_tests.sh --coverage --skip_flakey_fails -cwl lib/galaxy_test/api/cwl -- -m "${{ matrix.marker }} and ${{ matrix.conformance-version }}"
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: cwl-conformance
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: CWL conformance test results (${{ matrix.python-version }}, ${{ matrix.marker }}, ${{ matrix.conformance-version }})
          path: 'galaxy root/run_cwl_tests.html'

name: Database indexes
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
defaults:
  run:
    working-directory: 'galaxy root'
jobs:
  check:
    name: Check database indexes
    runs-on: ubuntu-latest
    strategy:
      matrix:
        db: ['postgresql']
        postgresql-version: ['9.6', '10', '11', '14', '18']
        python-version: ['3.10']
        include:
          - db: sqlite
            python-version: '3.10'
    services:
      postgres:
        image: ${{ matrix.db == 'postgresql' && format('postgres:{0}', matrix.postgresql-version) || '' }}
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Set database connection on PostgreSQL
        if: matrix.db == 'postgresql'
        run: echo 'GALAXY_CONFIG_OVERRIDE_DATABASE_CONNECTION=postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8' >> $GITHUB_ENV
      - name: Check indexes
        run: tox -e check_indexes

name: Update dependencies
on:
  schedule:
    - cron: '0 3 * * 6'  # Run every saturday at 3 am.
  workflow_dispatch:
jobs:
  update_dependencies:
    name: Update dependencies
    if: github.repository_owner == 'galaxyproject'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: '3.10'
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Update dependencies
        run: make update-dependencies
      - name: Create pull request
        uses: peter-evans/create-pull-request@v8
        with:
          author: galaxybot <galaxybot@users.noreply.github.com>
          token: ${{ secrets.GALAXYBOT_PAT }}
          commit-message: |
            Update Python dependencies

            by running `make update-dependencies`.
          branch: dev_auto_update_dependencies
          delete-branch: true
          push-to-fork: galaxybot/galaxy
          title: Update Python dependencies
          body: by running `make update-dependencies`.
          labels: |
            area/dependencies
            kind/enhancement

name: Deployment Tests
on:
  workflow_dispatch:
    inputs:
      target:
        description: 'Galaxy Deployment to target'
        required: true
        default: 'usegalaxymain'
        type: choice
        options:
        - usegalaxytest
        - usegalaxymain
        - usegalaxyeu
      type:
        description: 'Test type'
        required: true
        default: 'all'
        type: choice
        options:
        - all
        - api
        - selenium
      debug:
        required: true
        description: 'Run deployment tests with debug mode on'
        type: boolean
jobs:
  testdeployment:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - uses: nanasess/setup-chromedriver@v2
      - name: Run tests
        run: bash ./test/deployment/usegalaxystar.bash
        env:
          GALAXY_TEST_DEPLOYMENT_TARGET: ${{ inputs.target }}
          GALAXY_TEST_DEPLOYMENT_DEBUG: ${{ inputs.debug }}
          GALAXY_TEST_DEPLOYMENT_TEST_TYPE: ${{ inputs.type }}
          GALAXY_TEST_USEGALAXYMAIN_USER_EMAIL: "jmchilton+test@gmail.com"
          GALAXY_TEST_USEGALAXYMAIN_USER_PASSWORD: ${{ secrets.USEGALAXYMAIN_USER_PASSWORD }}
          GALAXY_TEST_USEGALAXYMAIN_USER_KEY: ${{ secrets.USEGALAXYMAIN_USER_KEY }}
          GALAXY_TEST_USEGALAXYTEST_USER_EMAIL: "jmchilton+test@gmail.com"
          GALAXY_TEST_USEGALAXYTEST_USER_PASSWORD: ${{ secrets.USEGALAXYTEST_USER_PASSWORD }}
          GALAXY_TEST_USEGALAXYTEST_USER_KEY: ${{ secrets.USEGALAXYTEST_USER_KEY }}
          GALAXY_TEST_USEGALAXYEU_USER_EMAIL: "jmchilton+test@gmail.com"
          GALAXY_TEST_USEGALAXYEU_USER_PASSWORD: ${{ secrets.USEGALAXYEU_USER_PASSWORD }}
          GALAXY_TEST_USEGALAXYEU_USER_KEY: ${{ secrets.USEGALAXYEU_USER_KEY }}
          GALAXY_TEST_TIMEOUT_MULTIPLIER: 10
      - uses: actions/upload-artifact@v7
        if: always()
        with:
          name: Deployment test results (${{ inputs.target }}, ${{ inputs.type }}, ${{ inputs.debug }}, ${{ matrix.python-version }})
          path: 'deployment_tests.html'

name: Build docs
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    steps:
      - name: Get target branch name (push)
        if: github.event_name == 'push'
        run: echo "TARGET_BRANCH=${GITHUB_REF##*/}" >> $GITHUB_ENV
      - name: Get target branch name (pull request)
        if: github.event_name == 'pull_request'
        run: echo "TARGET_BRANCH=$GITHUB_BASE_REF" >> $GITHUB_ENV
      - name: Show target branch name
        run: echo $TARGET_BRANCH
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Install Python dependencies
        run: uv pip install --system -r requirements.txt -r lib/galaxy/dependencies/dev-requirements.txt sphinxcontrib-simpleversioning
      - name: Add Google Analytics to doc/source/conf.py
        run: |
          sed -i -e "/html_theme_options = {/a\
          \    'analytics_id': 'UA-45719423-17'," -e "s#https://docs.galaxyproject.org/en/[^/]*/#https://docs.galaxyproject.org/en/$TARGET_BRANCH/#" doc/source/conf.py
      - name: Checkout the latest doc/source/conf.versioning.py
        if: github.event_name != 'push' || github.ref != 'refs/heads/dev'
        run: |
          # We cannot just download the latest version from dev, because it may be newer in this branch/PR
          git fetch origin dev:dev
          if [ ! -f doc/source/conf.versioning.py ] || [ "$(git log -1 --pretty="format:%ct" dev -- doc/source/conf.versioning.py)" -gt "$(git log -1 --pretty="format:%ct" -- doc/source/conf.versioning.py)" ]; then
              git checkout dev -- doc/source/conf.versioning.py
          fi
      - name: Append doc/source/conf.versioning.py
        run: cat doc/source/conf.versioning.py >> doc/source/conf.py
      - name: Build docs
        run: make docs
      - name: Deploy docs
        if: github.event_name == 'push' && github.repository_owner == 'galaxyproject'
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        run: |
          case "$TARGET_BRANCH" in
              release_[[:digit:]][[:digit:]].[[:digit:]][[:digit:]] | release_[[:digit:]][[:digit:]].[[:digit:]] | master)
                  UPLOAD_DIR=$TARGET_BRANCH
                  ;;
              dev)
                  UPLOAD_DIR=latest
                  ;;
              *)
                  echo "Not deploying documentation for branch $TARGET_BRANCH"
                  exit 0
                  ;;
          esac
          uv tool install awscli
          aws s3 sync doc/build/html/ "s3://galaxy-docs/en/$UPLOAD_DIR" --region us-east-2 --size-only --delete

name: first startup
on:
  push:
    paths-ignore:
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
env:
  YARN_INSTALL_OPTS: --frozen-lockfile
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  build-client:
    uses: ./.github/workflows/build_client.yaml
  test:
    name: Startup test
    needs: build-client
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10', '3.14']
    defaults:
      run:
        shell: bash -l {0}
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - name: Set up Python
        uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Restore client cache
        uses: actions/cache@v5
        with:
          fail-on-cache-miss: true
          key: galaxy-static-${{ needs.build-client.outputs.commit-id }}
          path: 'galaxy root/static'
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: run tests
        run: tox -e first_startup
        working-directory: 'galaxy root'

name: Tool framework tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
        use-legacy-api: ['if_needed', 'always']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-framework
      - name: Run tests
        run: GALAXY_TEST_USE_LEGACY_TOOL_API="${{ matrix.use-legacy-api }}" ./run_tests.sh --coverage --framework-tools
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: framework
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Tool framework test results (${{ matrix.python-version }})
          path: 'galaxy root/run_framework_tests.html'

name: Workflow framework tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
  GALAXY_TEST_WORKFLOW_AFTER_RERUN: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-framework
      - name: Run tests
        run: ./run_tests.sh --coverage --framework-workflows
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: framework-workflows
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Workflow framework test results (${{ matrix.python-version }})
          path: 'galaxy root/run_framework_workflows_tests.html'

name: Integration Selenium
on:
  push:
    paths-ignore:
      - 'doc/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'doc/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_SKIP_CLIENT_BUILD: '0'
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
  GALAXY_TEST_SELENIUM_RETRIES: 1
  YARN_INSTALL_OPTS: --frozen-lockfile
  GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
  GALAXY_DEPENDENCIES_INSTALL_WEASYPRINT: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  setup-selenium:
    uses: ./.github/workflows/setup_selenium.yaml
  build-client:
    uses: ./.github/workflows/build_client.yaml
  test:
    name: Test
    needs: [setup-selenium, build-client]
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - name: Prune unused docker image, volumes and containers
        run: docker system prune -a -f
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-integration-selenium
      - name: Restore client cache
        uses: actions/cache@v5
        with:
          fail-on-cache-miss: true
          key: galaxy-static-${{ needs.build-client.outputs.commit-id }}
          path: 'galaxy root/static'
      - name: Run tests
        run: ./run_tests.sh --coverage -integration test/integration_selenium
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: integration-selenium
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Integration Selenium test results (${{ matrix.python-version }})
          path: 'galaxy root/run_integration_tests.html'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Integration Selenium debug info (${{ matrix.python-version }})
          path: 'galaxy root/database/test_errors'

name: Integration
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
  GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
  GALAXY_DEPENDENCIES_INSTALL_WEASYPRINT: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
        chunk: ['0', '1', '2', '3']
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          # Skip outputs_to_working_directory: true in integration tests, doesn't work with pulsar
          # echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - name: Prune unused docker image, volumes and containers
        run: docker system prune -a -f
      - name: Clean dotnet folder for space
        run: rm -Rf /usr/share/dotnet
      - name: Install packages
        # ffmpeg: ffprobe needed by media datatypes
        run: sudo apt-get update && sudo apt-get -y install ffmpeg
      - name: Setup Minikube
        uses: medyagh/setup-minikube@latest
        with:
          driver: none
          kubernetes-version: '1.28.0'
      - name: Check pods
        run: kubectl get pods -A
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-integration
      - name: Install Apptainer's singularity
        uses: eWaterCycle/setup-apptainer@v2
      - name: Run tests
        run: |
          . .ci/minikube-test-setup/start_services.sh
          ./run_tests.sh --coverage -integration test/integration -- --num-shards=4 --shard-id=${{ matrix.chunk }}
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: integration
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Integration test results (${{ matrix.python-version }}, ${{ matrix.chunk }})
          path: 'galaxy root/run_integration_tests.html'

name: Client linting
on:
  push:
    paths:
      - 'client/**'
      - '.github/workflows/js_lint.yaml'
  pull_request:
    paths:
      - 'client/**'
      - '.github/workflows/js_lint.yaml'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  client-unit-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      - name: Read Node.js version
        id: node-version
        run: echo "version=$(cat 'client/.node_version')" >> $GITHUB_OUTPUT
      - name: Setup node
        uses: actions/setup-node@v6
        with:
          node-version: ${{ steps.node-version.outputs.version }}
      - name: Setup pnpm
        uses: pnpm/action-setup@v5
      - run: pnpm install --frozen-lockfile
        working-directory: client
      - name: Run ESLint
        run: pnpm run eslint
        working-directory: client
      - name: Run prettier checks
        run: pnpm run format-check
        working-directory: client
      - name: Run vue-tsc
        working-directory: client
        run: pnpm type-check

name: Labels Verifier
on:
  pull_request_target:
    types: [closed]
jobs:
  onMerged:
    name: "Check Labels on merge"
    permissions:
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      - name: Check Labels on merge
        if: |
          github.event.pull_request.merged == true &&
          ! contains(join(github.event.pull_request.labels.*.name, ', '), 'kind/') &&
          ! contains(github.event.pull_request.labels.*.name, 'merge') &&
          ! contains(github.event.pull_request.labels.*.name, 'minor')
        uses: actions/github-script@v8
        with:
          script: |
            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: 'This PR was merged without a "kind/" label, please correct.',
            })

name: OpenAPI linting
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  validate-schema:
    name: Validate OpenAPI schema
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10', '3.14']
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - name: Read Node.js version
        id: node-version
        run: echo "version=$(cat 'galaxy root/client/.node_version')" >> $GITHUB_OUTPUT
      - uses: actions/setup-node@v6
        with:
          node-version: ${{ steps.node-version.outputs.version }}
      - name: Setup pnpm
        uses: pnpm/action-setup@v5
        with:
          package_json_file: 'galaxy root/package.json'
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-api
      - name: Install dependencies
        run: ./scripts/common_startup.sh --dev-wheels --skip-client-build
        working-directory: 'galaxy root'
      - name: Lint schema
        run: make lint-api-schema
        working-directory: 'galaxy root'
      - name: Build typescript schema
        run: make update-client-api-schema
        working-directory: 'galaxy root'
      - name: Diff...
        run: git diff
        working-directory: 'galaxy root'
      - name: Check for changes
        run: |
          if [[ `git status --porcelain` ]]; then
            echo "Rebuilding client/src/api/schema/schema.ts resulted in changes, run 'make update-client-api-schema' and commit results"
            exit 1
          fi
        working-directory: 'galaxy root'

name: Python linting
on:
  push:
    paths:
      - '**.py'
      - '.github/workflows/lint.yaml'
      - .flake8
      - .isort.cfg
      - lib/galaxy/dependencies/**
      - mypy.ini
      - pyproject.toml
      - tox.ini
  pull_request:
    paths:
      - '**.py'
      - '.github/workflows/lint.yaml'
      - .flake8
      - .isort.cfg
      - lib/galaxy/dependencies/**
      - mypy.ini
      - pyproject.toml
      - tox.ini
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10', '3.14']
    env:
      LINT_PATH: 'lib/galaxy/dependencies/pinned-lint-requirements.txt'
      TYPE_PATH: 'lib/galaxy/dependencies/pinned-typecheck-requirements.txt'
      CORE_PATH: 'lib/galaxy/dependencies/pinned-requirements.txt'
    steps:
      - uses: actions/checkout@v6
        with:
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Run linting
        run: tox -e lint
      - name: Run docstring linting
        run: tox -e lint_docstring_include_list
      - name: Run mypy checks
        run: tox -e mypy
      - name: Run format checks
        run: tox -e format

name: Main tool tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
env:
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-framework
      - name: Run tests
        run: ./run_tests.sh --coverage --main_tools
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: main-tools
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Main tool test results (${{ matrix.python-version }})
          path: 'galaxy root/run_framework_tests.html'

name: Maintenance Bot
on:
  pull_request_target:
    types: [opened, reopened, edited, ready_for_review, unlabeled]
jobs:
  labeler:
    name: Assign labels and milestone
    if: github.repository_owner == 'galaxyproject'
    permissions:
      contents: read
      issues: write
      pull-requests: write
    runs-on: ubuntu-latest
    env:
      MILESTONE_NUMBER: 33
    steps:
      - name: Get latest pull request labels
        id: get_pr_labels
        uses: actions/github-script@v8
        with:
          script: |
            const response = await github.rest.issues.listLabelsOnIssue({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
            });
            console.log(response);
            return response.data;
      - name: Add area labels
        if: ${{ ! contains(join(fromJSON(steps.get_pr_labels.outputs.result).*.name, ', '), 'area/') }}
        uses: actions/labeler@v6
      - name: Assign milestone
        if: |
          ! github.event.pull_request.milestone &&
          ! contains(github.event.pull_request.labels.*.name, 'merge') &&
          ! contains(github.event.pull_request.labels.*.name, 'status/WIP') &&
          ! contains(github.event.pull_request.title, 'WIP') &&
          ! github.event.pull_request.draft
        uses: actions/github-script@v8
        with:
          script: |
            github.rest.issues.update({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              milestone: ${{ env.MILESTONE_NUMBER }},
            });

name: Mulled Unit Tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Install Apptainer's singularity
        uses: eWaterCycle/setup-apptainer@v2
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Run tests
        run: tox -e mulled
        working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Mulled unit test results (${{ matrix.python-version }})
          path: 'galaxy root/run_unit_tests.html'

name: macOS startup
on:
  push:
    paths-ignore:
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  build-client:
    uses: ./.github/workflows/build_client.yaml
  test:
    name: Startup test
    runs-on: macos-latest
    needs: build-client
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10', '3.14']
    defaults:
      run:
        shell: bash -l {0}
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - name: Install miniforge  # use this job to test using Python from a conda environment
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniforge-version: latest
          activate-environment: ''
      - name: Restore client cache
        uses: actions/cache@v5
        with:
          fail-on-cache-miss: true
          key: galaxy-static-${{ needs.build-client.outputs.commit-id }}
          path: 'galaxy root/static'
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Run tests
        run: tox -e first_startup
        working-directory: 'galaxy root'
        env:
          GALAXY_CONDA_PYTHON_VERSION: "${{ matrix.python-version }}"

name: Performance tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ['3.10']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-performance
      - name: Run tests
        run: ./run_tests.sh --ci_test_metrics --structured_data_html --structured_data_report_file "test.json" --skip_flakey_fails -api lib/galaxy_test/performance
        working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: API test results (${{ matrix.python-version }})
          path: 'galaxy root/run_api_tests.html'
      - uses: actions/upload-artifact@v7
        with:
          name: Performance Metrics (${{ matrix.python-version }})
          path: 'galaxy root/test.html'

name: Playwright tests
on:
  push:
    paths-ignore:
      - 'doc/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'doc/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_CONFIG_GALAXY_URL_PREFIX: '/galaxypf'
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
  GALAXY_TEST_SELENIUM_RETRIES: 1
  GALAXY_TEST_SKIP_FLAKEY_TESTS_ON_ERROR: 1
  GALAXY_TEST_SELENIUM_HEADLESS: 1
  YARN_INSTALL_OPTS: --frozen-lockfile
  GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  build-client:
    uses: ./.github/workflows/build_client.yaml
  test:
    name: Test
    needs: [build-client]
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
        chunk: [0, 1, 2]
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-playwright
      - name: Restore client cache
        uses: actions/cache@v5
        with:
          fail-on-cache-miss: true
          key: galaxy-static-${{ needs.build-client.outputs.commit-id }}
          path: 'galaxy root/static'
      - name: Run tests
        run: ./run_tests.sh --coverage -playwright lib/galaxy_test/selenium -- --num-shards=3 --shard-id=${{ matrix.chunk }}
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: playwright
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Playwright test results (${{ matrix.python-version }}, ${{ matrix.chunk }})
          path: 'galaxy root/run_playwright_tests.html'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Playwright debug info (${{ matrix.python-version }}, ${{ matrix.chunk }})
          path: 'galaxy root/database/test_errors'

name: Update PR title

on:
  pull_request_target:
    types: [opened, edited, reopened]

jobs:
  update-title:
    if: github.event.action != 'edited' || github.event.changes.base.ref.from != ''
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
    steps:
      - name: Update PR title
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
          TARGET_BRANCH: "${{ github.base_ref }}"
          PR_TITLE: "${{ github.event.pull_request.title }}"
          REPO: "${{ github.repository }}"
        run: |
          VERSION=$(echo $TARGET_BRANCH | grep -oP '^release_\K\d+.\d+$' || true)
          NEW_TITLE=$(echo "$PR_TITLE" | sed -E "s/\[[0-9]+\.[0-9]+\] //")
          if [[ -n "$VERSION" ]]; then
            NEW_TITLE="[$VERSION] $NEW_TITLE"
          fi
          if [[ "$NEW_TITLE" != "$PR_TITLE" ]]; then
            gh pr edit $PR_NUMBER --repo "$REPO" --title "$NEW_TITLE"
          fi

name: Publish release artifacts
on:
  release:
    types: [released, prereleased]
  workflow_dispatch:
    inputs:
      release_type:
        description: 'create release or prerelease artifact ?'
        required: true
        default: 'prerelease'
        type: choice
        options:
        - release
        - prerelease
      release_tag:
        description: 'Specify tag to build for'
        required: true
        type: string
jobs:
  check-permissions:
    if: github.event_name == 'workflow_dispatch'
    runs-on: ubuntu-latest
    steps:
      - name: Check if user can create releases
        run: |
          PERMISSION=$(gh api repos/${{ github.repository }}/collaborators/${{ github.actor }}/permission --jq '.permission')
          if [[ "$PERMISSION" != "admin" ]]; then
            echo "Error: Only repository admins can manually trigger release artifacts"
            exit 1
          fi
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  build-and-publish-pypi:
    if: |
      github.repository_owner == 'galaxyproject' &&
      (github.event_name == 'release' ||
       (github.event_name == 'workflow_dispatch' && !cancelled() && !failure()))
    needs: [check-permissions]
    name: Build and Publish to PyPI
    runs-on: ubuntu-latest
    strategy:
        matrix:
            python-version: ['3.10']
    steps:
      - uses: actions/checkout@v6
        with:
          ref: ${{ github.event_name == 'workflow_dispatch' && inputs.release_tag || '' }}
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Install script dependencies
        run: uv tool install galaxy-release-util
      - name: Build and publish to PyPI
        run: |
          galaxy-release-util build-and-upload --no-confirm
        env:
            TWINE_USERNAME: __token__
            TWINE_PASSWORD: ${{ (github.event_name == 'workflow_dispatch' && inputs.release_type == 'prerelease') || (github.event_name == 'release' && github.event.release.prerelease) && secrets.PYPI_TEST_TOKEN || secrets.PYPI_MAIN_TOKEN }}
            TWINE_REPOSITORY_URL: ${{ (github.event_name == 'workflow_dispatch' && inputs.release_type == 'prerelease') || (github.event_name == 'release' && github.event.release.prerelease) && 'https://test.pypi.org/legacy/' || 'https://upload.pypi.org/legacy/' }}

  build-and-publish-npm:
    if: |
      github.repository_owner == 'galaxyproject' &&
      (github.event_name == 'release' ||
       (github.event_name == 'workflow_dispatch' && !cancelled() && !failure()))
    needs: [check-permissions]
    name: Build and Publish to NPM
    runs-on: ubuntu-latest
    permissions:
      id-token: write
    steps:
      - uses: actions/checkout@v6
        with:
          ref: ${{ github.event_name == 'workflow_dispatch' && inputs.release_tag || '' }}
          persist-credentials: false
      - name: Read Node.js version
        id: node-version
        run: echo "version=$(cat client/.node_version)" >> $GITHUB_OUTPUT
      - uses: actions/setup-node@v6
        with:
          node-version: ${{ steps.node-version.outputs.version }}
          registry-url: 'https://registry.npmjs.org'
      - name: Setup pnpm
        uses: pnpm/action-setup@v5
      - name: build client
        run: pnpm install && pnpm build-production
        working-directory: 'client'
      # Ensure npm 11.5.1 or later for trusted publishing
      - run: npm install -g npm@latest
        working-directory: 'client'
      - name: publish client
        if: (github.event_name == 'workflow_dispatch' && inputs.release_type == 'release') || (github.event_name == 'release' && !github.event.release.prerelease)
        run: npm publish --provenance --access public
        working-directory: 'client'
      - name: sync client-api version
        run: npm run sync-version
        working-directory: 'client-api'
      - name: build client-api
        run: pnpm install && pnpm run build
        working-directory: 'client-api'
      - name: publish client-api
        if: (github.event_name == 'workflow_dispatch' && inputs.release_type == 'release') || (github.event_name == 'release' && !github.event.release.prerelease)
        run: npm publish --provenance --access public
        working-directory: 'client-api'

name: Selenium tests
on:
  push:
    paths-ignore:
      - 'doc/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'doc/**'
      - 'packages/**'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_CONFIG_GALAXY_URL_PREFIX: '/galaxypf'
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
  GALAXY_TEST_SELENIUM_RETRIES: 1
  GALAXY_TEST_SKIP_FLAKEY_TESTS_ON_ERROR: 1
  YARN_INSTALL_OPTS: --frozen-lockfile
  GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  setup-selenium:
    uses: ./.github/workflows/setup_selenium.yaml
  build-client:
    uses: ./.github/workflows/build_client.yaml
  test:
    name: Test
    needs: [setup-selenium, build-client]
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
        chunk: [0, 1, 2]
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-selenium
      - name: Restore client cache
        uses: actions/cache@v5
        with:
          fail-on-cache-miss: true
          key: galaxy-static-${{ needs.build-client.outputs.commit-id }}
          path: 'galaxy root/static'
      - name: Run tests
        run: ./run_tests.sh --coverage -selenium lib/galaxy_test/selenium -- --num-shards=3 --shard-id=${{ matrix.chunk }}
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: selenium
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Selenium test results (${{ matrix.python-version }}, ${{ matrix.chunk }})
          path: 'galaxy root/run_selenium_tests.html'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Selenium debug info (${{ matrix.python-version }}, ${{ matrix.chunk }})
          path: 'galaxy root/database/test_errors'

on:
  workflow_call:
jobs:
  setup_chromedriver:
    runs-on: ubuntu-latest
    steps:
      - name: Install chromedriver
        uses: nanasess/setup-chromedriver@v2

name: Test Galaxy packages for Pulsar
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.8']  # don't upgrade, see https://github.com/galaxyproject/galaxy/pull/16649
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Install Apptainer's singularity
        uses: eWaterCycle/setup-apptainer@v2
      - name: Install ffmpeg
        run: sudo apt-get update && sudo apt-get -y install ffmpeg
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Run tests
        run: tox -e test_galaxy_packages_for_pulsar
        working-directory: 'galaxy root'

name: Test Galaxy packages
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10', '3.14']
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Install ffmpeg
        run: sudo apt-get update && sudo apt-get -y install ffmpeg
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Run tests
        run: tox -e test_galaxy_packages
        working-directory: 'galaxy root'

name: Test Galaxy release script
on:
  push:
    paths:
      - '.github/workflows/test_galaxy_release.yaml'
      - lib/galaxy/dependencies/**
      - lib/galaxy/version.py
      - scripts/release.sh
      - test/release.sh
  pull_request:
    paths:
      - '.github/workflows/test_galaxy_release.yaml'
      - lib/galaxy/dependencies/**
      - lib/galaxy/version.py
      - scripts/release.sh
      - test/release.sh
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
          persist-credentials: false
      - name: Run tests
        run: ./test/release.sh

name: Tool form harness tests
on:
  push:
    paths:
      - 'client/src/components/Form/**'
      - 'client/src/components/Tool/**'
      - 'client/src/utils/navigation/navigation.yml'
      - 'lib/galaxy/navigation/navigation.yml'
      - 'lib/galaxy/selenium/navigates_galaxy.py'
      - 'lib/galaxy_test/selenium/framework.py'
      - 'lib/galaxy_test/selenium/test_tool_form_harness.py'
      - 'test/functional/tools/**'
      - '.github/workflows/tool_form_harness.yaml'
  pull_request:
    paths:
      - 'client/src/components/Form/**'
      - 'client/src/components/Tool/**'
      - 'client/src/utils/navigation/navigation.yml'
      - 'lib/galaxy/navigation/navigation.yml'
      - 'lib/galaxy/selenium/navigates_galaxy.py'
      - 'lib/galaxy_test/selenium/framework.py'
      - 'lib/galaxy_test/selenium/test_tool_form_harness.py'
      - 'test/functional/tools/**'
      - '.github/workflows/tool_form_harness.yaml'
  schedule:
    # Run at midnight UTC every Tuesday
    - cron: '0 0 * * 2'
env:
  GALAXY_CONFIG_GALAXY_URL_PREFIX: '/galaxypf'
  GALAXY_TEST_E2E_TOOL_TESTS: '1'
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
  GALAXY_TEST_SELENIUM_RETRIES: 1
  GALAXY_TEST_SKIP_FLAKEY_TESTS_ON_ERROR: 1
  GALAXY_TEST_SELENIUM_HEADLESS: 1
  YARN_INSTALL_OPTS: --frozen-lockfile
  GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  build-client:
    uses: ./.github/workflows/build_client.yaml
  test:
    name: Test
    needs: [build-client]
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - if: github.event_name == 'schedule'
        run: |
          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-playwright
      - name: Install dependencies
        run: ./scripts/common_startup.sh --dev-wheels --skip-client-build
        working-directory: 'galaxy root'
      - name: Install Playwright
        run: |
          . .venv/bin/activate
          playwright install chromium --with-deps
        working-directory: 'galaxy root'
      - name: Restore client cache
        uses: actions/cache@v5
        with:
          fail-on-cache-miss: true
          key: galaxy-static-${{ needs.build-client.outputs.commit-id }}
          path: 'galaxy root/static'
      - name: Run tests
        run: ./run_tests.sh --coverage -playwright lib/galaxy_test/selenium/test_tool_form_harness.py
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: tool-form-harness
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Tool form harness test results (${{ matrix.python-version }})
          path: 'galaxy root/run_playwright_tests.html'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Tool form harness debug info (${{ matrix.python-version }})
          path: 'galaxy root/database/test_errors'

name: Toolshed tests
on:
  push:
    paths-ignore:
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
env:
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
  TOOL_SHED_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/toolshed?client_encoding=utf8'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10', '3.14']
        test-install-client: ['galaxy_api', 'standalone']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-toolshed
      - name: Install dependencies
        run: ./scripts/common_startup.sh --dev-wheels --skip-client-build
        working-directory: 'galaxy root'
      - name: Setup pnpm
        uses: pnpm/action-setup@v5
        with:
          package_json_file: 'galaxy root/lib/tool_shed/webapp/frontend/package.json'
      - name: Build Frontend
        run: |
          . .venv/bin/activate
          cd lib/tool_shed/webapp/frontend
          pnpm install --frozen-lockfile
          make client
        working-directory: 'galaxy root'
      - name: Install playwright
        run: |
          . .venv/bin/activate
          playwright install
        working-directory: 'galaxy root'
      - name: Run tests
        run: ./run_tests.sh -toolshed
        env:
          TOOL_SHED_TEST_INSTALL_CLIENT: ${{ matrix.test-install-client }}
        working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Toolshed test results (${{ matrix.python-version }}, ${{ matrix.test-install-client }})
          path: 'galaxy root/run_toolshed_tests.html'

name: Unit w/postgres tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
env:
  GALAXY_TEST_DBURI: 'postgresql+psycopg://postgres:postgres@localhost:5432/postgres?client_encoding=utf8'  # using postgres as the db
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10']
    services:
      postgres:
        image: postgres:18
        env:
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: postgres
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Cache galaxy venv
        uses: actions/cache@v5
        with:
          path: 'galaxy root/.venv'
          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-unit-postgres
      - name: Run migration tests
        run: ./run_tests.sh -unit test/unit/data/model/migrations/test_migrations.py
        working-directory: 'galaxy root'
      - name: Run test migrate database
        run: ./run_tests.sh -unit test/unit/app/test_migrate_database.py
        working-directory: 'galaxy root'

name: Unit tests
on:
  push:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
  pull_request:
    paths-ignore:
      - 'client/**'
      - 'doc/**'
      - 'lib/galaxy_test/selenium/**'
      - 'packages/**'
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ['3.10', '3.14']
    steps:
      - uses: actions/checkout@v6
        with:
          path: 'galaxy root'
          persist-credentials: false
      - uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install uv
        uses: astral-sh/setup-uv@v7
      - name: Get full Python version
        id: full-python-version
        shell: bash
        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
      - name: Install ffmpeg
        run: sudo apt-get update && sudo apt-get -y install ffmpeg
      - name: Install tox
        run: uv tool install tox --with tox-uv
      - name: Run tests
        run: tox -e unit-coverage
        working-directory: 'galaxy root'
      - uses: codecov/codecov-action@v5
        with:
          flags: py-unit
          working-directory: 'galaxy root'
      - uses: actions/upload-artifact@v7
        if: failure()
        with:
          name: Unit test results (${{ matrix.python-version }})
          path: 'galaxy root/run_unit_tests.html'