Gradle ტესტების დაყოფა

Tuist Gradle პლაგინი შეიცავს ჩაშენებულ მხარდაჭერას ტესტების დაყოფისთვის. ის გეგმავს სატესტო სუიტებს, რომლებიც Tuist-მა ჩაწერა თქვენი პროექტების სატესტო ამოცანების წინა CI გაშვებების დროს, და იყენებს Tuist სერვერს ბალანსირებული ნაწილების გეგმების შესაქმნელად ისტორიული დროის მონაცემების საფუძველზე.

REQUIREMENTS

ტესტების ანალიტიკა უნდა იყოს კონფიგურირებული

როგორ მუშაობს#

ტესტების დაყოფა მიჰყვება ორეტაპიან სამუშაო პროცესს:

აგების ეტაპი: Tuist ქმნის ნაწილების გეგმას სერვერზე თქვენი პროექტებისთვის ჩაწერილი სატესტო სუიტებიდან. სერვერი იყენებს ბოლო 30 დღის ისტორიულ სატესტო დროის მონაცემებს ტესტების ნაწილებად განაწილებისთვის, რათა თითოეულ ნაწილს დაახლოებით ერთნაირი დრო დასჭირდეს. აგების ეტაპი გამოაქვს ნაწილების მატრიცა, რომელსაც თქვენი CI სისტემა იყენებს პარალელური გამშვებების შესაქმნელად.
ტესტირების ეტაპი: თითოეული CI გამშვები იღებს ნაწილის ინდექსს და ასრულებს მხოლოდ იმ ტესტებს, რომლებიც ამ ნაწილს მიეკუთვნება. ბოლო ნაწილი ასევე ასრულებს ყველა სატესტო სუიტას, რომელიც არ არის მინიჭებული სხვა ნაწილზე.

აგების ეტაპი#

მოამზადეთ სატესტო ნაწილები tuistPrepareTestShards ამოცანის გამოყენებით:

bash

./gradlew tuistPrepareTestShards \
  -PtuistShardMax=5

ეს ამოცანა:

პოულობს პროექტებს, რომლებსაც აქვთ დასაყოფი სატესტო ამოცანა, მათი კომპილირების გარეშე
ქმნის ნაწილების გეგმას Tuist სერვერზე იმ პროექტებისთვის ჩაწერილი სატესტო სუიტებიდან და დროებიდან ბოლო 30 დღის განმავლობაში
გამოაქვს ნაწილების მატრიცა თქვენი CI სისტემისთვის

როდესაც სატესტო სუიტები ჯერ არ არის ჩაწერილი, მაგალითად პირველ გაშვებაზე, გეგმას აქვს ერთი ნაწილი, რომელიც ასრულებს ყველა ტესტს.

აგების პარამეტრები#

დააყენეთ დაყოფა Gradle პროექტის თვისებების მეშვეობით:

თვისება	აღწერა
`-PtuistShardMax=<N>`	ნაწილების მაქსიმალური რაოდენობა (ნაგულისხმები: 2)
`-PtuistShardMin=<N>`	ნაწილების მინიმალური რაოდენობა
`-PtuistShardMaxDuration=<MS>`	სამიზნე მაქსიმალური ხანგრძლივობა თითოეული ნაწილისთვის მილიწამებში
`-PtuistShardTestTask=<NAME>`	სატესტო ამოცანა, რომლის ტესტებიც იყოფა, მაგალითად `testDebugUnitTest`. ნაგულისხმევად იყენებს აგებაში არსებულ ყველა სატესტო ამოცანას

Android პროექტებს რამდენიმე აგების ვარიანტით აქვთ ერთი ერთეულოვანი ტესტის ამოცანა თითოეული ვარიანტისთვის. დააყენეთ -PtuistShardTestTask იმ ვარიანტზე, რომელსაც თქვენი ნაწილები ასრულებენ, რათა დაიგეგმოს მხოლოდ ის პროექტები, რომლებსაც ეს აქვთ:

bash

./gradlew tuistPrepareTestShards \
  -PtuistShardMax=5 \
  -PtuistShardTestTask=testDebugUnitTest

ნაწილის მითითება ავტომატურად მიიღება CI გარემოს ცვლადებიდან (GITHUB_RUN_ID, CI_PIPELINE_ID და ა.შ.) ან შეიძლება პირდაპირ დაყენდეს TUIST_SHARD_REFERENCE გარემოს ცვლადის მეშვეობით.

ტესტირების ეტაპი#

