Integration Testing

Integration Testing

Overview

Designs comprehensive integration testing strategies including API testing, database testing, microservices testing, end-to-end testing, and test automation frameworks

Core Capabilities

1. Core Capability 1 - Description 2. Core Capability 2 - Description 3. Core Capability 3 - Description

Quick Start

Basic Workflow:

1. Analyze requirements and context 2. Apply appropriate patterns 3. Validate and test results 4. Document findings and recommendations

Detailed Topics

Load reference files based on specific needs:

• Activation Guidelines: See activation-guidelines.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Cicd Integration: See cicd-integration.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Core Capabilities: See core-capabilities.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Integration Testing Process: See integration-testing-process.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Test Coverage And Reporting: See test-coverage-and-reporting.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Test Patterns: See test-patterns.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Testing Best Practices: See testing-best-practices.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Testing Frameworks: See testing-frameworks.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

• Testing Frameworks And Tools: See testing-frameworks-and-tools.md when:
• Working with related functionality
• Need specific patterns or examples
• Require detailed guidance

Activation Guidelines

This skill should be activated when:

• Designing integration test strategies
• Writing API integration tests
• Testing database interactions
• Testing microservices communication
• Implementing E2E tests
• Setting up test automation
• Configuring CI/CD test pipelines
• Creating test data strategies
• Implementing contract testing
• Testing distributed systems
• Debugging integration issues
• Improving test coverage

The skill provides the most value when given system Mermaid architecture diagrams, API specifications, and clear testing objectives.

CI/CD Integration for Automated Testing

This guide covers integrating integration tests into CI/CD pipelines across different platforms.

GitHub Actions

Complete Integration Test Workflow

# .github/workflows/integration-tests.yml
name: Integration Tests

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

env:
  NODE_VERSION: '18'
  DATABASE_NAME: test_db

jobs:
  integration-tests:
    runs-on: ubuntu-latest
    timeout-minutes: 30

    strategy:
      matrix:
        node-version: [16, 18, 20]
      fail-fast: false # Continue other jobs if one fails

    services:
      postgres:
        image: postgres:15-alpine
        env:
          POSTGRES_DB: ${{ env.DATABASE_NAME }}
          POSTGRES_USER: test_user
          POSTGRES_PASSWORD: test_password
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

      redis:
        image: redis:7-alpine
        ports:
          - 6379:6379
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

      rabbitmq:
        image: rabbitmq:3-management-alpine
        env:
          RABBITMQ_DEFAULT_USER: test
          RABBITMQ_DEFAULT_PASS: test
        ports:
          - 5672:5672
          - 15672:15672
        options: >-
          --health-cmd "rabbitmq-diagnostics -q ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Full history for better coverage reports

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

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

      - name: Install dependencies
        run: npm ci

      - name: Wait for services
        run: |
          echo "Waiting for PostgreSQL..."
          timeout 30 bash -c 'until pg_isready -h localhost -p 5432; do sleep 1; done'
          echo "Waiting for Redis..."
          timeout 30 bash -c 'until redis-cli -h localhost ping; do sleep 1; done'
          echo "Waiting for RabbitMQ..."
          timeout 30 bash -c 'until curl -s -f http://localhost:15672/api/healthchecks/node >/dev/null; do sleep 1; done'

      - name: Setup test database
        env:
          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/${{ env.DATABASE_NAME }}
        run: |
          npm run db:migrate
          npm run db:seed:test

      - name: Run linting
        run: npm run lint

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

      - name: Run integration tests
        env:
          NODE_ENV: test
          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/${{ env.DATABASE_NAME }}
          REDIS_URL: redis://localhost:6379
          RABBITMQ_URL: amqp://test:test@localhost:5672
          JWT_SECRET: test-secret-key
          API_BASE_URL: http://localhost:3000
        run: npm run test:integration -- --coverage

      - name: Run E2E tests
        env:
          NODE_ENV: test
          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/${{ env.DATABASE_NAME }}
        run: |
          npm run start:test &
          npx wait-on http://localhost:3000/health --timeout 60000
          npm run test:e2e

      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/coverage-final.json
          flags: integration-tests
          name: integration-coverage-${{ matrix.node-version }}
          fail_ci_if_error: false

      - name: Generate test report
        if: always()
        uses: dorny/test-reporter@v1
        with:
          name: Integration Test Results (Node ${{ matrix.node-version }})
          path: test-results.json
          reporter: jest-junit
          fail-on-error: true

      - name: Upload test artifacts
        if: failure()
        uses: actions/upload-artifact@v3
        with:
          name: test-artifacts-${{ matrix.node-version }}
          path: |
            screenshots/
            test-results/
            logs/
          retention-days: 7

      - name: Comment PR with test results
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const results = JSON.parse(fs.readFileSync('test-results.json'));
            const body = `## Test Results (Node ${{ matrix.node-version }})
            
            - ✅ Tests Passed: ${results.numPassedTests}
            - ❌ Tests Failed: ${results.numFailedTests}
            - ⏭️  Tests Skipped: ${results.numPendingTests}
            - ⏱️  Duration: ${results.testResults[0].endTime - results.testResults[0].startTime}ms
            
            [View Full Report](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})`;
            
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: body
            });

  contract-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 18

      - name: Run consumer contract tests
        run: |
          npm ci
          npm run test:contract:consumer

      - name: Publish contracts
        if: github.ref == 'refs/heads/main'
        env:
          PACT_BROKER_BASE_URL: ${{ secrets.PACT_BROKER_URL }}
          PACT_BROKER_TOKEN: ${{ secrets.PACT_BROKER_TOKEN }}
        run: npm run pact:publish

      - name: Verify provider contracts
        env:
          PACT_BROKER_BASE_URL: ${{ secrets.PACT_BROKER_URL }}
          PACT_BROKER_TOKEN: ${{ secrets.PACT_BROKER_TOKEN }}
        run: npm run test:contract:provider

  performance-tests:
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4

      - name: Run performance tests
        run: |
          npm ci
          npm run test:performance

      - name: Compare with baseline
        run: |
          node scripts/compare-performance.js

      - name: Upload performance results
        uses: actions/upload-artifact@v3
        with:
          name: performance-results
          path: performance-results.json

  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Run npm audit
        run: npm audit --audit-level=moderate

      - name: Run Snyk security scan
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

Parallel Test Execution

# .github/workflows/parallel-tests.yml
name: Parallel Integration Tests

on: [push, pull_request]

jobs:
  test-matrix:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        test-group: [api, database, services, auth, integration]
        
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      
      - name: Run ${{ matrix.test-group }} tests
        run: npm run test:${{ matrix.test-group }}

GitLab CI/CD

Complete Pipeline Configuration

# .gitlab-ci.yml
variables:
  POSTGRES_DB: test_db
  POSTGRES_USER: test_user
  POSTGRES_PASSWORD: test_password
  NODE_ENV: test

stages:
  - build
  - test
  - contract-test
  - deploy

cache:
  key: ${CI_COMMIT_REF_SLUG}
  paths:
    - node_modules/
    - .npm/

before_script:
  - npm ci --cache .npm --prefer-offline

build:
  stage: build
  image: node:18-alpine
  script:
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 hour

unit-tests:
  stage: test
  image: node:18-alpine
  script:
    - npm run test:unit -- --coverage
  coverage: '/All files[^|]*\|[^|]*\s+([\d\.]+)/'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura-coverage.xml
      junit: junit.xml

integration-tests:
  stage: test
  image: node:18-alpine
  services:
    - name: postgres:15-alpine
      alias: postgres
    - name: redis:7-alpine
      alias: redis
    - name: rabbitmq:3-management-alpine
      alias: rabbitmq

  variables:
    DATABASE_URL: postgresql://test_user:test_password@postgres:5432/test_db
    REDIS_URL: redis://redis:6379
    RABBITMQ_URL: amqp://test:test@rabbitmq:5672

  script:
    - echo "Waiting for services..."
    - apk add --no-cache postgresql-client
    - until pg_isready -h postgres -p 5432; do sleep 1; done
    - echo "Running migrations..."
    - npm run db:migrate
    - npm run db:seed:test
    - echo "Running integration tests..."
    - npm run test:integration -- --coverage --ci
  
  artifacts:
    when: always
    reports:
      junit: test-results.xml
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura-coverage.xml
    paths:
      - coverage/
      - test-results/
    expire_in: 7 days

  retry:
    max: 2
    when:
      - runner_system_failure
      - stuck_or_timeout_failure

e2e-tests:
  stage: test
  image: mcr.microsoft.com/playwright:v1.40.0-focal
  services:
    - name: postgres:15-alpine
      alias: postgres

  variables:
    DATABASE_URL: postgresql://test_user:test_password@postgres:5432/test_db

  script:
    - npm ci
    - npm run db:migrate
    - npm run start:test &
    - npx wait-on http://localhost:3000/health --timeout 60000
    - npm run test:e2e

  artifacts:
    when: on_failure
    paths:
      - playwright-report/
      - test-results/
    expire_in: 7 days

contract-tests:
  stage: contract-test
  image: node:18-alpine
  script:
    - npm run test:contract
  only:
    - main
    - develop

.test-template: &test-template
  stage: test
  image: node:18-alpine
  services:
    - postgres:15-alpine
    - redis:7-alpine

api-tests:
  <<: *test-template
  script:
    - npm run test:api

database-tests:
  <<: *test-template
  script:
    - npm run test:database

services-tests:
  <<: *test-template
  script:
    - npm run test:services

# Parallel execution
.parallel-tests:
  parallel: 4
  script:
    - npm run test:integration -- --shard=${CI_NODE_INDEX}/${CI_NODE_TOTAL}

Jenkins Pipeline

Declarative Pipeline

