mongodb/mongo-ruby-driver

View on GitHub
.evergreen/config-atlas.yml

Summary

Maintainability
Test Coverage
# GENERATED FILE - DO NOT EDIT.
# Run ./.evergreen/update-evergreen-configs to regenerate this file.

# When a task that used to pass starts to fail, go through all versions that
# may have been skipped to detect when the task started failing.
stepback: true

# Fail builds when pre tasks fail.
pre_error_fails_task: true

# Mark a failure as a system/bootstrap failure (purple box) rather then a task
# failure by default.
# Actual testing tasks are marked with `type: test`
command_type: system

# Protect ourself against rogue test case, or curl gone wild, that runs forever.
exec_timeout_secs: 1800


# What to do when evergreen hits the timeout (`post:` tasks are run automatically)
timeout:
  - command: shell.exec
    params:
      script: |
        true

functions:
  "fetch source":
    # Executes git clone and applies the submitted patch, if any
    - command: git.get_project
      params:
        directory: "src"
    - command: shell.exec
      params:
        working_dir: "src"
        script: |
          set -ex

          git submodule update --init --recursive

  "fetch egos":
    - command: shell.exec
      params:
        working_dir: "src"
        script: |
          set -e

          # Python version:
          #curl -sfLo egos https://raw.githubusercontent.com/p-mongo/egos/master/egos

          # C version:
          curl --retry 3 -sfLo egos.c https://raw.githubusercontent.com/p-mongo/egos/master/egos.c
          gcc -O2 -g -oegos -lrt egos.c

  "create expansions":
    # Make an evergreen expansion file with dynamic values
    - command: shell.exec
      params:
        working_dir: "src"
        script: |
          # Get the current unique version of this checkout
          if [ "${is_patch}" = "true" ]; then
            CURRENT_VERSION=$(git describe)-patch-${version_id}
          else
            CURRENT_VERSION=latest
          fi

          export DRIVERS_TOOLS="$(pwd)/../drivers-tools"

          # Python has cygwin path problems on Windows. Detect prospective mongo-orchestration home directory
          if [ "Windows_NT" = "$OS" ]; then # Magic variable in cygwin
            export DRIVERS_TOOLS=$(cygpath -m $DRIVERS_TOOLS)
          fi

          export MONGO_ORCHESTRATION_HOME="$DRIVERS_TOOLS/.evergreen/orchestration"
          export MONGODB_BINARIES="$DRIVERS_TOOLS/mongodb/bin"
          export UPLOAD_BUCKET="${project}"
          export PROJECT_DIRECTORY="$(pwd)"

          cat <<EOT > expansion.yml
          CURRENT_VERSION: "$CURRENT_VERSION"
          DRIVERS_TOOLS: "$DRIVERS_TOOLS"
          MONGO_ORCHESTRATION_HOME: "$MONGO_ORCHESTRATION_HOME"
          MONGODB_BINARIES: "$MONGODB_BINARIES"
          UPLOAD_BUCKET: "$UPLOAD_BUCKET"
          PROJECT_DIRECTORY: "$PROJECT_DIRECTORY"
          PREPARE_SHELL: |
            set -o errexit
            set -o xtrace
            export DRIVERS_TOOLS="$DRIVERS_TOOLS"
            export MONGO_ORCHESTRATION_HOME="$MONGO_ORCHESTRATION_HOME"
            export MONGODB_BINARIES="$MONGODB_BINARIES"
            export UPLOAD_BUCKET="$UPLOAD_BUCKET"
            export PROJECT_DIRECTORY="$PROJECT_DIRECTORY"

            # TMPDIR cannot be too long, see
            # https://github.com/broadinstitute/cromwell/issues/3647.
            # Why is it even set at all?
            #export TMPDIR="$MONGO_ORCHESTRATION_HOME/db"
            export PATH="$MONGODB_BINARIES:$PATH"
            export PROJECT="${project}"
            export ATLAS_REPLICA_SET_URI="${atlas_replica_set_uri}"
            export ATLAS_SHARDED_URI="${atlas_sharded_uri}"
            export ATLAS_FREE_TIER_URI="${atlas_free_tier_uri}"
            export ATLAS_TLS11_URI="${atlas_tls11_uri}"
            export ATLAS_TLS12_URI="${atlas_tls12_uri}"
            export ATLAS_SERVERLESS_URI="${atlas_serverless_uri}"
            export ATLAS_SERVERLESS_LB_URI="${atlas_serverless_lb_uri}"
            export RVM_RUBY="${RVM_RUBY}"
            export SERVERLESS_DRIVERS_GROUP="${SERVERLESS_DRIVERS_GROUP}"
            export SERVERLESS_API_PUBLIC_KEY="${SERVERLESS_API_PUBLIC_KEY}"
            export SERVERLESS_API_PRIVATE_KEY="${SERVERLESS_API_PRIVATE_KEY}"
            export SERVERLESS_ATLAS_USER="${SERVERLESS_ATLAS_USER}"
            export SERVERLESS_ATLAS_PASSWORD="${SERVERLESS_ATLAS_PASSWORD}"
          EOT
          # See what we've done
          cat expansion.yml

    # Load the expansion file to make an evergreen variable with the current
    # unique version
    - command: expansions.update
      params:
        file: src/expansion.yml

  "delete serverless instance":
    - command: shell.exec
      params:
        working_dir: "src"
        shell: bash
        script: |
          ${PREPARE_SHELL}
          if [[ -n "${SERVERLESS_INSTANCE_NAME}" ]]; then
            SERVERLESS_INSTANCE_NAME=${SERVERLESS_INSTANCE_NAME} .evergreen/serverless/delete-instance.sh
          fi

  "export AWS auth credentials":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          cat <<EOT > .env.private
          IAM_AUTH_ASSUME_AWS_ACCOUNT="${iam_auth_assume_aws_account}"
          IAM_AUTH_ASSUME_AWS_SECRET_ACCESS_KEY="${iam_auth_assume_aws_secret_access_key}"
          IAM_AUTH_ASSUME_ROLE_NAME="${iam_auth_assume_role_name}"
          IAM_AUTH_EC2_INSTANCE_ACCOUNT="${iam_auth_ec2_instance_account}"
          IAM_AUTH_EC2_INSTANCE_PROFILE="${iam_auth_ec2_instance_profile}"
          IAM_AUTH_EC2_INSTANCE_SECRET_ACCESS_KEY="${iam_auth_ec2_instance_secret_access_key}"
          IAM_AUTH_ECS_ACCOUNT="${iam_auth_ecs_account}"
          IAM_AUTH_ECS_ACCOUNT_ARN="${iam_auth_ecs_account_arn}"
          IAM_AUTH_ECS_CLUSTER="${iam_auth_ecs_cluster}"
          IAM_AUTH_ECS_SECRET_ACCESS_KEY="${iam_auth_ecs_secret_access_key}"
          IAM_AUTH_ECS_SECURITY_GROUP="${iam_auth_ecs_security_group}"
          IAM_AUTH_ECS_SUBNET_A="${iam_auth_ecs_subnet_a}"
          IAM_AUTH_ECS_SUBNET_B="${iam_auth_ecs_subnet_b}"
          IAM_AUTH_ECS_TASK_DEFINITION="${iam_auth_ecs_task_definition}"
          EOT

  "export FLE credentials":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          cat <<EOT > .env.private
          MONGO_RUBY_DRIVER_AWS_KEY="${fle_aws_key}"
          MONGO_RUBY_DRIVER_AWS_SECRET="${fle_aws_secret}"
          MONGO_RUBY_DRIVER_AWS_REGION="${fle_aws_region}"
          MONGO_RUBY_DRIVER_AWS_ARN="${fle_aws_arn}"

          MONGO_RUBY_DRIVER_AZURE_TENANT_ID="${fle_azure_tenant_id}"
          MONGO_RUBY_DRIVER_AZURE_CLIENT_ID="${fle_azure_client_id}"
          MONGO_RUBY_DRIVER_AZURE_CLIENT_SECRET="${fle_azure_client_secret}"
          MONGO_RUBY_DRIVER_AZURE_IDENTITY_PLATFORM_ENDPOINT="${fle_azure_identity_platform_endpoint}"
          MONGO_RUBY_DRIVER_AZURE_KEY_VAULT_ENDPOINT="${fle_azure_key_vault_endpoint}"
          MONGO_RUBY_DRIVER_AZURE_KEY_NAME="${fle_azure_key_name}"

          MONGO_RUBY_DRIVER_GCP_EMAIL="${fle_gcp_email}"
          MONGO_RUBY_DRIVER_GCP_PRIVATE_KEY="${fle_gcp_private_key}"
          MONGO_RUBY_DRIVER_GCP_PROJECT_ID="${fle_gcp_project_id}"
          MONGO_RUBY_DRIVER_GCP_LOCATION="${fle_gcp_location}"
          MONGO_RUBY_DRIVER_GCP_KEY_RING="${fle_gcp_key_ring}"
          MONGO_RUBY_DRIVER_GCP_KEY_NAME="${fle_gcp_key_name}"
          MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT="${fle_mongocryptd_port}"
          EOT

  "export Kerberos credentials":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          cat <<EOT > .env.private
          SASL_HOST=${sasl_host}
          SASL_PORT=${sasl_port}
          SASL_USER=${sasl_user}
          SASL_PASS=${sasl_pass}
          SASL_DB=${sasl_db}
          PRINCIPAL=${principal}
          KERBEROS_DB=${kerberos_db}
          KEYTAB_BASE64=${keytab_base64}
          EOT

  "exec script" :
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          sh ${PROJECT_DIRECTORY}/${file}

  "upload mo artifacts":
    - command: shell.exec
      params:
        script: |
          ${PREPARE_SHELL}
          find $MONGO_ORCHESTRATION_HOME -name \*.log\* | xargs tar czf mongodb-logs.tar.gz
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: mongodb-logs.tar.gz
        remote_file: ${UPLOAD_BUCKET}/${build_variant}/${revision}/${version_id}/${build_id}/logs/${task_id}-${execution}-mongodb-logs.tar.gz
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: "mongodb-logs.tar.gz"

  "upload working dir":
    - command: archive.targz_pack
      params:
        target: "working-dir.tar.gz"
        source_dir: ${PROJECT_DIRECTORY}/
        include:
          - "./**"
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: working-dir.tar.gz
        remote_file: ${UPLOAD_BUCKET}/${build_variant}/${revision}/${version_id}/${build_id}/artifacts/${task_id}-${execution}-working-dir.tar.gz
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: "working-dir.tar.gz"
    - command: archive.targz_pack
      params:
        target: "drivers-dir.tar.gz"
        source_dir: ${DRIVERS_TOOLS}
        include:
          - "./**"
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: drivers-dir.tar.gz
        remote_file: ${UPLOAD_BUCKET}/${build_variant}/${revision}/${version_id}/${build_id}/artifacts/${task_id}-${execution}-drivers-dir.tar.gz
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: "drivers-dir.tar.gz"

  "upload test results to s3":
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        # src is the relative path to repo checkout,
        # This is specified in this yaml file earlier.
        local_file: ./src/tmp/rspec.json
        display_name: rspec.json
        remote_file: ${UPLOAD_BUCKET}/${version_id}/${build_id}/artifacts/${build_variant}/rspec.json
        content_type: application/json
        permissions: public-read
        bucket: mciuploads
    # AWS does not appear to support on-the-fly gzip encoding; compress
    # the results manually and upload a compressed file.
    # Typical size reduction: 50 MB -> 800 KB
    - command: shell.exec
      params:
        script: |
          gzip <src/tmp/rspec.json >src/tmp/rspec.json.gz
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        # src is the relative path to repo checkout,
        # This is specified in this yaml file earlier.
        local_file: ./src/tmp/rspec.json.gz
        display_name: rspec.json.gz
        remote_file: ${UPLOAD_BUCKET}/${version_id}/${build_id}/artifacts/${build_variant}/rspec.json.gz
        content_type: application/gzip
        permissions: public-read
        bucket: mciuploads
    - command: shell.exec
      params:
        script: |
          xz -9 <src/tmp/rspec.json >src/tmp/rspec.json.xz
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        # src is the relative path to repo checkout,
        # This is specified in this yaml file earlier.
        local_file: ./src/tmp/rspec.json.xz
        display_name: rspec.json.xz
        remote_file: ${UPLOAD_BUCKET}/${version_id}/${build_id}/artifacts/${build_variant}/rspec.json.xz
        content_type: application/x-xz
        permissions: public-read
        bucket: mciuploads

  "upload test results":
    - command: attach.xunit_results
      params:
        file: ./src/tmp/rspec.xml

  "delete private environment":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          rm -f .env.private

  "build and test docker image":
    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          set -x
          ./egos stdbuf -i0 -o0 -e0 .evergreen/test-on-docker -d ${os} MONGODB_VERSION=${mongodb-version} TOPOLOGY=${topology} RVM_RUBY=${ruby} -s .evergreen/run-tests.sh TEST_CMD=true ${PRELOAD_ARG}

  "run tests":
    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ./egos stdbuf -i0 -o0 -e0 .evergreen/run-tests.sh

  "run tests via docker":
    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ./egos stdbuf -i0 -o0 -e0 .evergreen/run-tests-docker.sh

  "run AWS auth tests":
    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ./egos stdbuf -i0 -o0 -e0 .evergreen/run-tests-aws-auth.sh

  "run Kerberos unit tests":
    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ./egos stdbuf -i0 -o0 -e0 .evergreen/run-tests-kerberos-unit.sh

  "run Kerberos integration tests":
    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ./egos stdbuf -i0 -o0 -e0 .evergreen/run-tests-kerberos-integration.sh

  "run Atlas tests":
    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          AUTH=${AUTH} SSL=${SSL} TOPOLOGY=${TOPOLOGY} RVM_RUBY="${RVM_RUBY}" ATLAS_REPLICA_SET_URI=${atlas_replica_set_uri} ATLAS_SHARDED_URI=${atlas_sharded_uri} ATLAS_FREE_TIER_URI=${atlas_free_tier_uri} ATLAS_TLS11_URI=${atlas_tls11_uri} ATLAS_TLS12_URI=${atlas_tls12_uri} ATLAS_SERVERLESS_URI=${atlas_serverless_uri} ATLAS_SERVERLESS_LB_URI=${atlas_serverless_lb_uri} .evergreen/run-tests-atlas.sh

  "run serverless tests":
    - command: shell.exec
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          # This hack with PROJECT env is necessary while serverless
          # rejects creating instances with too long names.
          PROJECT="mongo-ruby-driver" LOADBALANCED="ON" .evergreen/serverless/create-instance.sh
          cat serverless-expansion.yml

    - command: expansions.update
      params:
        file: src/serverless-expansion.yml

    - command: shell.exec
      type: test
      params:
        shell: bash
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          SERVERLESS=1 SSL=ssl RVM_RUBY="${RVM_RUBY}" SINGLE_MONGOS="${SINGLE_MONGOS}" SERVERLESS_URI="${SERVERLESS_URI}" .evergreen/run-tests-serverless.sh

