CI/CD Pipeline для тестировщиков: Полное руководство по интеграции

pipeline {
    agent any

    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', url: 'https://github.com/company/project.git'
            }
        }

        stage('Install Dependencies') {
            steps {
                sh 'npm install'
            }
        }

        stage('Unit Tests') {
            steps {
                sh 'npm run test:unit'
            }
            post {
                always {
                    junit 'reports/junit/*.xml'
                }
            }
        }

        stage('Integration Tests') {
            steps {
                sh 'npm run test:integration'
            }
            post {
                always {
                    publishHTML([
                        reportDir: 'reports/html',
                        reportFiles: 'index.html',
                        reportName: 'Integration Test Report'
                    ])
                }
            }
        }

        stage('E2E Tests') {
            parallel {
                stage('Chrome') {
                    steps {
                        sh 'npm run test:e2e -- --browser=chrome'
                    }
                }
                stage('Firefox') {
                    steps {
                        sh 'npm run test:e2e -- --browser=firefox'
                    }
                }
                stage('Safari') {
                    steps {
                        sh 'npm run test:e2e -- --browser=safari'
                    }
                }
            }
            post {
                always {
                    archiveArtifacts artifacts: 'screenshots/**/*.png', allowEmptyArchive: true
                }
            }
        }
    }

    post {
        always {
            cleanWs()
        }
        failure {
            emailext (
                subject: "Test Failure: ${env.JOB_NAME} - Build ${env.BUILD_NUMBER}",
                body: "Check console output at ${env.BUILD_URL}",
                to: 'qa-team@company.com'
            )
        }
    }
}

stages:
  - test
  - integration
  - e2e
  - report

variables:
  DOCKER_DRIVER: overlay2
  TEST_DB_URL: "postgres://test:test@postgres:5432/testdb"

.test_template: &test_template
  image: node:18
  before_script:
    - npm ci
  cache:
    key: ${CI_COMMIT_REF_SLUG}
    paths:
      - node_modules/

unit_tests:
  <<: *test_template
  stage: test
  script:
    - npm run test:unit -- --coverage
  coverage: '/All files[^|]*\|[^|]*\s+([\d\.]+)/'
  artifacts:
    reports:
      junit: reports/junit.xml
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura-coverage.xml
    paths:
      - coverage/

integration_tests:
  <<: *test_template
  stage: integration
  services:
    - postgres:14
  variables:
    POSTGRES_DB: testdb
    POSTGRES_USER: test
    POSTGRES_PASSWORD: test
  script:
    - npm run test:integration
  artifacts:
    reports:
      junit: reports/integration-junit.xml

e2e_tests:
  stage: e2e
  image: cypress/browsers:node18.12.0-chrome106-ff106
  parallel:
    matrix:
      - BROWSER: [chrome, firefox, edge]
  script:
    - npm ci
    - npm run start:test &
    - npx wait-on http://localhost:3000
    - npm run test:e2e -- --browser=${BROWSER}
  artifacts:
    when: always
    paths:
      - cypress/videos/**/*.mp4
      - cypress/screenshots/**/*.png
    expire_in: 1 week
    reports:
      junit: cypress/results/junit-*.xml