// Jenkinsfile
pipeline {
    agent any
    
    options {
        timeout(time: 30, unit: 'MINUTES')
        timestamps()
        buildDiscarder(logRotator(numToKeepStr: '10'))
    }
    
    environment {
        NODE_ENV = 'test'
        DATABASE_URL = credentials('test-database-url')
        REDIS_URL = 'redis://localhost:6379'
        NPM_CONFIG_CACHE = "${WORKSPACE}/.npm"
    }
    
    stages {
        stage('Setup') {
            steps {
                script {
                    sh 'node --version'
                    sh 'npm --version'
                }
            }
        }
        
        stage('Install Dependencies') {
            steps {
                sh 'npm ci'
            }
        }
        
        stage('Start Services') {
            steps {
                script {
                    sh '''
                        docker-compose -f docker-compose.test.yml up -d
                        sleep 10
                        docker-compose -f docker-compose.test.yml ps
                    '''
                }
            }
        }
        
        stage('Database Setup') {
            steps {
                sh 'npm run db:migrate'
                sh 'npm run db:seed:test'
            }
        }
        
        stage('Lint') {
            steps {
                sh 'npm run lint'
            }
        }
        
        stage('Unit Tests') {
            steps {
                sh 'npm run test:unit -- --coverage'
            }
        }
        
        stage('Integration Tests') {
            parallel {
                stage('API Tests') {
                    steps {
                        sh 'npm run test:api'
                    }
                }
                stage('Database Tests') {
                    steps {
                        sh 'npm run test:database'
                    }
                }
                stage('Service Tests') {
                    steps {
                        sh 'npm run test:services'
                    }
                }
            }
        }
        
        stage('E2E Tests') {
            steps {
                sh '''
                    npm run start:test &
                    npx wait-on http://localhost:3000/health
                    npm run test:e2e
                '''
            }
        }
        
        stage('Contract Tests') {
            when {
                branch 'main'
            }
            steps {
                sh 'npm run test:contract'
            }
        }
    }
    
    post {
        always {
            // Publish test results
            junit testResults: 'test-results/**/*.xml', allowEmptyResults: true
            
            // Publish coverage
            publishHTML([
                reportDir: 'coverage/lcov-report',
                reportFiles: 'index.html',
                reportName: 'Coverage Report'
            ])
            
            // Archive artifacts
            archiveArtifacts artifacts: 'test-results/**/*', allowEmptyArchive: true
            
            // Cleanup
            sh 'docker-compose -f docker-compose.test.yml down -v'
        }
        
        success {
            echo 'All tests passed!'
        }
        
        failure {
            echo 'Tests failed!'
            // Send notification
            emailext(
                subject: "Build Failed: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
                body: "Check console output at ${env.BUILD_URL}",
                to: "${env.CHANGE_AUTHOR_EMAIL}"
            )
        }
    }
}

CircleCI

Configuration

# .circleci/config.yml
version: 2.1

orbs:
  node: circleci/node@5.1
  codecov: codecov/codecov@3.2

executors:
  node-postgres:
    docker:
      - image: cimg/node:18.19
      - image: cimg/postgres:15.4
        environment:
          POSTGRES_DB: test_db
          POSTGRES_USER: test_user
          POSTGRES_PASSWORD: test_password
      - image: cimg/redis:7.2

commands:
  install-dependencies:
    steps:
      - restore_cache:
          keys:
            - v1-deps-{{ checksum "package-lock.json" }}
            - v1-deps-
      - run:
          name: Install dependencies
          command: npm ci
      - save_cache:
          key: v1-deps-{{ checksum "package-lock.json" }}
          paths:
            - node_modules

  wait-for-services:
    steps:
      - run:
          name: Wait for PostgreSQL
          command: |
            dockerize -wait tcp://localhost:5432 -timeout 1m
      - run:
          name: Wait for Redis
          command: |
            dockerize -wait tcp://localhost:6379 -timeout 1m

jobs:
  unit-tests:
    executor: node-postgres
    steps:
      - checkout
      - install-dependencies
      - run:
          name: Run unit tests
          command: npm run test:unit -- --coverage
      - store_test_results:
          path: test-results
      - store_artifacts:
          path: coverage

  integration-tests:
    executor: node-postgres
    parallelism: 4
    steps:
      - checkout
      - install-dependencies
      - wait-for-services
      - run:
          name: Run migrations
          command: npm run db:migrate
          environment:
            DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
      - run:
          name: Seed test data
          command: npm run db:seed:test
      - run:
          name: Run integration tests
          command: |
            TESTFILES=$(circleci tests glob "tests/integration/**/*.test.js" | circleci tests split --split-by=timings)
            npm run test:integration -- $TESTFILES --coverage
          environment:
            DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
            REDIS_URL: redis://localhost:6379
      - store_test_results:
          path: test-results
      - store_artifacts:
          path: coverage
      - codecov/upload:
          flags: integration

  e2e-tests:
    docker:
      - image: mcr.microsoft.com/playwright:v1.40.0-focal
    steps:
      - checkout
      - install-dependencies
      - run:
          name: Start application
          command: npm run start:test
          background: true
      - run:
          name: Wait for application
          command: npx wait-on http://localhost:3000/health --timeout 60000
      - run:
          name: Run E2E tests
          command: npm run test:e2e
      - store_test_results:
          path: test-results
      - store_artifacts:
          path: playwright-report
          when: on_fail

workflows:
  test-and-deploy:
    jobs:
      - unit-tests
      - integration-tests:
          requires:
            - unit-tests
      - e2e-tests:
          requires:
            - integration-tests
      - deploy:
          requires:
            - e2e-tests
          filters:
            branches:
              only: main

Docker Compose for Testing

# docker-compose.test.yml
version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: test_db
      POSTGRES_USER: test_user
      POSTGRES_PASSWORD: test_password
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U test_user"]
      interval: 5s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

  rabbitmq:
    image: rabbitmq:3-management-alpine
    environment:
      RABBITMQ_DEFAULT_USER: test
      RABBITMQ_DEFAULT_PASS: test
    ports:
      - "5672:5672"
      - "15672:15672"
    healthcheck:
      test: rabbitmq-diagnostics -q ping
      interval: 10s
      timeout: 5s
      retries: 5

  mongodb:
    image: mongo:7
    environment:
      MONGO_INITDB_ROOT_USERNAME: test
      MONGO_INITDB_ROOT_PASSWORD: test
    ports:
      - "27017:27017"
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/test --quiet
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  postgres_data:

Package.json Scripts

{
  "scripts": {
    "test": "npm run test:unit && npm run test:integration",
    "test:unit": "jest --testPathPattern=tests/unit --coverage",
    "test:integration": "jest --testPathPattern=tests/integration --runInBand",
    "test:api": "jest --testPathPattern=tests/integration/api",
    "test:database": "jest --testPathPattern=tests/integration/database",
    "test:services": "jest --testPathPattern=tests/integration/services",
    "test:e2e": "playwright test",
    "test:contract": "npm run test:contract:consumer && npm run test:contract:provider",
    "test:contract:consumer": "jest --testPathPattern=tests/contract/consumer",
    "test:contract:provider": "jest --testPathPattern=tests/contract/provider",
    "test:performance": "k6 run tests/performance/load-test.js",
    "test:watch": "jest --watch",
    "test:ci": "npm run test -- --ci --coverage --maxWorkers=2",
    "db:migrate": "knex migrate:latest",
    "db:seed:test": "knex seed:run --env=test",
    "start:test": "NODE_ENV=test node server.js",
    "docker:test:up": "docker-compose -f docker-compose.test.yml up -d",
    "docker:test:down": "docker-compose -f docker-compose.test.yml down -v",
    "pact:publish": "pact-broker publish ./pacts --consumer-app-version=$CI_COMMIT_SHA --broker-base-url=$PACT_BROKER_URL --broker-token=$PACT_BROKER_TOKEN"
  }
}

Test Reporting

Jest JUnit Reporter

// jest.config.js
module.exports = {
  reporters: [
    'default',
    [
      'jest-junit',
      {
        outputDirectory: './test-results',
        outputName: 'junit.xml',
        classNameTemplate: '{classname}',
        titleTemplate: '{title}',
        ancestorSeparator: ' › ',
        usePathForSuiteName: true
      }
    ],
    [
      'jest-html-reporters',
      {
        publicPath: './test-results/html-report',
        filename: 'report.html',
        expand: true
      }
    ]
  ]
};

Custom Test Report Script

// scripts/generate-test-report.js
const fs = require('fs');
const path = require('path');

function generateReport(resultsFile) {
  const results = JSON.parse(fs.readFileSync(resultsFile, 'utf8'));
  
  const report = {
    summary: {
      total: results.numTotalTests,
      passed: results.numPassedTests,
      failed: results.numFailedTests,
      skipped: results.numPendingTests,
      duration: results.testResults.reduce((sum, r) => 
        sum + (r.endTime - r.startTime), 0
      )
    },
    suites: results.testResults.map(suite => ({
      file: suite.name,
      tests: suite.numPassingTests,
      failures: suite.numFailingTests,
      duration: suite.endTime - suite.startTime,
      failedTests: suite.testResults
        .filter(t => t.status === 'failed')
        .map(t => ({
          name: t.fullName,
          error: t.failureMessages.join('\n')
        }))
    }))
  };
  
  fs.writeFileSync(
    'test-report.json',
    JSON.stringify(report, null, 2)
  );
  
  console.log('Test Report Generated:');
  console.log(`✅ Passed: ${report.summary.passed}`);
  console.log(`❌ Failed: ${report.summary.failed}`);
  console.log(`⏭️  Skipped: ${report.summary.skipped}`);
  console.log(`⏱️  Duration: ${report.summary.duration}ms`);
}

generateReport(process.argv[2] || 'test-results.json');

Best Practices

1. Fast Feedback

• Run unit tests before integration tests
• Use parallel execution
• Cache dependencies
• Use service health checks

2. Reliable Tests

• Retry flaky tests (max 2-3 times)
• Use proper timeouts
• Wait for services to be ready
• Clean up test data

3. Clear Reporting

• Generate JUnit XML for CI systems
• Create HTML reports for humans
• Include coverage reports
• Log failures with context

4. Resource Management

• Use Docker services for dependencies
• Clean up containers after tests
• Use test databases (not production)
• Manage secrets properly

5. Performance

• Run tests in parallel
• Use test sharding for large suites
• Cache node_modules
• Optimize database seeds

6. Security

• Never commit credentials
• Use CI secrets management
• Run security scans
• Audit dependencies

7. Maintainability

