Algolia

    GitHub Actions

    Acest ghid explică cum să integrați clientul API JMeter LoadFocus cu GitHub Actions pentru testare automată a performanței.

    Pași de configurare

    1. Stocarea credențialelor ca secrete GitHub

    Mai întâi, stocați credențialele API LoadFocus ca secrete ale repository-ului GitHub:

    1. Accesați repository-ul GitHub
    2. Navigați la Settings > Secrets and variables > Actions
    3. Adăugați următoarele secrete:
      • LOADFOCUS_API_KEY: Cheia API LoadFocus
      • LOADFOCUS_TEAM_ID: ID-ul echipei LoadFocus

    2. Crearea unui flux de lucru GitHub Actions

    Creați un fișier nou în repository la .github/workflows/performance-test.yml:

    name: Performance Tests
    

    on:
      push:
        branches: [ main, develop ]
      pull_request:
        branches: [ main ]
      # Optional: Run on a schedule
      schedule:
        - cron: '0 0 * * 1'  # Run at midnight every Monday
    

    jobs:
      performance-test:
        runs-on: ubuntu-latest
    

        steps:
        - uses: actions/checkout@v3
    

        - name: Setup Node.js
          uses: actions/setup-node@v3
          with:
            node-version: '16'
    

        - name: Install LoadFocus JMeter API Client
          run: npm install -g @loadfocus/loadfocus-api-client
    

        - name: Configure LoadFocus API Client
          run: |
            loadfocus-api config set apikey ${{ secrets.LOADFOCUS_API_KEY }}
            loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}
    

        - name: Run Performance Tests
          run: |
            loadfocus-api jmeter run-test \
              --name "GitHub_${{ github.repository_owner }}_${{ github.repository }}_${{ github.ref_name }}" \
              --thresholds "avgresponse<=200,errors==0,p95<=250" \
              --format json > performance_results.json
    

        - name: Upload Performance Test Results
          uses: actions/upload-artifact@v3
          with:
            name: performance-test-results
            path: performance_results.json

    3. Adăugarea testării performanței în fluxul de deployment

    Pentru ca deployment-ul să depindă de rezultatele testelor de performanță:

    name: Build, Test, and Deploy
    

    on:
      push:
        branches: [ main ]
    

    jobs:
      build:
        runs-on: ubuntu-latest
        steps:
          # Your build steps...
    

      performance-test:
        needs: build
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v3
    

          - name: Setup Node.js
            uses: actions/setup-node@v3
            with:
              node-version: '16'
    

          - name: Install LoadFocus JMeter API Client
            run: npm install -g @loadfocus/loadfocus-api-client
    

          - name: Configure LoadFocus API Client
            run: |
              loadfocus-api config set apikey ${{ secrets.LOADFOCUS_API_KEY }}
              loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}
    

          - name: Run Performance Tests
            run: |
              loadfocus-api jmeter run-test \
                --name "GitHub_${{ github.repository }}_${{ github.ref_name }}" \
                --thresholds "avgresponse<=200,errors==0,p95<=250" \
                --format json > performance_results.json
    

          - name: Upload Performance Test Results
            uses: actions/upload-artifact@v3
            with:
              name: performance-test-results
              path: performance_results.json
    

      deploy:
        needs: performance-test
        runs-on: ubuntu-latest
        steps:
          # Your deployment steps...

    Configurare avansată

    Testare matrice pentru medii multiple

    Rulați teste pe mai multe medii sau configurații:

    jobs:
      performance-test:
        runs-on: ubuntu-latest
        strategy:
          matrix:
            environment: [dev, staging, production]
            test-type: [api, frontend]
    

        steps:
          # Setup steps...
    

          - name: Run Performance Tests
            run: |
              TEST_NAME="${{ matrix.test-type }}_test_${{ matrix.environment }}"
    

              # Adjust thresholds based on environment
              if [ "${{ matrix.environment }}" == "production" ]; then
                THRESHOLDS="avgresponse<=150,errors==0,p95<=200"
              else
                THRESHOLDS="avgresponse<=300,errors==0,p95<=500"
              fi
    

              loadfocus-api jmeter run-test \
                --name "$TEST_NAME" \
                --thresholds "$THRESHOLDS" \
                --format json > "performance_results_${{ matrix.environment }}_${{ matrix.test-type }}.json"

    Crearea rapoartelor de test de performanță

    Generarea rapoartelor HTML din rezultatele JSON:

    - name: Generate HTML Report
      run: |
        # Install report generator
        npm install -g performance-report-generator
    

        # Generate HTML report
        performance-report-generator \
          --input performance_results.json \
          --output performance_report.html
    

    - name: Upload HTML Report
      uses: actions/upload-artifact@v3
      with:
        name: performance-test-report
        path: performance_report.html
    

    # Optional: Publish to GitHub Pages
    - name: Publish to GitHub Pages
      uses: peaceiris/actions-gh-pages@v3
      with:
        github_token: ${{ secrets.GITHUB_TOKEN }}
        publish_dir: ./reports
        destination_dir: performance-reports

    Comentarea rezultatelor testelor pe PR-uri

    Adăugarea rezultatelor testelor de performanță ca comentariu pe pull request-uri:

    - name: Comment PR
      uses: actions/github-script@v6
      if: github.event_name == 'pull_request'
      with:
        github-token: ${{ secrets.GITHUB_TOKEN }}
        script: |
          const fs = require('fs');
          const results = JSON.parse(fs.readFileSync('performance_results.json', 'utf8'));
    

          let comment = '## Performance Test Results\n\n';
          comment += `**Overall Result:** ${results.overallResult}\n\n`;
    

          comment += '### Results by Label\n\n';
          for (const label of results.labels) {
            comment += `#### ${label.label}\n`;
            comment += `- **Result:** ${label.result}\n`;
            comment += `- **Samples:** ${label.metrics.samples}\n`;
            comment += `- **Avg Response:** ${label.metrics.avgresponse}ms\n`;
            comment += `- **Error Rate:** ${label.metrics.errors}\n\n`;
          }
    

          github.rest.issues.createComment({
            issue_number: context.issue.number,
            owner: context.repo.owner,
            repo: context.repo.repo,
            body: comment
          });

    Flux de lucru reutilizabil

    Creați un flux de lucru reutilizabil pentru testarea performanței:

    # .github/workflows/reusable-performance-test.yml
    name: Reusable Performance Test
    

    on:
      workflow_call:
        inputs:
          test-name:
            required: true
            type: string
          thresholds:
            required: false
            type: string
            default: "avgresponse<=200,errors==0,p95<=250"
          wait-timeout:
            required: false
            type: number
            default: 1800
        secrets:
          LOADFOCUS_API_KEY:
            required: true
          LOADFOCUS_TEAM_ID:
            required: true
    

    jobs:
      performance-test:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v3
    

          - name: Setup Node.js
            uses: actions/setup-node@v3
            with:
              node-version: '16'
    

          - name: Install LoadFocus JMeter API Client
            run: npm install -g @loadfocus/loadfocus-api-client
    

          - name: Configure LoadFocus API Client
            run: |
              loadfocus-api config set apikey ${{ secrets.LOADFOCUS_API_KEY }}
              loadfocus-api config set teamid ${{ secrets.LOADFOCUS_TEAM_ID }}
    

          - name: Run Performance Tests
            run: |
              loadfocus-api jmeter run-test \
                --name "${{ inputs.test-name }}" \
                --thresholds "${{ inputs.thresholds }}" \
                --waitTimeout ${{ inputs.wait-timeout }} \
                --format json > performance_results.json
    

          - name: Upload Performance Test Results
            uses: actions/upload-artifact@v3
            with:
              name: performance-test-results
              path: performance_results.json

    Apoi apelați-l dintr-un alt flux de lucru:

    # .github/workflows/main.yml
    jobs:
      call-performance-test:
        uses: ./.github/workflows/reusable-performance-test.yml
        with:
          test-name: "API_Performance_Test"
          thresholds: "avgresponse<=150,errors==0"
        secrets:
          LOADFOCUS_API_KEY: ${{ secrets.LOADFOCUS_API_KEY }}
          LOADFOCUS_TEAM_ID: ${{ secrets.LOADFOCUS_TEAM_ID }}

    Sfaturi pentru integrarea GitHub Actions

    1. Cache: Memorarea în cache a dependențelor npm pentru a accelera rulările:

      - name: Cache Node modules
        uses: actions/cache@v3
        with:
          path: ~/.npm
          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-node-

    2. Control concurență: Limitarea testelor de performanță concurente:

      concurrency:
        group: performance-test-${{ github.ref }}
        cancel-in-progress: false

    3. Teste specifice mediului: Utilizarea mediilor GitHub pentru diferite configurații de test:

      jobs:
        performance-test:
          runs-on: ubuntu-latest
          environment: staging
          # Environment-specific variables are available here

    4. Testare condiționată: Rularea testelor de performanță doar când se modifică fișiere specifice:

      jobs:
        performance-test:
          if: |
            contains(github.event.pull_request.labels.*.name, 'performance-test') ||
            github.event_name == 'schedule' ||
            contains(github.event.head_commit.message, '[perf-test]')

    Pentru mai multe informații, consultați documentația GitHub Actions și documentația clientului API LoadFocus.

    Anterior
    CircleCI
    Următor
    GitLab CI/CD