test_summary:
  stage: report
  image: python:3.10
  when: always
  script:
    - pip install junit2html
    - junit2html reports/*.xml reports/summary.html
  artifacts:
    paths:
      - reports/summary.html
    expire_in: 30 days

name: Test Suite

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]
  schedule:
    - cron: '0 2 * * *'

jobs:
  unit-tests:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [16.x, 18.x, 20.x]

    steps:
      - uses: actions/checkout@v3

      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run unit tests
        run: npm run test:unit

      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/lcov.info
          flags: unittests
          name: codecov-${{ matrix.node-version }}

  api-tests:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:14
        env:
          POSTGRES_PASSWORD: postgres
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-node@v3
        with:
          node-version: '18.x'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run API tests
        run: npm run test:api
        env:
          DATABASE_URL: postgresql://postgres:postgres@localhost:5432/testdb

      - name: Publish test results
        uses: EnricoMi/publish-unit-test-result-action@v2
        if: always()
        with:
          files: reports/junit/*.xml

  e2e-tests:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        browser: [chromium, firefox, webkit]
        shard: [1, 2, 3, 4]

    steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-node@v3
        with:
          node-version: '18.x'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Install Playwright Browsers
        run: npx playwright install --with-deps ${{ matrix.browser }}

      - name: Run E2E tests
        run: npx playwright test --project=${{ matrix.browser }} --shard=${{ matrix.shard }}/4
        env:
          CI: true

      - name: Upload test results
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: playwright-report-${{ matrix.browser }}-${{ matrix.shard }}
          path: playwright-report/
          retention-days: 7

// vars/testPipeline.groovy
def call(Map config) {
    pipeline {
        agent any

        stages {
            stage('Setup') {
                steps {
                    script {
                        sh config.setupCommand ?: 'npm ci'
                    }
                }
            }

            stage('Test') {
                parallel {
                    stage('Unit') {
                        when {
                            expression { config.runUnitTests != false }
                        }
                        steps {
                            sh config.unitTestCommand ?: 'npm run test:unit'
                        }
                    }

                    stage('Integration') {
                        when {
                            expression { config.runIntegrationTests == true }
                        }
                        steps {
                            sh config.integrationTestCommand
                        }
                    }
                }
            }
        }
    }
}

// Использование в Jenkinsfile
@Library('shared-pipeline-library') _

testPipeline(
    runUnitTests: true,
    runIntegrationTests: true,
    integrationTestCommand: 'npm run test:integration'
)

// playwright.config.js
module.exports = {
  testDir: './tests',
  fullyParallel: true,
  workers: process.env.CI ? 4 : 2,

  projects: [
    {
      name: 'chromium',
      use: {
        ...devices['Desktop Chrome'],
        shard: process.env.SHARD ? {
          current: parseInt(process.env.SHARD_CURRENT),
          total: parseInt(process.env.SHARD_TOTAL)
        } : null
      },
    },
  ],
};

// jest.config.js
module.exports = {
  reporters: [
    'default',
    [
      'jest-junit',
      {
        outputDirectory: './reports/junit',
        outputName: 'junit.xml',
        classNameTemplate: '{classname}',
        titleTemplate: '{title}',
        ancestorSeparator: ' › ',
        usePathForSuiteName: true,
      },
    ],
    [
      'jest-html-reporter',
      {
        pageTitle: 'Test Report',
        outputPath: './reports/html/index.html',
        includeFailureMsg: true,
        includeConsoleLog: true,
        theme: 'darkTheme',
      },
    ],
  ],
  collectCoverage: true,
  coverageReporters: ['text', 'lcov', 'html', 'cobertura'],
  coverageDirectory: './coverage',
};

# .gitlab-ci.yml
e2e_tests:
  stage: test
  script:
    - npm run test:e2e -- --reporter=allure
  after_script:
    - allure generate allure-results --clean -o allure-report
  artifacts:
    paths:
      - allure-report/
    reports:
      junit: allure-results/*.xml

pages:
  stage: deploy
  dependencies:
    - e2e_tests
  script:
    - mkdir -p public
    - cp -r allure-report/* public/
  artifacts:
    paths:
      - public
  only:
    - main

# GitHub Actions условные тесты
name: Smart Test Execution

on: [push, pull_request]

jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      backend: ${{ steps.filter.outputs.backend }}
      frontend: ${{ steps.filter.outputs.frontend }}
      database: ${{ steps.filter.outputs.database }}
    steps:
      - uses: actions/checkout@v3
      - uses: dorny/paths-filter@v2
        id: filter
        with:
          filters: |
            backend:
              - 'src/backend/**'
              - 'package.json'
            frontend:
              - 'src/frontend/**'
              - 'public/**'
            database:
              - 'migrations/**'
              - 'schema.sql'

  backend-tests:
    needs: detect-changes
    if: needs.detect-changes.outputs.backend == 'true'
    runs-on: ubuntu-latest
    steps:
      - run: npm run test:backend

// Jenkinsfile с этапами окружений
pipeline {
    agent any

    stages {
        stage('Test in Dev') {
            environment {
                API_URL = 'https://dev-api.company.com'
                DB_CONN = credentials('dev-db-connection')
            }
            steps {
                sh 'npm run test:integration'
            }
        }

        stage('Test in Staging') {
            when {
                branch 'main'
            }
            environment {
                API_URL = 'https://staging-api.company.com'
                DB_CONN = credentials('staging-db-connection')
            }
            steps {
                sh 'npm run test:smoke'
            }
        }

        stage('Deploy to Production') {
            when {
                branch 'main'
                allOf {
                    environment name: 'DEPLOY_TO_PROD', value: 'true'
                }
            }
            input {
                message "Deploy to production?"
                ok "Deploy"
            }
            steps {
                sh 'npm run deploy:prod'
            }
        }
    }
}