pre:
  - func: "fetch source"
  - func: "fetch egos"
  - func: "create expansions"

post:
  - func: "delete private environment"
  # Removed, causing timeouts
  # - func: "upload working dir"
  - func: "upload mo artifacts"
  #- func: "upload test results"
  - func: "upload test results to s3"
  - func: "delete serverless instance"

tasks:

  - name: "test-atlas"
    commands:
      - func: "run Atlas tests"
  - name: "test-serverless"
    commands:
      - func: "run serverless tests"
axes:

  - id: preload
    display_name: Preload server
    values:
      - id: nopreload
        display_name: Do not preload
      - id: preload
        display_name: Preload
        variables:
          PRELOAD_ARG: -p

  - id: "mongodb-version"
    display_name: MongoDB Version
    values:
      - id: "latest"
        display_name: "latest"
        variables:
          MONGODB_VERSION: "latest"
      - id: "6.0"
        display_name: "6.0"
        variables:
          MONGODB_VERSION: "6.0"
      - id: "5.3"
        display_name: "5.3"
        variables:
          MONGODB_VERSION: "5.3"
      - id: "5.0"
        display_name: "5.0"
        variables:
          MONGODB_VERSION: "5.0"
      - id: "4.4"
        display_name: "4.4"
        variables:
          MONGODB_VERSION: "4.4"
      - id: "4.2"
        display_name: "4.2"
        variables:
          MONGODB_VERSION: "4.2"
      - id: "4.0"
        display_name: "4.0"
        variables:
          MONGODB_VERSION: "4.0"
      - id: "3.6"
        display_name: "3.6"
        variables:
          MONGODB_VERSION: "3.6"

  - id: fcv
    display_name: FCV
    values:
      - id: '3.4'
        display_name: '3.4'
        variables:
          FCV: '3.4'

  - id: "topology"
    display_name: Topology
    values:
      - id: "standalone"
        display_name: Standalone
        variables:
          TOPOLOGY: standalone
      - id: "replica-set"
        display_name: Replica Set
        variables:
          TOPOLOGY: replica-set
      - id: "sharded-cluster"
        display_name: Sharded
        variables:
          TOPOLOGY: sharded-cluster
      - id: "load-balanced"
        display_name: Load Balanced
        variables:
          TOPOLOGY: load-balanced

  - id: "single-mongos"
    display_name: Single Mongos
    values:
      - id: "single-mongos"
        display_name: Single Mongos
        variables:
          SINGLE_MONGOS: 'true'

  - id: "auth-and-ssl"
    display_name: Authentication and SSL
    values:
      - id: "auth-and-ssl"
        display_name: Auth SSL
        variables:
          AUTH: "auth"
          SSL: "ssl"
      - id: "auth-and-nossl"
        display_name: Auth NoSSL
        variables:
          AUTH: "auth"
      - id: "noauth-and-ssl"
        display_name: NoAuth SSL
        variables:
          SSL: "ssl"
      - id: "noauth-and-nossl"
        display_name: NoAuth NoSSL
      - id: "x509"
        display_name: X.509
        variables:
          AUTH: "x509"
          SSL: "ssl"
      - id: kerberos
        display_name: Kerberos
        variables:
          AUTH: kerberos
      - id: aws-regular
        display_name: AWS Auth Regular Credentials
        variables:
          AUTH: aws-regular
      - id: aws-assume-role
        display_name: AWS Auth Assume Role
        variables:
          AUTH: aws-assume-role
      - id: aws-ec2
        display_name: AWS Auth EC2 Role
        variables:
          AUTH: aws-ec2
      - id: aws-ecs
        display_name: AWS Auth ECS Task
        variables:
          AUTH: aws-ecs

  - id: "ruby"
    display_name: Ruby Version
    values:
      - id: "ruby-3.1"
        display_name: ruby-3.1
        variables:
          RVM_RUBY: "ruby-3.1"
      - id: "ruby-3.0"
        display_name: ruby-3.0
        variables:
          RVM_RUBY: "ruby-3.0"
      - id: "ruby-2.7"
        display_name: ruby-2.7
        variables:
          RVM_RUBY: "ruby-2.7"
      - id: "ruby-2.6"
        display_name: ruby-2.6
        variables:
          RVM_RUBY: "ruby-2.6"
      - id: "ruby-2.5"
        display_name: ruby-2.5
        variables:
          RVM_RUBY: "ruby-2.5"
      - id: "ruby-head"
        display_name: ruby-head
        variables:
          RVM_RUBY: "ruby-head"
      - id: "jruby-9.2"
        display_name: jruby-9.2
        variables:
          RVM_RUBY: "jruby-9.2"
      - id: "jruby-9.3"
        display_name: jruby-9.3
        variables:
          RVM_RUBY: "jruby-9.3"

  - id: "os"
    display_name: OS
    values:
      - id: ubuntu2004
        display_name: "Ubuntu 20.04"
        run_on: ubuntu2004-small
      - id: ubuntu1804
        display_name: "Ubuntu 18.04"
        run_on: ubuntu1804-small
      - id: ubuntu1604
        display_name: "Ubuntu 16.04"
        run_on: ubuntu1604-small
      - id: rhel80
        display_name: "RHEL 8"
        run_on: rhel80-small
      - id: rhel70
        display_name: "RHEL 7"
        run_on: rhel70-small
      - id: rhel62
        display_name: "RHEL 6"
        run_on: rhel62-small

  - id: docker-distro
    display_name: Docker Distro
    values:
        - id: debian92
          display_name: debian92
          variables:
            DOCKER_DISTRO: debian92
        - id: debian10
          display_name: debian10
          variables:
            DOCKER_DISTRO: debian10
        - id: ubuntu1804
          display_name: ubuntu1804
          variables:
            DOCKER_DISTRO: ubuntu1804

  - id: "compressor"
    display_name: Compressor
    values:
      - id: "zlib"
        display_name: Zlib
        variables:
          COMPRESSOR: "zlib"
      - id: "snappy"
        display_name: Snappy
        variables:
          COMPRESSOR: "snappy"
      - id: "zstd"
        display_name: Zstd
        variables:
          COMPRESSOR: "zstd"

  - id: retry-reads
    display_name: Retry Reads
    values:
      - id: no-retry-reads
        display_name: No Retry Reads
        variables:
          RETRY_READS: 'false'

  - id: retry-writes
    display_name: Retry Writes
    values:
      - id: no-retry-writes
        display_name: No Retry Writes
        variables:
          RETRY_WRITES: 'false'

  - id: lint
    display_name: Lint
    values:
      - id: on
        display_name: On
        variables:
          LINT: '1'

  - id: stress
    display_name: Stress
    values:
      - id: on
        display_name: On
        variables:
          STRESS: '1'

  - id: fork
    display_name: Fork
    values:
      - id: on
        display_name: On
        variables:
          FORK: '1'

  - id: solo
    display_name: Solo
    values:
      - id: on
        display_name: On
        variables:
          SOLO: '1'

  - id: "as"
    display_name: ActiveSupport
    values:
      - id: "as"
        display_name: AS
        variables:
          WITH_ACTIVE_SUPPORT: true

  - id: bson
    display_name: BSON
    values:
      - id: master
        display_name: master
        variables:
          BSON: master
      - id: 4-stable
        display_name: 4-stable
        variables:
          BSON: 4-stable
      - id: min
        display_name: min
        variables:
          BSON: min

  - id: storage-engine
    display_name: Storage Engine
    values:
      - id: mmapv1
        display_name: MMAPv1
        run_on: ubuntu1604-small
        variables:
          MMAPV1: 'true'

  - id: "fle"
    display_name: FLE
    values:
      - id: "helper"
        display_name: via LMC helper
        variables:
          FLE: helper
      - id: "path"
        display_name: via LMC path
        variables:
          FLE: path

  - id: ocsp-algorithm
    display_name: OCSP Algorithm
    values:
      - id: rsa
        display_name: RSA
        variables:
          OCSP_ALGORITHM: rsa
      - id: ecdsa
        display_name: ECDSA
        variables:
          OCSP_ALGORITHM: ecdsa

  - id: ocsp-status
    display_name: OCSP Status
    values:
      - id: valid
        display_name: Valid
      - id: revoked
        display_name: Revoked
        variables:
          OCSP_STATUS: revoked
      - id: unknown
        display_name: Unknown
        variables:
          OCSP_STATUS: unknown

  - id: ocsp-delegate
    display_name: OCSP Delegate
    values:
      - id: on
        display_name: on
        variables:
          OCSP_DELEGATE: 1

  - id: ocsp-must-staple
    display_name: OCSP Must Staple
    values:
      - id: on
        display_name: on
        variables:
          OCSP_MUST_STAPLE: 1

  - id: ocsp-verifier
    display_name: OCSP Verifier
    values:
      - id: true
        display_name: true
        variables:
          OCSP_VERIFIER: 1

  - id: ocsp-connectivity
    display_name: OCSP Connectivity
    values:
      - id: pass
        display_name: pass
        variables:
          OCSP_CONNECTIVITY: pass
      - id: fail
        display_name: fail
        variables:
          OCSP_CONNECTIVITY: fail

  - id: extra-uri-options
    display_name: extra URI options
    values:
      - id: none
        display_name: None
      - id: "tlsInsecure=true"
        variables:
          EXTRA_URI_OPTIONS: "tlsInsecure=true"
      - id: "tlsAllowInvalidCertificates=true"
        variables:
          EXTRA_URI_OPTIONS: "tlsAllowInvalidCertificates=true"

  - id: api-version-required
    display_name: API version required
    values:
      - id: yes
        display_name: Yes
        variables:
          API_VERSION_REQUIRED: 1
      - id: no
        display_name: No
buildvariants:
  - matrix_name: "all"
    matrix_spec:
      ruby: ["ruby-2.5", "ruby-2.6", "ruby-2.7", "ruby-3.0", "ruby-3.1", "jruby-9.2"]
    display_name: "Atlas tests ${ruby}"
    run_on:
      - ubuntu1804-small
    tasks:
       - name: test-atlas

  - matrix_name: "serverless"
    matrix_spec:
      ruby: ["ruby-2.5", "ruby-2.6", "ruby-2.7", "ruby-3.0", "ruby-3.1", "jruby-9.2"]
    display_name: "Atlas serverless ${ruby} single mongos"
    run_on:
      - ubuntu1804-small
    tasks:
       - name: test-serverless