თითოეული ნაწილის გამშვები ასრულებს მისთვის მინიჭებულ ტესტებს სტანდარტული test ამოცანის გამოყენებით. როდესაც TUIST_SHARD_INDEX დაყენებულია, პლაგინი ავტომატურად იღებს ნაწილის მინიჭებას სერვერიდან და ფილტრავს ტესტების შესრულებას ისე, რომ მოიცვას მხოლოდ მინიჭებული სატესტო სუიტები. სატესტო ამოცანები პროექტებში, რომლებსაც არ აქვთ ნაწილზე მინიჭებული სუიტები, გამოტოვებულია.

ბოლო ნაწილი ასრულებს ყველა სატესტო ამოცანას და გამორიცხავს სხვა ნაწილებზე მინიჭებულ სუიტებს, ასე რომ სუიტები, რომლებსაც ჯერ არ აქვთ ჩაწერილი გაშვებები, როგორიცაა ახლად დამატებულები, მაინც სრულდება.

bash

TUIST_SHARD_INDEX=0 ./gradlew test

თუ აგების ეტაპზე დააყენეთ -PtuistShardTestTask, გაუშვით იგივე ამოცანა თითოეულ ნაწილში, მაგალითად ./gradlew testDebugUnitTest.

უწყვეტი ინტეგრაცია#

Tuist ავტომატურად აღმოაჩენს შემდეგ CI პროვაიდერებს:

GitHub Actions
GitLab CI
CircleCI
Buildkite
Codemagic
Bitrise

სხვა პროვაიდერებისთვის, მიმართეთ .tuist-shard-matrix.json ფაილს პარალელური სამუშაოების დასაყენებლად.

GitHub Actions#

გამოიყენეთ მატრიცის სტრატეგია ნაწილების პარალელურად გასაშვებად:

yaml

name: Tests
on: [pull_request]