• Keep pipeline configuration DRY
• Use templates/orbs when available
• Document custom scripts
• Version control pipeline config

Core Capabilities

When activated, this skill enables you to:

1. Test Strategy & Planning

• Define integration testing scope and objectives
• Identify integration points and dependencies
• Create test plans and test cases
• Design test data management strategies
• Plan test environments and infrastructure

2. API Testing

• Test RESTful API endpoints
• Test GraphQL queries and mutations
• Validate request/response schemas
• Test authentication and authorization
• Implement contract testing

3. Database Integration Testing

• Test database queries and transactions
• Validate data integrity and constraints
• Test migrations and schema changes
• Implement test data fixtures
• Test database performance

4. Microservices Testing

• Test inter-service communication
• Implement service contract testing
• Test message queues and event streaming
• Validate distributed transactions
• Test service discovery and load balancing

5. End-to-End Testing

• Design user journey tests
• Test complete business workflows
• Implement UI-driven integration tests
• Test cross-platform functionality
• Validate system integration

6. Test Automation

• Select appropriate testing frameworks
• Implement test automation pipelines
• Integrate with CI/CD systems
• Generate test reports and coverage
• Implement parallel test execution

Integration Testing Process

Follow this systematic approach when designing integration tests:

Phase 1: Test Strategy & Planning

1. Define Testing Scope

Integration Levels

• Component Integration: Individual modules/classes working together
• Service Integration: APIs and services interacting
• System Integration: Multiple services/systems integrated
• End-to-End: Complete user workflows across entire stack

Test Objectives

• Verify interface contracts between components
• Validate data flow across system boundaries
• Ensure proper error handling in integrations
• Test transaction integrity across services
• Validate performance under realistic load

1. Identify Integration Points

System Architecture:
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Frontend  │────▶│   API GW    │────▶│   Auth Svc  │
└─────────────┘     └─────────────┘     └─────────────┘
                           │
                    ┌──────┴──────┐
                    ▼              ▼
            ┌─────────────┐  ┌─────────────┐
            │  User Svc   │  │ Product Svc │
            └─────────────┘  └─────────────┘
                    │              │
                    ▼              ▼
            ┌─────────────┐  ┌─────────────┐
            │  Database   │  │  Database   │
            └─────────────┘  └─────────────┘
                    │
                    ▼
            ┌─────────────┐
            │ Message Queue│
            └─────────────┘

Integration Points to Test:
1. Frontend ↔ API Gateway
2. API Gateway ↔ Auth Service
3. API Gateway ↔ User Service
4. API Gateway ↔ Product Service
5. Services ↔ Databases
6. Services ↔ Message Queue
7. Cross-service workflows

1. Test Environment Planning

Environment Types

• Development: Local testing, mocked external dependencies
• Integration: Shared environment with real dependencies
• Staging: Production-like environment for final validation
• Production: Post-deployment smoke tests

Infrastructure Requirements

• Test databases (separate from production)
• Message queues and caches
• External service mocks/stubs
• Test data management tools
• CI/CD runners

Phase 2: API Integration Testing

1. RESTful API Testing

Test Framework Setup (Jest + Supertest)

// api.test.js
const request = require('supertest');
const app = require('../app');
const db = require('../database');

describe('User API Integration Tests', () => {
  beforeAll(async () => {
    await db.connect();
    await db.migrate();
  });

  afterAll(async () => {
    await db.close();
  });

  beforeEach(async () => {
    await db.seed(); // Load test data
  });

  afterEach(async () => {
    await db.truncate(); // Clean up
  });

  describe('POST /api/v1/users', () => {
    it('should create a new user with valid data', async () => {
      const userData = {
        email: 'test@example.com',
        name: 'Test User',
        password: 'Password123!'
      };

      const response = await request(app)
        .post('/api/v1/users')
        .send(userData)
        .expect(201)
        .expect('Content-Type', /json/);

      expect(response.body).toMatchObject({
        email: userData.email,
        name: userData.name
      });
      expect(response.body).toHaveProperty('id');
      expect(response.body).not.toHaveProperty('password');

      // Verify database
      const user = await db.users.findByEmail(userData.email);
      expect(user).toBeDefined();
      expect(user.name).toBe(userData.name);
    });

    it('should return 422 for invalid email', async () => {
      const response = await request(app)
        .post('/api/v1/users')
        .send({
          email: 'invalid-email',
          name: 'Test User',
          password: 'Password123!'
        })
        .expect(422);

      expect(response.body.error.code).toBe('VALIDATION_ERROR');
      expect(response.body.error.details).toContainEqual(
        expect.objectContaining({
          field: 'email',
          message: expect.stringContaining('email')
        })
      );
    });

    it('should return 409 for duplicate email', async () => {
      const userData = {
        email: 'existing@example.com',
        name: 'Test User',
        password: 'Password123!'
      };

      // First creation succeeds
      await request(app)
        .post('/api/v1/users')
        .send(userData)
        .expect(201);

      // Second creation fails
      const response = await request(app)
        .post('/api/v1/users')
        .send(userData)
        .expect(409);

      expect(response.body.error.code).toBe('DUPLICATE_EMAIL');
    });
  });

  describe('GET /api/v1/users/:id', () => {
    it('should return user by id', async () => {
      const user = await db.users.create({
        email: 'test@example.com',
        name: 'Test User'
      });

      const response = await request(app)
        .get(`/api/v1/users/${user.id}`)
        .expect(200);

      expect(response.body).toMatchObject({
        id: user.id,
        email: user.email,
        name: user.name
      });
    });

    it('should return 404 for non-existent user', async () => {
      await request(app)
        .get('/api/v1/users/non-existent-id')
        .expect(404);
    });
  });

  describe('Authentication Flow Integration', () => {
    it('should complete login-to-protected-resource flow', async () => {
      // 1. Create user
      const userData = {
        email: 'test@example.com',
        password: 'Password123!'
      };
      
      await request(app)
        .post('/api/v1/users')
        .send({ ...userData, name: 'Test User' })
        .expect(201);

      // 2. Login
      const loginResponse = await request(app)
        .post('/api/v1/auth/login')
        .send(userData)
        .expect(200);

      const { access_token } = loginResponse.body;
      expect(access_token).toBeDefined();

      // 3. Access protected resource
      const profileResponse = await request(app)
        .get('/api/v1/users/me')
        .set('Authorization', `Bearer ${access_token}`)
        .expect(200);

      expect(profileResponse.body.email).toBe(userData.email);

      // 4. Verify unauthorized without token
      await request(app)
        .get('/api/v1/users/me')
        .expect(401);
    });
  });
});

1. Schema Validation Testing

// schema-validation.test.js
const Ajv = require('ajv');
const ajv = new Ajv();

describe('API Response Schema Validation', () => {
  const userSchema = {
    type: 'object',
    required: ['id', 'email', 'name', 'created_at'],
    properties: {
      id: { type: 'string', format: 'uuid' },
      email: { type: 'string', format: 'email' },
      name: { type: 'string' },
      created_at: { type: 'string', format: 'date-time' }
    },
    additionalProperties: false
  };

  it('should match user schema', async () => {
    const response = await request(app)
      .get('/api/v1/users/123')
      .expect(200);

    const validate = ajv.compile(userSchema);
    const valid = validate(response.body);
    
    if (!valid) {
      console.log(validate.errors);
    }
    
    expect(valid).toBe(true);
  });
});

1. Contract Testing (Pact)

// user-api.contract.test.js
const { Pact } = require('@pact-foundation/pact');
const { like, iso8601 } = require('@pact-foundation/pact').Matchers;

const provider = new Pact({
  consumer: 'Frontend',
  provider: 'UserAPI'
});

describe('User API Contract', () => {
  beforeAll(() => provider.setup());
  afterAll(() => provider.finalize());
  afterEach(() => provider.verify());

  it('should get user by id', async () => {
    await provider.addInteraction({
      state: 'user exists',
      uponReceiving: 'a request for user',
      withRequest: {
        method: 'GET',
        path: '/api/v1/users/123'
      },
      willRespondWith: {
        status: 200,
        headers: { 'Content-Type': 'application/json' },
        body: {
          id: like('123'),
          email: like('user@example.com'),
          name: like('John Doe'),
          created_at: iso8601()
        }
      }
    });

    // Test your consumer code
    const user = await userApiClient.getUser('123');
    expect(user.email).toBeDefined();
  });
});

Phase 3: Database Integration Testing

1. Database Setup & Teardown

// db-setup.js
const { Client } = require('pg');
const { migrate } = require('./migrations');
const { seed } = require('./seeds');

class TestDatabase {
  constructor() {
    this.client = new Client({
      host: process.env.TEST_DB_HOST || 'localhost',
      database: process.env.TEST_DB_NAME || 'test_db',
      user: process.env.TEST_DB_USER || 'test_user',
      password: process.env.TEST_DB_PASSWORD
    });
  }

  async connect() {
    await this.client.connect();
  }

  async disconnect() {
    await this.client.end();
  }

  async reset() {
    // Truncate all tables
    await this.client.query(`
      TRUNCATE TABLE users, posts, comments CASCADE;
    `);
  }

  async migrate() {
    await migrate(this.client);
  }

  async seed(fixtures = 'default') {
    await seed(this.client, fixtures);
  }
}

module.exports = TestDatabase;

1. Transaction Testing

// transaction.test.js
describe('Database Transaction Tests', () => {
  it('should rollback on error', async () => {
    const initialBalance = 1000;
    
    // Create accounts
    const account1 = await db.accounts.create({ balance: initialBalance });
    const account2 = await db.accounts.create({ balance: 0 });

    // Attempt transfer that will fail
    await expect(
      transferMoney(account1.id, account2.id, 1500)
    ).rejects.toThrow('Insufficient funds');

    // Verify rollback - balances unchanged
    const acc1After = await db.accounts.findById(account1.id);
    const acc2After = await db.accounts.findById(account2.id);
    
    expect(acc1After.balance).toBe(initialBalance);
    expect(acc2After.balance).toBe(0);
  });

  it('should commit successful transaction', async () => {
    const account1 = await db.accounts.create({ balance: 1000 });
    const account2 = await db.accounts.create({ balance: 0 });

    await transferMoney(account1.id, account2.id, 500);

    const acc1After = await db.accounts.findById(account1.id);
    const acc2After = await db.accounts.findById(account2.id);
    
    expect(acc1After.balance).toBe(500);
    expect(acc2After.balance).toBe(500);
  });
});

