Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

orchestrating-test-execution

/orchestrating-test-execution

Koordynuje równoległe uruchamianie testów w wielu środowiskach i frameworkach testowych, na przykład przy poleceniach orchestrate tests.

Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
7
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
4
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Koordynuje równoległe uruchamianie testów w wielu środowiskach i frameworkach testowych, na przykład przy poleceniach orchestrate tests.

Wyzwalacze z opisu

orchestrate testsrun parallel testscoordinate test execution
Oryginalny opis (EN)

Test coordinate parallel test execution across multiple environments and frameworks. Use when performing specialized testing. Trigger with phrases like "orchestrate tests", "run parallel tests", or "coordinate test execution".

Jak działa

  1. Overview
  2. Prerequisites
  3. Instructions
  4. Output
  5. Error Handling
  6. Examples
  7. Resources
Sekcje z nagłówków SKILL.md, w oryginale · 100 linii, 635 słów
Podgląd SKILL.md
---
name: orchestrating-test-execution
description: 'Test coordinate parallel test execution across multiple environments
  and frameworks.

  Use when performing specialized testing.

  Trigger with phrases like "orchestrate tests", "run parallel tests", or "coordinate
  test execution".

  '
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(test:orchestrate-*)
version: 1.25.0
author: Jeremy Longshore <jeremy@intentsolutions.io>
license: MIT
tags:
- testing
- orchestrating-test
compatibility: Designed for Claude Code
---
# Test Orchestrator

## Overview

Coordinate parallel test execution across multiple test suites, frameworks, and environments. Manages test splitting, worker allocation, result aggregation, and intelligent retry strategies.

## Prerequisites

- Test runner with parallel execution support (Jest, Vitest, pytest-xdist, Playwright, or JUnit 5)
- CI/CD platform configured (GitHub Actions, GitLab CI, CircleCI, or Jenkins)
- Test suite with consistent pass rates (flaky tests identified and tagged)
- Sufficient CI runner resources for parallel worker count
- Test result reporting tool (JUnit XML, Allure, or equivalent)

## Instructions

1. Analyze the existing test suite using Grep and Glob to catalog all test files, their framework, approximate run time, and dependency requirements.
2. Classify tests into execution tiers:
   - **Tier 1 (Fast)**: Unit tests with no I/O -- target under 30 seconds total.
   - **Tier 2 (Medium)**: Integration tests requiring local services -- target under 3 minutes.
   - **Tier 3 (Slow)**: E2E and browser tests -- target under 10 minutes.
3. Configure parallel execution for each tier:
   - Split unit tests across N workers using `jest --shard=i/N` or `pytest -n auto`.
   - Shard E2E tests by test file using Playwright `--shard=i/N` or Cypress parallelization.
   - Assign heavier integration tests to dedicated workers with more resources.
4. Create a CI pipeline configuration that runs tiers in parallel:
   - Tier 1 and Tier 2 run concurrently on separate jobs.
   - Tier 3 runs after a fast pre-check gate passes.
   - Each tier reports results to a unified collection step.
5. Implement intelligent retry logic for flaky tests:
   - Tag known flaky tests with `@flaky` or equivalent marker.
   - Retry failed tests up to 2 times before marking as failed.
   - Track flaky test frequency in a log file for triage.
6. Aggregate results from all parallel workers into a single report:
   - Merge JUnit XML files from each shard.
   - Calculate total pass/fail/skip counts and execution time.
   - Identify the slowest tests for optimization targets.
7. Write the orchestration configuration to the project's CI config file and validate it with a dry run.

## Output

- CI pipeline configuration file (`.github/workflows/test.yml`, `.gitlab-ci.yml`, or equivalent)
- Test sharding configuration with worker count and split strategy
- Merged test result report in JUnit XML or JSON format
- Execution timeline showing parallel job durations and bottlenecks
- Flaky test inventory with retry counts and failure patterns

## Error Handling

| Error | Cause | Solution |
|-------|-------|---------|
| Shard produces zero tests | Uneven test distribution or incorrect shard index | Verify shard count matches actual test file count; use file-based splitting |
| Worker out of memory | Too many parallel processes on one runner | Reduce `--maxWorkers` or `-n` count; increase runner memory; use `--workerIdleMemoryLimit` |
| Test ordering dependency | Tests pass in isolation but fail in specific shard order | Add `--randomize` flag; fix shared state leaks; enforce test independence |
| Result aggregation mismatch | Missing shard results due to job timeout | Set job-level timeouts higher than test timeouts; add result upload as a separate step |
| CI cache miss slowing startup | Dependencies not cached between parallel jobs | Configure dependency caching per lockfile hash; use a shared setup job |

## Examples

**GitHub Actions matrix strategy for Jest sharding:**

```yaml
jobs:
  test:
    strategy:
      matrix:
        shard: [1, 2, 3, 4]
    steps:
      - run: npx jest --shard=${{ matrix.shard }}/4 --ci --reporters=jest-junit
      - uses: actions/upload-artifact@v4
        with:
          name: results-${{ matrix.shard }}
          path: junit.xml
  merge:
    needs: test
    steps:
      - uses: actions/download-artifact@v4
      - run: npx junit-merge -d results-* -o merged-results.xml
```

**pytest-xdist parallel execution:**

```bash
pytest -n auto --dist worksteal -q --junitxml=results.xml
```

**Playwright sharded execution:**

```bash
npx playwright test --shard=1/3 --reporter=junit
```

## Resources

- Jest sharding: https://jestjs.io/docs/cli#--shardshardindex-shardcount
- pytest-xdist: https://pytest-xdist.readthedocs.io/
- Playwright test sharding: https://playwright.dev/docs/test-sharding
- GitHub Actions matrix strategy: https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs
- JUnit XML merge tools:
Pliki w paczce (7)
  • SKILL.md 5 KB
  • assets/README.md 1 KB
  • assets/configuration_template.yaml 4 KB
  • assets/example_test_graph.json 3 KB
  • assets/test_report_template.html 3 KB
  • references/README.md 1 KB
  • scripts/README.md 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · jeremylongshore/tons-of-skills-marketplace100MIT
HelixDevelopment/agent100MIT

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki e7c091a57888 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100orchestrating-subagents
    Prowadzi równoległe i szeregowe subagenty: koordynuje wykonanie planu z wielu jednostek, syntetyzuje wyniki niezależnych przebiegów i obsługuje awarie z ponowieniem.
  • 100running-mutation-tests
    Wykonuje testy mutacyjne, aby ocenić skuteczność zestawu testów.
  • 90quality-e2e-testing
    Konfiguruje testy end-to-end w Playwright lub Cypress: model page object, izolację testów, równoległe uruchamianie i integrację z CI.
  • 100qe-test-execution
    Organizuje uruchamianie testów z równoległym shardingiem, inteligentnym ponawianiem i raportowaniem na żywo w Jest, Vitest i Playwright, także dla niestabilnych testów i potoków CI.
  • 95testing
    Podaje wzorce testów opartych na zachowaniu: pisanie testów, fabryki danych testowych, struktura plików testowych i decyzje o tym, co testować.
  • 100running-mutation-tests
    Uruchamia testowanie mutacyjne, które sprawdza, czy testy faktycznie wychwytują błędy w kodzie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.