jobs:
  build:
    name: Build test shards
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.build.outputs.matrix }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'
      - uses: gradle/actions/setup-gradle@v4
      - run: tuist auth login
      - id: build
        run: ./gradlew tuistPrepareTestShards -PtuistShardMax=5

  test:
    name: "Shard #${{ matrix.shard }}"
    needs: build
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        shard: ${{ fromJson(needs.build.outputs.matrix).shard }}
    env:
      TUIST_SHARD_INDEX: ${{ matrix.shard }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'
      - uses: gradle/actions/setup-gradle@v4
      - run: tuist auth login
      - run: ./gradlew test

GitLab CI#

Tuist ქმნის .tuist-shard-child-pipeline.yml, რომელსაც იწყებთ როგორც შვილობილ პაიპლაინს. განსაზღვრეთ .tuist-shard შაბლონური სამუშაო, რომელსაც გაფართოებული ნაწილის სამუშაოები ეყრდნობიან:

yaml

# .gitlab-ci.yml
stages:
  - build
  - test

build-shards:
  stage: build
  script:
    - tuist auth login
    - ./gradlew tuistPrepareTestShards -PtuistShardMax=5
  artifacts:
    paths:
      - .tuist-shard-child-pipeline.yml

test-shards:
  stage: test
  needs: [build-shards]
  trigger:
    include:
      - artifact: .tuist-shard-child-pipeline.yml
        job: build-shards
    strategy: depend

შვილობილ პაიპლაინს სჭირდება .tuist-shard სამუშაოს შაბლონი:

yaml

# .gitlab/shard-template.yml
.tuist-shard:
  script:
    - tuist auth login
    - ./gradlew test

CircleCI#

Tuist ქმნის .tuist-shard-continuation.json პარამეტრებით გაგრძელების orb-ისთვის:

yaml

# .circleci/config.yml
version: 2.1
setup: true

orbs:
  continuation: circleci/continuation@1

jobs:
  build-shards:
    docker:
      - image: cimg/openjdk:17.0
    steps:
      - checkout
      - run:
          name: Build and plan shards
          command: |
            tuist auth login
            ./gradlew tuistPrepareTestShards -PtuistShardMax=5
      - continuation/continue:
          configuration_path: .circleci/continue-config.yml
          parameters: .tuist-shard-continuation.json

workflows:
  setup:
    jobs:
      - build-shards

yaml

# .circleci/continue-config.yml
version: 2.1

parameters:
  shard-indices:
    type: string
    default: ""
  shard-count:
    type: integer
    default: 0

jobs:
  test-shard:
    docker:
      - image: cimg/openjdk:17.0
    parameters:
      shard-index:
        type: integer
    steps:
      - checkout
      - run:
          name: Run shard
          command: |
            export TUIST_SHARD_INDEX=<< parameters.shard-index >>
            tuist auth login
            ./gradlew test

workflows:
  test:
    jobs:
      - test-shard:
          matrix:
            parameters:
              shard-index: [<< pipeline.parameters.shard-indices >>]

Buildkite#

Tuist ქმნის .tuist-shard-pipeline.yml ერთი ნაბიჯით თითოეული ნაწილისთვის. ატვირთეთ ის buildkite-agent pipeline upload-ის გამოყენებით:

yaml

# pipeline.yml
steps:
  - label: "Build test shards"
    command: |
      tuist auth login
      ./gradlew tuistPrepareTestShards -PtuistShardMax=5
      buildkite-agent pipeline upload .tuist-shard-pipeline.yml

თითოეულ შექმნილ ნაბიჯს გარემოში აქვს დაყენებული TUIST_SHARD_INDEX. დაამატეთ ტესტის ბრძანება თითოეულ ნაწილის ნაბიჯზე საერთო სკრიპტის გამოყენებით:

bash

# .buildkite/shard-step.sh
#!/bin/bash
tuist auth login
./gradlew test

Codemagic#

Codemagic არ უჭერს მხარს დინამიურ მატრიცულ სამუშაოებს, ამიტომ განსაზღვრეთ ცალკეული სამუშაო ნაკადი თითოეული ნაწილისთვის. Tuist წერს TUIST_SHARD_MATRIX და TUIST_SHARD_COUNTCM_ENV ფაილში, რათა გამოიყენონ თითოეულ სამუშაო ნაკადში:

yaml

# codemagic.yaml
workflows:
  build-shards:
    name: Build test shards
    instance_type: linux_x2
    environment:
      java: 17
    scripts:
      - name: Build and plan shards
        script: |
          tuist auth login
          ./gradlew tuistPrepareTestShards -PtuistShardMax=5

  test-shard-0: &shard-workflow
    name: "Shard #0"
    instance_type: linux_x2
    environment:
      java: 17
      vars:
        TUIST_SHARD_INDEX: 0
    scripts:
      - name: Run shard
        script: |
          tuist auth login
          ./gradlew test

  test-shard-1:
    <<: *shard-workflow
    name: "Shard #1"
    environment:
      java: 17
      vars:
        TUIST_SHARD_INDEX: 1

  test-shard-2:
    <<: *shard-workflow
    name: "Shard #2"
    environment:
      java: 17
      vars:
        TUIST_SHARD_INDEX: 2

  test-shard-3:
    <<: *shard-workflow
    name: "Shard #3"
    environment:
      java: 17
      vars:
        TUIST_SHARD_INDEX: 3

  test-shard-4:
    <<: *shard-workflow
    name: "Shard #4"
    environment:
      java: 17
      vars:
        TUIST_SHARD_INDEX: 4

Bitrise#

Bitrise-ზე, Tuist წერს .tuist-shard-matrix.jsonBITRISE_DEPLOY_DIR-ში, რაც ხელმისაწვდომს ხდის მას აგების არტეფაქტად მომდევნო პაიპლაინის ეტაპებისთვის. გამოიყენეთ Bitrise Pipelines წინასწარ განსაზღვრული პარალელური სამუშაო ნაკადებით:

yaml

# bitrise.yml
pipelines:
  test-pipeline:
    stages:
      - build-stage: {}
      - test-stage: {}

stages:
  build-stage:
    workflows:
      - build-shards: {}
  test-stage:
    workflows:
      - test-shard-0: {}
      - test-shard-1: {}
      - test-shard-2: {}
      - test-shard-3: {}
      - test-shard-4: {}

workflows:
  build-shards:
    steps:
      - script:
          title: Build and plan shards
          inputs:
            - content: |
                tuist auth login
                ./gradlew tuistPrepareTestShards -PtuistShardMax=5

  test-shard-0: &shard-workflow
    envs:
      - TUIST_SHARD_INDEX: 0
    steps:
      - script:
          title: Run shard
          inputs:
            - content: |
                tuist auth login
                ./gradlew test
  test-shard-1:
    <<: *shard-workflow
    envs:
      - TUIST_SHARD_INDEX: 1
  test-shard-2:
    <<: *shard-workflow
    envs:
      - TUIST_SHARD_INDEX: 2
  test-shard-3:
    <<: *shard-workflow
    envs:
      - TUIST_SHARD_INDEX: 3
  test-shard-4:
    <<: *shard-workflow
    envs:
      - TUIST_SHARD_INDEX: 4

Tip

Bitrise არ უჭერს მხარს დინამიურ პარალელურ სამუშაოების შექმნას შესრულების დროს. განსაზღვრეთ ფიქსირებული რაოდენობის ნაწილის სამუშაო ნაკადები თქვენს პაიპლაინის ეტაპებში — ეტაპის შიგნით სამუშაო ნაკადები ავტომატურად პარალელურად სრულდება.