1. Data Integrity Testing

// data-integrity.test.js
describe('Data Integrity Tests', () => {
  it('should enforce foreign key constraints', async () => {
    await expect(
      db.posts.create({
        title: 'Test Post',
        user_id: 'non-existent-id'
      })
    ).rejects.toThrow(/foreign key constraint/i);
  });

  it('should enforce unique constraints', async () => {
    await db.users.create({ email: 'test@example.com' });
    
    await expect(
      db.users.create({ email: 'test@example.com' })
    ).rejects.toThrow(/unique constraint/i);
  });

  it('should cascade delete', async () => {
    const user = await db.users.create({ email: 'test@example.com' });
    const post = await db.posts.create({ 
      user_id: user.id, 
      title: 'Test' 
    });

    await db.users.delete(user.id);

    const deletedPost = await db.posts.findById(post.id);
    expect(deletedPost).toBeNull();
  });
});

Phase 4: Microservices Integration Testing

1. Service-to-Service Communication

// microservices.test.js
describe('Microservices Integration', () => {
  beforeAll(async () => {
    // Start test instances of services
    await startService('user-service', 3001);
    await startService('order-service', 3002);
    await startService('payment-service', 3003);
  });

  afterAll(async () => {
    await stopAllServices();
  });

  it('should complete order workflow across services', async () => {
    // 1. Create user (User Service)
    const userResponse = await request('http://localhost:3001')
      .post('/users')
      .send({ email: 'test@example.com', name: 'Test User' })
      .expect(201);

    const userId = userResponse.body.id;

    // 2. Create order (Order Service)
    const orderResponse = await request('http://localhost:3002')
      .post('/orders')
      .send({
        user_id: userId,
        items: [{ product_id: 'prod_123', quantity: 2 }],
        total: 99.99
      })
      .expect(201);

    const orderId = orderResponse.body.id;

    // 3. Process payment (Payment Service)
    const paymentResponse = await request('http://localhost:3003')
      .post('/payments')
      .send({
        order_id: orderId,
        amount: 99.99,
        method: 'card'
      })
      .expect(200);

    expect(paymentResponse.body.status).toBe('completed');

    // 4. Verify order status updated
    const orderCheck = await request('http://localhost:3002')
      .get(`/orders/${orderId}`)
      .expect(200);

    expect(orderCheck.body.status).toBe('paid');
  });
});

1. Message Queue Testing

// message-queue.test.js
const { connect } = require('amqplib');

describe('Message Queue Integration', () => {
  let connection, channel;

  beforeAll(async () => {
    connection = await connect('amqp://localhost');
    channel = await connection.createChannel();
    await channel.assertQueue('test-queue');
  });

  afterAll(async () => {
    await channel.close();
    await connection.close();
  });

  it('should publish and consume messages', async (done) => {
    const message = { type: 'USER_CREATED', user_id: '123' };

    // Consumer
    await channel.consume('test-queue', (msg) => {
      const received = JSON.parse(msg.content.toString());
      expect(received).toEqual(message);
      channel.ack(msg);
      done();
    });

    // Producer
    await channel.sendToQueue(
      'test-queue',
      Buffer.from(JSON.stringify(message))
    );
  });

  it('should handle message processing failure with retry', async () => {
    let attempts = 0;
    
    await channel.consume('test-queue', async (msg) => {
      attempts++;
      
      if (attempts < 3) {
        // Reject and requeue
        channel.nack(msg, false, true);
      } else {
        // Success on third attempt
        channel.ack(msg);
        expect(attempts).toBe(3);
      }
    });

    await channel.sendToQueue('test-queue', Buffer.from('test'));
  });
});

1. Event-Driven Testing

// event-driven.test.js
describe('Event-Driven Integration', () => {
  it('should trigger downstream events', async () => {
    const events = [];
    
    // Subscribe to events
    eventBus.on('user.created', (data) => {
      events.push({ type: 'user.created', data });
    });
    
    eventBus.on('email.sent', (data) => {
      events.push({ type: 'email.sent', data });
    });

    // Trigger action
    await createUser({ email: 'test@example.com', name: 'Test' });

    // Wait for async events
    await waitFor(() => events.length === 2, { timeout: 5000 });

    expect(events).toContainEqual(
      expect.objectContaining({ type: 'user.created' })
    );
    expect(events).toContainEqual(
      expect.objectContaining({ type: 'email.sent' })
    );
  });
});

Phase 5: End-to-End Testing

1. UI-Driven Integration Tests (Playwright)

// e2e/user-registration.spec.js
const { test, expect } = require('@playwright/test');

test.describe('User Registration Flow', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('http://localhost:3000');
  });

  test('should complete full registration workflow', async ({ page }) => {
    // Navigate to registration
    await page.click('text=Sign Up');
    await expect(page).toHaveURL(/.*\/register/);

    // Fill registration form
    await page.fill('#email', 'test@example.com');
    await page.fill('#name', 'Test User');
    await page.fill('#password', 'Password123!');
    await page.fill('#confirmPassword', 'Password123!');

    // Submit form
    await page.click('button[type="submit"]');

    // Wait for redirect
    await expect(page).toHaveURL(/.*\/dashboard/);

    // Verify welcome message
    await expect(page.locator('text=Welcome, Test User')).toBeVisible();

    // Verify email sent (check database)
    const emailLog = await db.emails.findOne({ 
      to: 'test@example.com',
      type: 'welcome' 
    });
    expect(emailLog).toBeDefined();
  });

  test('should show validation errors', async ({ page }) => {
    await page.click('text=Sign Up');
    
    // Submit without filling
    await page.click('button[type="submit"]');

    // Check errors
    await expect(page.locator('text=Email is required')).toBeVisible();
    await expect(page.locator('text=Name is required')).toBeVisible();
  });
});

1. Multi-Step Workflow Testing

// e2e/checkout-flow.spec.js
test('should complete checkout workflow', async ({ page }) => {
  // 1. Login
  await page.goto('/login');
  await page.fill('#email', 'test@example.com');
  await page.fill('#password', 'Password123!');
  await page.click('button:text("Login")');

  // 2. Browse products
  await page.goto('/products');
  await page.click('[data-testid="product-1"]');

  // 3. Add to cart
  await page.click('button:text("Add to Cart")');
  await expect(page.locator('[data-testid="cart-count"]')).toHaveText('1');

  // 4. Go to cart
  await page.click('[data-testid="cart-icon"]');
  await expect(page).toHaveURL(/.*\/cart/);

  // 5. Proceed to checkout
  await page.click('button:text("Checkout")');

  // 6. Fill shipping info
  await page.fill('#address', '123 Main St');
  await page.fill('#city', 'New York');
  await page.fill('#zip', '10001');
  await page.click('button:text("Continue")');

  // 7. Enter payment
  await page.fill('#cardNumber', '4242424242424242');
  await page.fill('#expiry', '12/25');
  await page.fill('#cvc', '123');

  // 8. Submit order
  await page.click('button:text("Place Order")');

  // 9. Verify success
  await expect(page.locator('text=Order Confirmed')).toBeVisible();
  
  const orderId = await page.locator('[data-testid="order-id"]').textContent();
  expect(orderId).toMatch(/^ord_/);

  // 10. Verify database
  const order = await db.orders.findById(orderId);
  expect(order.status).toBe('confirmed');
  expect(order.total).toBeGreaterThan(0);
});

Phase 6: Test Data Management

1. Fixtures

// fixtures/users.js
module.exports = {
  admin: {
    email: 'admin@example.com',
    name: 'Admin User',
    role: 'admin',
    password: 'Admin123!'
  },
  regularUser: {
    email: 'user@example.com',
    name: 'Regular User',
    role: 'user',
    password: 'User123!'
  },
  inactiveUser: {
    email: 'inactive@example.com',
    name: 'Inactive User',
    role: 'user',
    status: 'inactive'
  }
};

// Usage in tests
const fixtures = require('./fixtures/users');

beforeEach(async () => {
  await db.users.create(fixtures.admin);
  await db.users.create(fixtures.regularUser);
});

1. Factory Pattern

// factories/user.factory.js
const { faker } = require('@faker-js/faker');

class UserFactory {
  static create(overrides = {}) {
    return {
      email: faker.internet.email(),
      name: faker.person.fullName(),
      password: 'Password123!',
      role: 'user',
      status: 'active',
      ...overrides
    };
  }

  static createMany(count, overrides = {}) {
    return Array.from({ length: count }, () => this.create(overrides));
  }

  static admin(overrides = {}) {
    return this.create({ role: 'admin', ...overrides });
  }
}

// Usage
const user = UserFactory.create();
const admin = UserFactory.admin({ name: 'Admin User' });
const users = UserFactory.createMany(10);

1. Database Seeding

// seeds/test-data.js
async function seed(db) {
  // Create users
  const users = await db.users.createMany([
    { email: 'admin@example.com', role: 'admin' },
    { email: 'user1@example.com', role: 'user' },
    { email: 'user2@example.com', role: 'user' }
  ]);

  // Create posts
  const posts = await db.posts.createMany([
    { user_id: users[1].id, title: 'First Post', status: 'published' },
    { user_id: users[1].id, title: 'Draft Post', status: 'draft' },
    { user_id: users[2].id, title: 'Another Post', status: 'published' }
  ]);

  // Create comments
  await db.comments.createMany([
    { post_id: posts[0].id, user_id: users[2].id, content: 'Great post!' },
    { post_id: posts[0].id, user_id: users[0].id, content: 'Thanks!' }
  ]);

  return { users, posts };
}

module.exports = { seed };

Phase 7: Mocking & Stubbing

1. External API Mocking

// Using nock for HTTP mocking
const nock = require('nock');

