testdriverai 7.2.3 → 7.2.10

package/docs/v7/features/parallel-execution.mdx

@@ -1,381 +0,0 @@
----
-title: "Parallel Execution"
-description: "Run tests concurrently for maximum throughput and faster CI pipelines"
-icon: "layer-group"
----
-
-Speed up your test suite by running multiple tests simultaneously. TestDriver's parallel execution capabilities let you maximize throughput and reduce overall test duration.
-
-## Quick Start
-
-Enable parallel execution in your Vitest configuration:
-
-```javascript vitest.config.mjs
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    testTimeout: 120000,
-    maxConcurrency: 10, // Run 10 tests simultaneously
-  },
-});
-```
-
-## Performance Comparison
-
-See the dramatic difference parallel execution makes:
-
-<CardGroup cols={2}>
-  <Card title="Sequential Execution" icon="chevron-right">
-    ```mermaid
-    gantt
-        title Sequential: 90s total
-        dateFormat s
-        axisFormat %Ss
-        Test 1 :done, t1, 0, 30s
-        Test 2 :done, t2, after t1, 30s
-        Test 3 :done, t3, after t2, 30s
-    ```
-  </Card>
-
-  <Card title="Parallel Execution (3x)" icon="chevrons-right">
-    ```mermaid
-    gantt
-        title Parallel: 30s total
-        dateFormat s
-        axisFormat %Ss
-        Test 1 :done, t1, 0, 30s
-        Test 2 :done, t2, 0, 30s
-        Test 3 :done, t3, 0, 30s
-    ```
-  </Card>
-</CardGroup>
-
-<Check>
-  **3x faster** - Run tests in parallel to dramatically reduce total execution time.
-</Check>
-
-## Real-World Example
-
-Here's how parallel execution impacts a real test suite:
-
-<CodeGroup>
-```bash Sequential (1 test at a time)
-$ npx vitest run --maxConcurrency=1
-
- ✓ test/login.test.js (3 tests) 87.4s
- ✓ test/checkout.test.js (5 tests) 142.6s
- ✓ test/profile.test.js (4 tests) 98.2s
-
- Test Files: 3 passed (3)
- Tests: 12 passed (12)
- Duration: 328.2s
-```
-
-```bash Parallel (10 tests at a time)
-$ npx vitest run --maxConcurrency=10
-
- ✓ test/login.test.js (3 tests) 31.2s
- ✓ test/checkout.test.js (5 tests) 58.7s
- ✓ test/profile.test.js (4 tests) 35.1s
-
- Test Files: 3 passed (3)
- Tests: 12 passed (12)
- Duration: 58.7s (5.6x faster ⚡)
-```
-</CodeGroup>
-
-## Configuration Options
-
-Fine-tune parallel execution for your needs:
-
-<Tabs>
-  <Tab title="Basic Concurrency">
-    ```javascript vitest.config.mjs
-    export default defineConfig({
-      test: {
-        maxConcurrency: 10, // Max parallel tests
-      },
-    });
-    ```
-
-    Control how many tests run simultaneously.
-  </Tab>
-
-  <Tab title="Thread Control">
-    ```javascript vitest.config.mjs
-    export default defineConfig({
-      test: {
-        pool: 'threads',
-        poolOptions: {
-          threads: {
-            minThreads: 2,
-            maxThreads: 8
-          }
-        }
-      },
-    });
-    ```
-
-    Manage worker thread pool for optimal performance.
-  </Tab>
-
-  <Tab title="File-Level Parallelism">
-    ```javascript vitest.config.mjs
-    export default defineConfig({
-      test: {
-        fileParallelism: true, // Default
-        maxConcurrency: 5,      // Tests per file
-      },
-    });
-    ```
-
-    Run test files in parallel, with concurrent tests within each file.
-  </Tab>
-
-  <Tab title="CI Optimization">
-    ```javascript vitest.config.mjs
-    export default defineConfig({
-      test: {
-        maxConcurrency: process.env.CI ? 20 : 5,
-        pool: 'threads',
-        poolOptions: {
-          threads: {
-            maxThreads: process.env.CI ? 16 : 4
-          }
-        }
-      },
-    });
-    ```
-
-    Use more parallelism in CI where resources are abundant.
-  </Tab>
-</Tabs>
-
-## Best Practices
-
-<AccordionGroup>
-  <Accordion title="1. Choose Appropriate Concurrency">
-    ```javascript
-    // Development: Lower concurrency for easier debugging
-    maxConcurrency: 3
-
-    // CI: Higher concurrency for speed
-    maxConcurrency: 20
-    ```
-
-    Balance speed with resource usage. Too many concurrent tests can overwhelm your system or CI runner.
-
-    **Guidelines:**
-    - **Local development:** 3-5 concurrent tests
-    - **CI with 2 CPUs:** 5-10 concurrent tests
-    - **CI with 4+ CPUs:** 10-20 concurrent tests
-  </Accordion>
-
-  <Accordion title="2. Ensure Test Isolation">
-    ```javascript
-    // ✅ Good - each test is isolated
-    test('login test 1', async (context) => {
-      const { testdriver } = await chrome(context, {
-        url: 'https://example.com'
-      });
-      // Test runs in its own sandbox
-    });
-
-    test('login test 2', async (context) => {
-      const { testdriver } = await chrome(context, {
-        url: 'https://example.com'
-      });
-      // Different sandbox, no interference
-    });
-    ```
-
-    TestDriver automatically provisions isolated sandboxes for each test, preventing interference.
-  </Accordion>
-
-  <Accordion title="3. Monitor Resource Usage">
-    ```bash
-    # Watch CPU and memory during test runs
-    # macOS
-    top -l 1 | grep -E "(CPU|PhysMem)"
-
-    # Linux
-    top -bn1 | grep "Cpu(s)"
-
-    # Adjust maxConcurrency if system is overwhelmed
-    ```
-
-    Keep an eye on system resources to find the optimal concurrency level.
-  </Accordion>
-
-  <Accordion title="4. Use Sharding for Large Suites">
-    ```yaml .github/workflows/test.yml
-    strategy:
-      matrix:
-        shard: [1, 2, 3, 4]
-    steps:
-      - run: npx vitest run --shard=${{ matrix.shard }}/4
-    ```
-
-    Split tests across multiple CI jobs for massive test suites.
-  </Accordion>
-</AccordionGroup>
-
-## Combining with Caching
-
-Parallel execution + intelligent caching = maximum speed:
-
-```javascript
-// With both parallelization and caching enabled:
-✅ Cache-accelerated parallel execution:
-   Total: 15s (6x faster than sequential, no cache)
-```
-
-When you combine:
-- **Parallel execution:** Run multiple tests at once
-- **Intelligent caching:** Skip redundant AI analysis
-
-You get exponential performance improvements.
-
-[Learn about Intelligent Caching](/v7/features/fast)
-
-## Troubleshooting
-
-<AccordionGroup>
-  <Accordion title="Tests Failing in Parallel but Pass Sequentially">
-    **Cause:** Tests may have hidden dependencies or shared state.
-
-    **Solution:**
-    ```javascript
-    // Check for shared resources
-    test.sequential('sequential test group', () => {
-      test('test 1', async () => { /* ... */ });
-      test('test 2', async () => { /* ... */ });
-    });
-    ```
-
-    Or run with lower concurrency to identify the issue:
-    ```bash
-    npx vitest run --maxConcurrency=1
-    ```
-  </Accordion>
-
-  <Accordion title="CI Runner Running Out of Memory">
-    **Cause:** Too many concurrent tests for available resources.
-
-    **Solution:**
-    ```javascript vitest.config.mjs
-    export default defineConfig({
-      test: {
-        maxConcurrency: process.env.CI ? 10 : 5, // Reduce CI concurrency
-      },
-    });
-    ```
-  </Accordion>
-
-  <Accordion title="Slower Performance with Parallelism">
-    **Cause:** System overhead from too many workers.
-
-    **Solution:**
-    ```javascript
-    // Try different concurrency levels
-    maxConcurrency: 3  // Start low
-    maxConcurrency: 5
-    maxConcurrency: 10 // Increase until performance degrades
-    ```
-
-    Find the sweet spot for your system.
-  </Accordion>
-</AccordionGroup>
-
-## CI/CD Configuration
-
-<Tabs>
-  <Tab title="GitHub Actions">
-    ```yaml .github/workflows/test.yml
-    jobs:
-      test:
-        runs-on: ubuntu-latest
-        strategy:
-          matrix:
-            shard: [1, 2, 3, 4]
-        
-        steps:
-          - uses: actions/checkout@v3
-          
-          - name: Setup Node.js
-            uses: actions/setup-node@v3
-            with:
-              node-version: '20'
-          
-          - name: Install dependencies
-            run: npm install
-          
-          - name: Run tests (shard ${{ matrix.shard }}/4)
-            run: npx vitest run --shard=${{ matrix.shard }}/4
-            env:
-              TD_API_KEY: ${{ secrets.TD_API_KEY }}
-    ```
-  </Tab>
-
-  <Tab title="GitLab CI">
-    ```yaml .gitlab-ci.yml
-    test:
-      parallel: 4
-      script:
-        - npm install
-        - npx vitest run --shard=$CI_NODE_INDEX/$CI_NODE_TOTAL
-      variables:
-        TD_API_KEY: $TD_API_KEY
-    ```
-  </Tab>
-
-  <Tab title="CircleCI">
-    ```yaml .circleci/config.yml
-    jobs:
-      test:
-        parallelism: 4
-        steps:
-          - checkout
-          - run: npm install
-          - run: |
-              npx vitest run --shard=$CIRCLE_NODE_INDEX/$CIRCLE_NODE_TOTAL
-    ```
-  </Tab>
-</Tabs>
-
-## Next Steps
-
-<CardGroup cols={2}>
-  <Card
-    title="Intelligent Caching"
-    icon="bolt"
-    href="/v7/features/fast"
-  >
-    Speed up tests with smart caching
-  </Card>
-
-  <Card
-    title="Running Tests"
-    icon="play"
-    href="/v7/getting-started/running-tests"
-  >
-    Learn how to run your test suite
-  </Card>
-
-  <Card
-    title="Setting Up in CI"
-    icon="arrows-spin"
-    href="/v7/getting-started/setting-up-in-ci"
-  >
-    Configure CI/CD pipelines
-  </Card>
-
-  <Card
-    title="Performance Guide"
-    icon="gauge-high"
-    href="/v7/guides/performance"
-  >
-    Optimize test performance
-  </Card>
-</CardGroup>