describe('External API Integration', () => {
  afterEach(() => {
    nock.cleanAll();
  });

  it('should fetch user from external API', async () => {
    nock('https://api.external.com')
      .get('/users/123')
      .reply(200, {
        id: '123',
        name: 'External User',
        email: 'external@example.com'
      });

    const user = await externalApiClient.getUser('123');
    expect(user.name).toBe('External User');
  });

  it('should handle external API errors', async () => {
    nock('https://api.external.com')
      .get('/users/123')
      .reply(500, { error: 'Internal Server Error' });

    await expect(
      externalApiClient.getUser('123')
    ).rejects.toThrow('External API error');
  });

  it('should handle network timeout', async () => {
    nock('https://api.external.com')
      .get('/users/123')
      .delayConnection(5000)
      .reply(200);

    await expect(
      externalApiClient.getUser('123', { timeout: 1000 })
    ).rejects.toThrow('timeout');
  });
});

1. Service Mocking

// Using jest.mock
jest.mock('../services/email.service');
const emailService = require('../services/email.service');

describe('User Registration with Email Mock', () => {
  it('should send welcome email on registration', async () => {
    emailService.sendWelcomeEmail.mockResolvedValue({ sent: true });

    const user = await registerUser({
      email: 'test@example.com',
      name: 'Test User'
    });

    expect(emailService.sendWelcomeEmail).toHaveBeenCalledWith(
      'test@example.com',
      'Test User'
    );
  });
});

Phase 8: CI/CD Integration

1. GitHub Actions Workflow

# .github/workflows/integration-tests.yml
name: Integration Tests

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main, develop]

jobs:
  integration-tests:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_DB: test_db
          POSTGRES_USER: test_user
          POSTGRES_PASSWORD: test_password
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 5432:5432

      redis:
        image: redis:7
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 6379:6379

    steps:
      - uses: actions/checkout@v3

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

      - name: Install dependencies
        run: npm ci

      - name: Run migrations
        env:
          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
        run: npm run migrate

      - name: Run integration tests
        env:
          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
          REDIS_URL: redis://localhost:6379
        run: npm run test:integration

      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/coverage-final.json
          flags: integration

      - name: Generate test report
        if: always()
        uses: dorny/test-reporter@v1
        with:
          name: Integration Test Results
          path: test-results.json
          reporter: jest-junit

1. Parallel Test Execution

// jest.config.js
module.exports = {
  testMatch: ['**/__tests__/**/*.test.js'],
  maxWorkers: 4, // Run 4 tests in parallel
  testTimeout: 30000, // 30 seconds
  setupFilesAfterEnv: ['./test-setup.js'],
  collectCoverageFrom: [
    'src/**/*.js',
    '!src/**/*.test.js'
  ],
  coverageThreshold: {
    global: {
      branches: 70,
      functions: 70,
      lines: 70,
      statements: 70
    }
  }
};

Test Coverage & Reporting

// Generate coverage report
npm run test:integration -- --coverage

// Coverage report example
---------------------|---------|----------|---------|---------|
File                 | % Stmts | % Branch | % Funcs | % Lines |
---------------------|---------|----------|---------|---------|
All files           |   85.23  |   78.45  |   82.11 |   85.67 |
 api/               |   92.15  |   88.32  |   90.22 |   92.45 |
  users.js          |   95.67  |   92.11  |   94.33 |   95.89 |
  posts.js          |   88.23  |   84.12  |   85.44 |   88.67 |
 services/          |   78.45  |   68.23  |   73.11 |   79.12 |
  email.js          |   82.34  |   75.44  |   79.22 |   83.11 |
---------------------|---------|----------|---------|---------|

Integration Testing Patterns & Best Practices

This guide covers common patterns, anti-patterns, and best practices for integration testing.

Test Design Patterns

1. Arrange-Act-Assert (AAA) Pattern

Structure

test('should do something', async () => {
  // Arrange - Set up test data and dependencies
  const user = await createTestUser({ email: 'test@example.com' });
  const service = new OrderService();
  
  // Act - Execute the functionality being tested
  const order = await service.createOrder(user.id, { items: [...] });
  
  // Assert - Verify the outcome
  expect(order.status).toBe('pending');
  expect(order.user_id).toBe(user.id);
});

Benefits

• Clear test structure
• Easy to read and maintain
• Separates concerns
• Identifies missing steps

Anti-pattern: Multiple Acts

// ❌ Bad - Multiple acts in one test
test('user workflow', async () => {
  const user = await createUser();
  const profile = await updateProfile(user.id); // Act 1
  const order = await createOrder(user.id); // Act 2
  const payment = await processPayment(order.id); // Act 3
  
  // Which assertion belongs to which act?
  expect(profile.name).toBe('Test');
  expect(order.status).toBe('completed');
});

// ✅ Good - Split into separate tests
test('should update user profile', async () => {
  const user = await createUser();
  
  const profile = await updateProfile(user.id);
  
  expect(profile.name).toBe('Test');
});

test('should create order for user', async () => {
  const user = await createUser();
  
  const order = await createOrder(user.id);
  
  expect(order.status).toBe('pending');
});

2. Test Data Builder Pattern

Implementation

class UserBuilder {
  constructor() {
    this.user = {
      email: 'default@example.com',
      name: 'Default User',
      role: 'user',
      status: 'active'
    };
  }
  
  withEmail(email) {
    this.user.email = email;
    return this;
  }
  
  withName(name) {
    this.user.name = name;
    return this;
  }
  
  asAdmin() {
    this.user.role = 'admin';
    return this;
  }
  
  inactive() {
    this.user.status = 'inactive';
    return this;
  }
  
  build() {
    return { ...this.user };
  }
  
  async create() {
    return await db.users.create(this.build());
  }
}

// Usage
test('should allow admin to delete users', async () => {
  const admin = await new UserBuilder()
    .withEmail('admin@example.com')
    .asAdmin()
    .create();
  
  const user = await new UserBuilder()
    .withEmail('user@example.com')
    .create();
  
  await deleteUser(admin.id, user.id);
  
  const deleted = await db.users.findById(user.id);
  expect(deleted).toBeNull();
});

Benefits

• Fluent API for test data creation
• Reduces duplication
• Default values for common cases
• Easy to maintain and extend

3. Object Mother Pattern

Implementation

class UserMother {
  static regular() {
    return {
      email: 'user@example.com',
      name: 'Regular User',
      role: 'user',
      status: 'active'
    };
  }
  
  static admin() {
    return {
      email: 'admin@example.com',
      name: 'Admin User',
      role: 'admin',
      status: 'active'
    };
  }
  
  static inactive() {
    return {
      email: 'inactive@example.com',
      name: 'Inactive User',
      role: 'user',
      status: 'inactive'
    };
  }
  
  static withOrders(orderCount = 5) {
    return {
      ...this.regular(),
      orders: Array.from({ length: orderCount }, (_, i) => 
        OrderMother.forUser(i)
      )
    };
  }
}

// Usage
test('should display user orders', async () => {
  const user = await db.users.create(UserMother.withOrders(3));
  
  const orders = await orderService.getUserOrders(user.id);
  
  expect(orders).toHaveLength(3);
});

Benefits

• Pre-defined test data scenarios
• Named factory methods
• Reduces test setup code
• Centralized test data management

4. Test Fixture Pattern

Setup

// fixtures/users.js
module.exports = {
  users: [
    {
      id: 'user-1',
      email: 'john@example.com',
      name: 'John Doe',
      role: 'user'
    },
    {
      id: 'user-2',
      email: 'jane@example.com',
      name: 'Jane Smith',
      role: 'admin'
    }
  ],
  posts: [
    {
      id: 'post-1',
      user_id: 'user-1',
      title: 'First Post',
      status: 'published'
    },
    {
      id: 'post-2',
      user_id: 'user-1',
      title: 'Draft Post',
      status: 'draft'
    }
  ]
};

// Test
const fixtures = require('./fixtures/users');

beforeEach(async () => {
  await db.users.createMany(fixtures.users);
  await db.posts.createMany(fixtures.posts);
});

test('should get user posts', async () => {
  const posts = await postService.getUserPosts('user-1');
  
  expect(posts).toHaveLength(2);
});

Benefits

• Consistent test data across tests
• Easy to version and update
• Can be shared across test suites
• Supports complex data relationships

5. Database Transaction Pattern

Implementation

describe('User Service', () => {
  let transaction;
  
  beforeEach(async () => {
    transaction = await db.beginTransaction();
  });
  
  afterEach(async () => {
    await transaction.rollback();
  });
  
  test('should create user', async () => {
    const user = await userService.createUser({
      email: 'test@example.com'
    }, { transaction });
    
    expect(user.id).toBeDefined();
    
    // Data visible within transaction
    const found = await userService.findById(user.id, { transaction });
    expect(found).toBeDefined();
    
    // After test, transaction rolls back automatically
  });
});

Benefits

• Fast test cleanup
• Test isolation
• No database cleanup needed
• Prevents data pollution

6. Shared Setup Pattern

Implementation

// setup/test-context.js
class TestContext {
  constructor() {
    this.users = [];
    this.posts = [];
  }
  
  async createUser(data = {}) {
    const user = await db.users.create({
      email: `user-${Date.now()}@example.com`,
      name: 'Test User',
      ...data
    });
    this.users.push(user);
    return user;
  }
  
  async createPost(userId, data = {}) {
    const post = await db.posts.create({
      user_id: userId,
      title: 'Test Post',
      ...data
    });
    this.posts.push(post);
    return post;
  }
  
  async cleanup() {
    await db.posts.deleteMany(this.posts.map(p => p.id));
    await db.users.deleteMany(this.users.map(u => u.id));
  }
}

// Usage
describe('Post Service', () => {
  let context;
  
  beforeEach(() => {
    context = new TestContext();
  });
  
  afterEach(async () => {
    await context.cleanup();
  });
  
  test('should create post', async () => {
    const user = await context.createUser();
    const post = await context.createPost(user.id);
    
    expect(post.user_id).toBe(user.id);
  });
});

7. Page Object Pattern (E2E)

Implementation

// pages/LoginPage.js
class LoginPage {
  constructor(page) {
    this.page = page;
    this.emailInput = '#email';
    this.passwordInput = '#password';
    this.submitButton = 'button[type="submit"]';
    this.errorMessage = '.error-message';
  }
  
  async goto() {
    await this.page.goto('/login');
  }
  
  async login(email, password) {
    await this.page.fill(this.emailInput, email);
    await this.page.fill(this.passwordInput, password);
    await this.page.click(this.submitButton);
  }
  
  async getErrorMessage() {
    return await this.page.textContent(this.errorMessage);
  }
  
  async isLoggedIn() {
    return await this.page.url().includes('/dashboard');
  }
}

// Usage in tests
test('should login successfully', async ({ page }) => {
  const loginPage = new LoginPage(page);
  
  await loginPage.goto();
  await loginPage.login('user@example.com', 'Password123!');
  
  expect(await loginPage.isLoggedIn()).toBe(true);
});

test('should show error for invalid credentials', async ({ page }) => {
  const loginPage = new LoginPage(page);
  
  await loginPage.goto();
  await loginPage.login('user@example.com', 'wrongpassword');
  
  const error = await loginPage.getErrorMessage();
  expect(error).toContain('Invalid credentials');
});

Benefits

• Encapsulates page interactions
• Reduces code duplication
• Makes tests more maintainable
• Abstracts UI changes

Testing Anti-Patterns

1. Test Interdependence

❌ Bad - Tests depend on each other

describe('User workflow', () => {
  let userId;
  
  test('1. create user', async () => {
    const user = await createUser();
    userId = user.id; // Shared state
    expect(user).toBeDefined();
  });
  
  test('2. update user', async () => {
    const updated = await updateUser(userId); // Depends on test 1
    expect(updated.name).toBe('Updated');
  });
});

✅ Good - Independent tests

describe('User operations', () => {
  test('should create user', async () => {
    const user = await createUser();
    expect(user).toBeDefined();
  });
  
  test('should update user', async () => {
    const user = await createUser(); // Create own data
    const updated = await updateUser(user.id);
    expect(updated.name).toBe('Updated');
  });
});

2. Hidden Dependencies

❌ Bad - Hidden database dependency

test('should get user by email', async () => {
  // Assumes user exists in database
  const user = await getUserByEmail('existing@example.com');
  expect(user).toBeDefined();
});

✅ Good - Explicit setup

test('should get user by email', async () => {
  // Explicit setup
  await createUser({ email: 'test@example.com' });
  
  const user = await getUserByEmail('test@example.com');
  expect(user).toBeDefined();
});

3. Overly Complex Tests

❌ Bad - Too much logic in test

test('complex workflow', async () => {
  const users = [];
  for (let i = 0; i < 10; i++) {
    const user = await createUser({ email: `user${i}@example.com` });
    users.push(user);
    
    if (i % 2 === 0) {
      await assignRole(user.id, 'admin');
    }
    
    for (let j = 0; j < 3; j++) {
      await createPost(user.id, { title: `Post ${j}` });
    }
  }
  
  // What are we actually testing?
  const admins = users.filter(u => u.role === 'admin');
  expect(admins.length).toBe(5);
});

✅ Good - Simple, focused test

test('should assign admin role to user', async () => {
  const user = await createUser();
  
  await assignRole(user.id, 'admin');
  
  const updated = await getUser(user.id);
  expect(updated.role).toBe('admin');
});

4. Testing Implementation Details

❌ Bad - Testing internal implementation

test('should call database with correct query', async () => {
  const spy = jest.spyOn(db, 'query');
  
  await userService.getUser('123');
  
  expect(spy).toHaveBeenCalledWith(
    'SELECT * FROM users WHERE id = $1',
    ['123']
  );
});

✅ Good - Testing behavior

test('should return user by id', async () => {
  const created = await createUser({ id: '123' });
  
  const user = await userService.getUser('123');
  
  expect(user.id).toBe('123');
  expect(user.email).toBe(created.email);
});

5. Shared Mutable State

❌ Bad - Shared state across tests

const sharedUser = { email: 'shared@example.com' };

describe('User tests', () => {
  test('should update email', async () => {
    sharedUser.email = 'updated@example.com';
    await updateUser(sharedUser);
  });
  
  test('should have original email', async () => {
    // This will fail! sharedUser was mutated
    expect(sharedUser.email).toBe('shared@example.com');
  });
});

✅ Good - Fresh state per test

describe('User tests', () => {
  let user;
  
  beforeEach(() => {
    user = { email: 'test@example.com' };
  });
  
  test('should update email', async () => {
    user.email = 'updated@example.com';
    await updateUser(user);
    expect(user.email).toBe('updated@example.com');
  });
  
  test('should have original email', async () => {
    expect(user.email).toBe('test@example.com');
  });
});

Best Practices

Test Organization

1. Group Related Tests

describe('User API', () => {
  describe('POST /users', () => {
    test('should create user with valid data', () => {});
    test('should return 422 for invalid email', () => {});
    test('should return 409 for duplicate email', () => {});
  });
  
  describe('GET /users/:id', () => {
    test('should return user by id', () => {});
    test('should return 404 for non-existent user', () => {});
  });
  
  describe('PATCH /users/:id', () => {
    test('should update user fields', () => {});
    test('should not update email to existing email', () => {});
  });
});

2. Use Descriptive Test Names

// ❌ Bad
test('user test', () => {});
test('works', () => {});
test('test 1', () => {});

// ✅ Good
test('should create user with valid email and name', () => {});
test('should return 404 when user does not exist', () => {});
test('should require authentication for protected endpoints', () => {});

3. Test One Thing at a Time

// ❌ Bad - Testing multiple things
test('user creation', async () => {
  const user = await createUser({ email: 'test@example.com' });
  expect(user.id).toBeDefined();
  expect(user.email).toBe('test@example.com');
  expect(user.created_at).toBeInstanceOf(Date);
  
  const fromDb = await getUser(user.id);
  expect(fromDb).toBeDefined();
  
  const all = await getAllUsers();
  expect(all).toContain(user);
});

// ✅ Good - Separate focused tests
test('should create user with generated id', async () => {
  const user = await createUser({ email: 'test@example.com' });
  expect(user.id).toBeDefined();
});

test('should persist user to database', async () => {
  const user = await createUser({ email: 'test@example.com' });
  const fromDb = await getUser(user.id);
  expect(fromDb.email).toBe(user.email);
});

Test Data Management

1. Use Factories for Dynamic Data

// factory.js
const { faker } = require('@faker-js/faker');

function createUserData(overrides = {}) {
  return {
    email: faker.internet.email(),
    name: faker.person.fullName(),
    age: faker.number.int({ min: 18, max: 80 }),
    ...overrides
  };
}

// test
test('should create user', async () => {
  const userData = createUserData({ age: 25 });
  const user = await createUser(userData);
  expect(user.age).toBe(25);
});

2. Use Fixtures for Stable Data

// fixtures/products.json
{
  "products": [
    { "id": "prod-1", "name": "Widget", "price": 19.99 },
    { "id": "prod-2", "name": "Gadget", "price": 29.99 }
  ]
}

// test
const fixtures = require('./fixtures/products.json');

test('should calculate order total', () => {
  const order = calculateTotal(fixtures.products);
  expect(order.total).toBe(49.98);
});

3. Clean Up Test Data

// Using transaction rollback
describe('User tests', () => {
  let transaction;
  
  beforeEach(async () => {
    transaction = await db.beginTransaction();
  });
  
  afterEach(async () => {
    await transaction.rollback();
  });
});

// Using explicit cleanup
describe('User tests', () => {
  const createdIds = [];
  
  afterEach(async () => {
    await db.users.deleteMany(createdIds);
    createdIds.length = 0;
  });
  
  test('should create user', async () => {
    const user = await createUser();
    createdIds.push(user.id);
  });
});

Assertion Best Practices

1. Use Specific Assertions

// ❌ Bad - Too vague
expect(response.status).toBeTruthy();
expect(user).toBeDefined();

// ✅ Good - Specific assertions
expect(response.status).toBe(200);
expect(user.email).toBe('test@example.com');

2. Assert on Behavior, Not Implementation

// ❌ Bad - Implementation detail
expect(mockFunction).toHaveBeenCalledTimes(1);

// ✅ Good - Behavior
const result = await doSomething();
expect(result.success).toBe(true);

3. Use Appropriate Matchers

// Equality
expect(value).toBe(1); // Strict equality
expect(obj).toEqual({ id: 1 }); // Deep equality
expect(array).toContain(item); // Array contains

// Objects
expect(obj).toHaveProperty('id');
expect(obj).toMatchObject({ id: 1 });

// Strings
expect(str).toMatch(/pattern/);
expect(str).toContain('substring');

// Numbers
expect(num).toBeGreaterThan(0);
expect(num).toBeCloseTo(1.5, 1);

// Async
await expect(promise).resolves.toBe(value);
await expect(promise).rejects.toThrow(Error);

Test Performance

1. Run Fast Tests First

// package.json
{
  "scripts": {
    "test": "npm run test:unit && npm run test:integration",
    "test:unit": "jest --testPathPattern=unit",
    "test:integration": "jest --testPathPattern=integration"
  }
}

2. Use Parallel Execution

// jest.config.js
module.exports = {
  maxWorkers: '50%', // Use 50% of CPU cores
  testTimeout: 10000
};

3. Mock Slow Dependencies

// Mock external API
jest.mock('../services/external-api');
externalApi.fetchData.mockResolvedValue({ data: 'mocked' });

// Mock database for unit tests
jest.mock('../database');
db.users.findById.mockResolvedValue({ id: '123' });

Test Maintenance

1. Keep Tests DRY

// Extract common setup
function setupTestUser() {
  return createUser({ email: 'test@example.com' });
}

// Extract common assertions
function assertValidUser(user) {
  expect(user).toHaveProperty('id');
  expect(user).toHaveProperty('email');
  expect(user.email).toMatch(/@/);
}

2. Refactor Tests with Code

// When you rename a function
function createUser() {} // renamed from addUser()

// Update all tests
test('should create user', async () => {
  const user = await createUser(); // was addUser()
});

3. Remove Obsolete Tests

// When feature is removed, remove its tests
describe('Deprecated feature', () => {
  // Delete this entire test suite
});

Test Pyramid Principles

           /\
          /  \
         / E2E\      Few (slow, brittle)
        /------\
       /  Integ \    Some (medium speed)
      /----------\
     /    Unit    \  Many (fast, reliable)
    /--------------\

Guidelines

1. Unit Tests: 60-70% of tests, fast, isolated 2. Integration Tests: 20-30% of tests, test component interactions 3. E2E Tests: 5-10% of tests, test critical user journeys

Integration Test Focus

• API endpoints
• Database operations
• Service communication
• Authentication/Authorization
• Data flow across boundaries
• External integrations (with mocks)

When to Write Integration Tests

• ✅ Testing API contracts
• ✅ Testing database transactions
• ✅ Testing service interactions
• ✅ Testing authentication flows
• ✅ Testing data transformations
• ❌ Testing business logic (use unit tests)
• ❌ Testing UI interactions (use E2E tests)
• ❌ Testing every edge case (use unit tests)

Testing Best Practices

Test Organization

1. Arrange-Act-Assert (AAA) Pattern

   it('should do something', () => {
     // Arrange - Set up test data
     const input = { value: 10 };
     
     // Act - Execute the test
     const result = doSomething(input);
     
     // Assert - Verify the result
     expect(result).toBe(20);
   });

2. Test Independence

• Each test should be isolated
• Use beforeEach/afterEach for setup/cleanup
• Don't rely on test execution order

3. Descriptive Test Names

   // ❌ Bad
   it('works', () => { });
   
   // ✅ Good
   it('should return 404 when user does not exist', () => { });

Test Data

1. Use factories for dynamic data 2. Use fixtures for stable reference data 3. Clean up test data after each test 4. Avoid hardcoded IDs 5. Use meaningful test data

Performance

1. Run unit tests before integration tests 2. Use test database snapshots 3. Parallel test execution where possible 4. Mock slow external dependencies 5. Set appropriate timeouts

Maintenance

1. Keep tests simple and focused 2. Avoid test duplication 3. Refactor tests with code 4. Monitor test flakiness 5. Remove obsolete tests

Testing Frameworks & Tools

JavaScript/Node.js

• Jest: Full-featured testing framework
• Mocha + Chai: Flexible testing setup
• Supertest: HTTP assertions
• Playwright/Puppeteer: E2E testing
• Pact: Contract testing

Python

• pytest: Popular testing framework
• unittest: Built-in framework
• requests: HTTP testing
• Selenium: E2E testing
• Factory Boy: Test data generation

Java

• JUnit 5: Testing framework
• TestContainers: Docker containers for tests
• REST Assured: API testing
• Mockito: Mocking framework
• Selenium: E2E testing

Testing Frameworks Comprehensive Guide

This guide provides detailed information about testing frameworks across different languages and platforms.

JavaScript/TypeScript Testing Frameworks

Jest

Overview: Complete testing framework with built-in mocking, coverage, and assertions.

Installation

npm install --save-dev jest @types/jest

Configuration

// jest.config.js
module.exports = {
  testEnvironment: 'node',
  testMatch: ['**/__tests__/**/*.test.js'],
  collectCoverageFrom: ['src/**/*.js'],
  coveragePathIgnorePatterns: ['/node_modules/', '/tests/'],
  setupFilesAfterEnv: ['./jest.setup.js'],
  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1'
  },
  maxWorkers: '50%',
  testTimeout: 10000
};

Jest Setup File

// jest.setup.js
beforeAll(() => {
  console.log('Global test setup');
});

afterAll(() => {
  console.log('Global test teardown');
});

// Custom matchers
expect.extend({
  toBeWithinRange(received, floor, ceiling) {
    const pass = received >= floor && received <= ceiling;
    if (pass) {
      return {
        message: () => `expected ${received} not to be within range ${floor} - ${ceiling}`,
        pass: true
      };
    } else {
      return {
        message: () => `expected ${received} to be within range ${floor} - ${ceiling}`,
        pass: false
      };
    }
  }
});

Example Tests

// user.service.test.js
const UserService = require('../services/user.service');
const db = require('../database');

jest.mock('../database');

describe('UserService', () => {
  let userService;

  beforeEach(() => {
    userService = new UserService();
    jest.clearAllMocks();
  });

  describe('createUser', () => {
    it('should create user successfully', async () => {
      const userData = {
        email: 'test@example.com',
        name: 'Test User'
      };

      db.users.create.mockResolvedValue({
        id: '123',
        ...userData,
        created_at: new Date()
      });

      const result = await userService.createUser(userData);

      expect(result).toHaveProperty('id', '123');
      expect(result.email).toBe(userData.email);
      expect(db.users.create).toHaveBeenCalledWith(userData);
      expect(db.users.create).toHaveBeenCalledTimes(1);
    });

    it('should throw error for duplicate email', async () => {
      db.users.create.mockRejectedValue(
        new Error('Unique constraint violation')
      );

      await expect(
        userService.createUser({ email: 'exists@example.com' })
      ).rejects.toThrow('Unique constraint violation');
    });
  });

  describe('getUserById', () => {
    it('should return user when found', async () => {
      const mockUser = { id: '123', email: 'test@example.com' };
      db.users.findById.mockResolvedValue(mockUser);

      const result = await userService.getUserById('123');

      expect(result).toEqual(mockUser);
    });

    it('should return null when user not found', async () => {
      db.users.findById.mockResolvedValue(null);

      const result = await userService.getUserById('999');

      expect(result).toBeNull();
    });
  });
});

Async Testing

// Promises
test('async test with promise', () => {
  return fetchData().then(data => {
    expect(data).toBe('result');
  });
});

// Async/Await
test('async test with async/await', async () => {
  const data = await fetchData();
  expect(data).toBe('result');
});

// Resolves/Rejects
test('async test with resolves', async () => {
  await expect(fetchData()).resolves.toBe('result');
});

test('async test with rejects', async () => {
  await expect(fetchError()).rejects.toThrow('error');
});

Snapshot Testing

test('component snapshot', () => {
  const component = renderComponent({ title: 'Test' });
  expect(component).toMatchSnapshot();
});

// Update snapshots: jest --updateSnapshot

Mocha + Chai

Installation

npm install --save-dev mocha chai chai-http sinon

Configuration

// .mocharc.js
module.exports = {
  require: ['./test/setup.js'],
  spec: 'test/**/*.test.js',
  timeout: 5000,
  recursive: true,
  reporter: 'spec'
};

Example Tests

// user.test.js
const { expect } = require('chai');
const sinon = require('sinon');
const UserService = require('../services/user.service');
const db = require('../database');

describe('UserService', () => {
  let userService;
  let dbStub;

  beforeEach(() => {
    userService = new UserService();
    dbStub = sinon.stub(db.users);
  });

  afterEach(() => {
    sinon.restore();
  });

  describe('#createUser', () => {
    it('should create user successfully', async () => {
      const userData = { email: 'test@example.com', name: 'Test' };
      dbStub.create.resolves({ id: '123', ...userData });

      const result = await userService.createUser(userData);

      expect(result).to.have.property('id', '123');
      expect(result.email).to.equal(userData.email);
      expect(dbStub.create.calledOnce).to.be.true;
    });

    it('should throw error for invalid email', async () => {
      try {
        await userService.createUser({ email: 'invalid' });
        expect.fail('Should have thrown error');
      } catch (error) {
        expect(error.message).to.include('email');
      }
    });
  });
});

HTTP Testing with Chai-HTTP

const chai = require('chai');
const chaiHttp = require('chai-http');
const app = require('../app');

chai.use(chaiHttp);
const { expect } = chai;

describe('User API', () => {
  it('GET /api/users should return users', (done) => {
    chai.request(app)
      .get('/api/users')
      .end((err, res) => {
        expect(res).to.have.status(200);
        expect(res.body).to.be.an('array');
        expect(res.body).to.have.lengthOf.at.least(1);
        done();
      });
  });

  it('POST /api/users should create user', async () => {
    const res = await chai.request(app)
      .post('/api/users')
      .send({ email: 'test@example.com', name: 'Test' });

    expect(res).to.have.status(201);
    expect(res.body).to.have.property('id');
  });
});

Supertest (HTTP Testing)

Installation

npm install --save-dev supertest

Example Tests

const request = require('supertest');
const app = require('../app');

describe('User API Integration', () => {
  describe('POST /api/v1/users', () => {
    it('should create user with valid data', async () => {
      const response = await request(app)
        .post('/api/v1/users')
        .send({
          email: 'test@example.com',
          name: 'Test User',
          password: 'Password123!'
        })
        .expect(201)
        .expect('Content-Type', /json/);

      expect(response.body).toMatchObject({
        email: 'test@example.com',
        name: 'Test User'
      });
      expect(response.body).toHaveProperty('id');
    });

    it('should return validation errors', async () => {
      const response = await request(app)
        .post('/api/v1/users')
        .send({ email: 'invalid-email' })
        .expect(422);

      expect(response.body.errors).toBeDefined();
    });
  });

  describe('Authentication', () => {
    it('should require authentication', async () => {
      await request(app)
        .get('/api/v1/users/me')
        .expect(401);
    });

    it('should accept valid token', async () => {
      const token = 'valid-jwt-token';
      
      const response = await request(app)
        .get('/api/v1/users/me')
        .set('Authorization', `Bearer ${token}`)
        .expect(200);

      expect(response.body).toHaveProperty('email');
    });
  });
});

Playwright (E2E Testing)

Installation

npm install --save-dev @playwright/test
npx playwright install

Configuration

// playwright.config.js
const { defineConfig, devices } = require('@playwright/test');

module.exports = defineConfig({
  testDir: './e2e',
  timeout: 30000,
  expect: {
    timeout: 5000
  },
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 1 : undefined,
  reporter: [
    ['html'],
    ['junit', { outputFile: 'test-results.xml' }]
  ],
  use: {
    baseURL: 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure'
  },
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] }
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] }
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] }
    },
    {
      name: 'Mobile Chrome',
      use: { ...devices['Pixel 5'] }
    }
  ],
  webServer: {
    command: 'npm run start',
    port: 3000,
    reuseExistingServer: !process.env.CI
  }
});

Example Tests

// e2e/login.spec.js
const { test, expect } = require('@playwright/test');

test.describe('Login Flow', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/login');
  });

  test('successful login', async ({ page }) => {
    await page.fill('#email', 'user@example.com');
    await page.fill('#password', 'Password123!');
    await page.click('button[type="submit"]');

    await expect(page).toHaveURL('/dashboard');
    await expect(page.locator('h1')).toHaveText('Dashboard');
  });

  test('login with invalid credentials', async ({ page }) => {
    await page.fill('#email', 'user@example.com');
    await page.fill('#password', 'wrongpassword');
    await page.click('button[type="submit"]');

    await expect(page.locator('.error')).toHaveText('Invalid credentials');
  });

  test('login form validation', async ({ page }) => {
    await page.click('button[type="submit"]');

    await expect(page.locator('#email-error')).toBeVisible();
    await expect(page.locator('#password-error')).toBeVisible();
  });
});

// Fixtures
test.describe('With authenticated user', () => {
  test.use({
    storageState: 'auth.json' // Pre-authenticated state
  });

  test('can access protected page', async ({ page }) => {
    await page.goto('/profile');
    await expect(page.locator('h1')).toHaveText('My Profile');
  });
});

// API Testing
test('API: create user', async ({ request }) => {
  const response = await request.post('/api/users', {
    data: {
      email: 'test@example.com',
      name: 'Test User'
    }
  });

  expect(response.ok()).toBeTruthy();
  const body = await response.json();
  expect(body.email).toBe('test@example.com');
});

Python Testing Frameworks

pytest

Installation

pip install pytest pytest-asyncio pytest-cov pytest-mock

Configuration

# pytest.ini
[pytest]
testpaths = tests
python_files = test_*.py *_test.py
python_classes = Test*
python_functions = test_*
addopts = 
    --verbose
    --cov=src
    --cov-report=html
    --cov-report=term
markers =
    integration: Integration tests
    slow: Slow running tests
    api: API tests

Example Tests

# tests/test_user_service.py
import pytest
from unittest.mock import Mock, patch
from src.services.user_service import UserService
from src.models.user import User

@pytest.fixture
def user_service():
    return UserService()

@pytest.fixture
def sample_user():
    return {
        'email': 'test@example.com',
        'name': 'Test User'
    }

class TestUserService:
    def test_create_user_success(self, user_service, sample_user):
        with patch('src.services.user_service.db') as mock_db:
            mock_db.users.create.return_value = User(id='123', **sample_user)
            
            result = user_service.create_user(sample_user)
            
            assert result.id == '123'
            assert result.email == sample_user['email']
            mock_db.users.create.assert_called_once_with(sample_user)
    
    def test_create_user_duplicate_email(self, user_service, sample_user):
        with patch('src.services.user_service.db') as mock_db:
            mock_db.users.create.side_effect = ValueError('Duplicate email')
            
            with pytest.raises(ValueError, match='Duplicate email'):
                user_service.create_user(sample_user)
    
    @pytest.mark.parametrize('email,valid', [
        ('test@example.com', True),
        ('invalid-email', False),
        ('', False),
        ('test@', False)
    ])
    def test_email_validation(self, user_service, email, valid):
        result = user_service.validate_email(email)
        assert result == valid

# Async tests
@pytest.mark.asyncio
async def test_async_create_user(user_service, sample_user):
    result = await user_service.create_user_async(sample_user)
    assert result is not None

API Testing with pytest

# tests/test_api.py
import pytest
from fastapi.testclient import TestClient
from src.main import app

@pytest.fixture
def client():
    return TestClient(app)

class TestUserAPI:
    def test_create_user(self, client):
        response = client.post('/api/v1/users', json={
            'email': 'test@example.com',
            'name': 'Test User',
            'password': 'Password123!'
        })
        
        assert response.status_code == 201
        data = response.json()
        assert data['email'] == 'test@example.com'
        assert 'id' in data
        assert 'password' not in data
    
    def test_create_user_validation_error(self, client):
        response = client.post('/api/v1/users', json={
            'email': 'invalid-email'
        })
        
        assert response.status_code == 422
        data = response.json()
        assert 'detail' in data
    
    def test_get_user(self, client):
        # Create user first
        create_response = client.post('/api/v1/users', json={
            'email': 'test@example.com',
            'name': 'Test User',
            'password': 'Password123!'
        })
        user_id = create_response.json()['id']
        
        # Get user
        response = client.get(f'/api/v1/users/{user_id}')
        
        assert response.status_code == 200
        data = response.json()
        assert data['id'] == user_id

Database Testing

# tests/conftest.py
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from src.database import Base

@pytest.fixture(scope='session')
def db_engine():
    engine = create_engine('sqlite:///:memory:')
    Base.metadata.create_all(engine)
    yield engine
    Base.metadata.drop_all(engine)

@pytest.fixture
def db_session(db_engine):
    Session = sessionmaker(bind=db_engine)
    session = Session()
    yield session
    session.rollback()
    session.close()

# tests/test_user_repository.py
def test_create_user(db_session):
    user = User(email='test@example.com', name='Test User')
    db_session.add(user)
    db_session.commit()
    
    assert user.id is not None
    
    retrieved = db_session.query(User).filter_by(email='test@example.com').first()
    assert retrieved.name == 'Test User'

Java Testing Frameworks

JUnit 5 + Spring Boot Test

Dependencies (Maven)

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>junit-jupiter</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Example Tests

// UserServiceIntegrationTest.java
package com.example.service;

import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.transaction.annotation.Transactional;

import static org.assertj.core.api.Assertions.*;

@SpringBootTest
@ActiveProfiles("test")
@Transactional
class UserServiceIntegrationTest {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private UserRepository userRepository;
    
    @BeforeEach
    void setUp() {
        userRepository.deleteAll();
    }
    
    @Test
    @DisplayName("Should create user successfully")
    void testCreateUser() {
        // Given
        UserDTO userDTO = new UserDTO("test@example.com", "Test User");
        
        // When
        User created = userService.createUser(userDTO);
        
        // Then
        assertThat(created).isNotNull();
        assertThat(created.getId()).isNotNull();
        assertThat(created.getEmail()).isEqualTo("test@example.com");
        
        // Verify in database
        User fromDb = userRepository.findById(created.getId()).orElse(null);
        assertThat(fromDb).isNotNull();
        assertThat(fromDb.getName()).isEqualTo("Test User");
    }
    
    @Test
    @DisplayName("Should throw exception for duplicate email")
    void testCreateUserDuplicateEmail() {
        // Given
        userService.createUser(new UserDTO("test@example.com", "User 1"));
        
        // When/Then
        assertThatThrownBy(() -> 
            userService.createUser(new UserDTO("test@example.com", "User 2"))
        )
        .isInstanceOf(DuplicateEmailException.class)
        .hasMessageContaining("email");
    }
    
    @Nested
    @DisplayName("User retrieval tests")
    class UserRetrievalTests {
        
        @Test
        void testGetUserById() {
            User user = userService.createUser(new UserDTO("test@example.com", "Test"));
            
            User retrieved = userService.getUserById(user.getId());
            
            assertThat(retrieved).isEqualTo(user);
        }
        
        @Test
        void testGetUserByIdNotFound() {
            assertThatThrownBy(() -> userService.getUserById(999L))
                .isInstanceOf(UserNotFoundException.class);
        }
    }
}

API Testing with REST Assured

// UserApiIntegrationTest.java
package com.example.api;

import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserApiIntegrationTest {
    
    @LocalServerPort
    private int port;
    
    @BeforeEach
    void setUp() {
        RestAssured.port = port;
        RestAssured.basePath = "/api/v1";
    }
    
    @Test
    void testCreateUser() {
        given()
            .contentType(ContentType.JSON)
            .body("""
                {
                    "email": "test@example.com",
                    "name": "Test User",
                    "password": "Password123!"
                }
                """)
        .when()
            .post("/users")
        .then()
            .statusCode(201)
            .body("email", equalTo("test@example.com"))
            .body("name", equalTo("Test User"))
            .body("id", notNullValue())
            .body("password", nullValue());
    }
    
    @Test
    void testGetUser() {
        // Create user
        String userId = given()
            .contentType(ContentType.JSON)
            .body("""
                {
                    "email": "test@example.com",
                    "name": "Test User"
                }
                """)
            .post("/users")
            .then()
            .extract()
            .path("id");
        
        // Get user
        given()
            .pathParam("id", userId)
        .when()
            .get("/users/{id}")
        .then()
            .statusCode(200)
            .body("id", equalTo(userId))
            .body("email", equalTo("test@example.com"));
    }
    
    @Test
    void testAuthenticationFlow() {
        // Create user
        given()
            .contentType(ContentType.JSON)
            .body("""
                {
                    "email": "test@example.com",
                    "name": "Test User",
                    "password": "Password123!"
                }
                """)
            .post("/users");
        
        // Login
        String token = given()
            .contentType(ContentType.JSON)
            .body("""
                {
                    "email": "test@example.com",
                    "password": "Password123!"
                }
                """)
            .post("/auth/login")
            .then()
            .statusCode(200)
            .extract()
            .path("access_token");
        
        // Access protected endpoint
        given()
            .header("Authorization", "Bearer " + token)
        .when()
            .get("/users/me")
        .then()
            .statusCode(200)
            .body("email", equalTo("test@example.com"));
    }
}

TestContainers for Database Testing

// AbstractIntegrationTest.java
package com.example;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@SpringBootTest
@Testcontainers
public abstract class AbstractIntegrationTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }
}

// Usage
class UserServiceIntegrationTest extends AbstractIntegrationTest {
    // Tests run with real PostgreSQL database in container
}

Comparison Matrix

Best Practices

Framework Selection

1. Choose based on language ecosystem 2. Consider team familiarity 3. Evaluate plugin ecosystem 4. Check CI/CD integration 5. Review documentation quality

Test Organization

1. Group related tests 2. Use descriptive names 3. Follow AAA pattern 4. Keep tests independent 5. Use fixtures/factories

Performance

1. Run fast tests first 2. Use parallel execution 3. Mock external dependencies 4. Use test database snapshots 5. Optimize setup/teardown

Maintenance

1. Keep tests simple 2. Avoid duplication 3. Refactor with code 4. Monitor flaky tests 5. Remove obsolete tests