Part 7: Test Automation and CI/CD

Introduction

Automated testing in CI/CD pipelines ensures every code change is verified before reaching production. In my TypeScript microservices, automated testing catches bugs early, enables confident deployments, and maintains code quality across teams.

This final part covers practical test automation strategies, CI/CD integration, and testing workflows I use in production systems.

CI/CD Testing Strategy

The Testing Pipeline

Code Push → Lint → Unit Tests → Integration Tests → Build → E2E Tests → Deploy → Smoke Tests

Each stage provides fast feedback and gates the next step.

GitHub Actions for Testing

Basic test workflow:

name: Test Suite

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

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run ESLint
        run: npm run lint
      
      - name: Run TypeScript check
        run: npm run type-check

  unit-tests:
    runs-on: ubuntu-latest
    needs: lint
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run unit tests
        run: npm run test:unit -- --coverage
      
      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/coverage-final.json
          flags: unit
      
      - name: Check coverage thresholds
        run: |
          npm run test:unit -- --coverage --coverageThreshold='{"global":{"branches":80,"functions":80,"lines":80,"statements":80}}'

  integration-tests:
    runs-on: ubuntu-latest
    needs: lint
    
    services:
      postgres:
        image: postgres:15-alpine
        env:
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
          POSTGRES_DB: testdb
        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
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run database migrations
        run: npm run db:migrate
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/testdb
      
      - name: Run integration tests
        run: npm run test:integration
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/testdb
          REDIS_URL: redis://localhost:6379
      
      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/coverage-final.json
          flags: integration

  e2e-tests:
    runs-on: ubuntu-latest
    needs: [unit-tests, integration-tests]
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Install Playwright browsers
        run: npx playwright install --with-deps
      
      - name: Build application
        run: npm run build
      
      - name: Start application
        run: |
          npm start &
          npx wait-on http://localhost:3000/health --timeout 60000
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/testdb
          NODE_ENV: test
      
      - name: Run E2E tests
        run: npm run test:e2e
      
      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: playwright-report
          path: playwright-report/
          retention-days: 30

  build:
    runs-on: ubuntu-latest
    needs: [unit-tests, integration-tests, e2e-tests]
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Build
        run: npm run build
      
      - name: Upload build artifacts
        uses: actions/upload-artifact@v3
        with:
          name: dist
          path: dist/

Matrix Testing

Test across multiple Node.js versions and platforms:

# .github/workflows/matrix-test.yml
name: Matrix Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ${{ matrix.os }}
    
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        node-version: [18, 20, 21]
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test

Parallel Testing

Speed up tests by running in parallel:

jest.config.js:

// jest.config.js
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  maxWorkers: '50%', // Use 50% of available CPUs
  testMatch: ['**/__tests__/**/*.test.ts'],
  collectCoverageFrom: ['src/**/*.ts'],
  coveragePathIgnorePatterns: ['/node_modules/', '/__tests__/'],
};

GitHub Actions parallel jobs:

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

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        shard: [1, 2, 3, 4]
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests (shard ${{ matrix.shard }}/4)
        run: npm test -- --shard=${{ matrix.shard }}/4

Test Caching

Cache dependencies and build artifacts:

# .github/workflows/cached-tests.yml
name: Cached Tests

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Cache Jest cache
        uses: actions/cache@v3
        with:
          path: .jest-cache
          key: ${{ runner.os }}-jest-${{ hashFiles('**/package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-jest-
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test -- --cacheDirectory=.jest-cache

Deployment Testing

Smoke Tests After Deployment

// tests/smoke/health-check.smoke.ts
import http from 'k6/http';
import { check } from 'k6';

export const options = {
  vus: 1,
  iterations: 1,
  thresholds: {
    checks: ['rate==1'], // All checks must pass
  },
};

const BASE_URL = __ENV.BASE_URL || 'https://api.production.com';

export default function () {
  // Health check
  const healthRes = http.get(`${BASE_URL}/health`);
  check(healthRes, {
    'health endpoint is up': (r) => r.status === 200,
  });

  // Database connectivity
  const dbRes = http.get(`${BASE_URL}/api/users?limit=1`);
  check(dbRes, {
    'database is accessible': (r) => r.status === 200,
  });

  // Authentication
  const authRes = http.post(`${BASE_URL}/api/auth/login`, JSON.stringify({
    email: '[email protected]',
    password: process.env.SMOKE_TEST_PASSWORD,
  }), {
    headers: { 'Content-Type': 'application/json' },
  });
  
  check(authRes, {
    'auth service works': (r) => r.status === 200,
  });
}

Run smoke tests after deployment:

# .github/workflows/deploy-and-test.yml
name: Deploy and Test

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Deploy to production
        run: ./deploy.sh
        env:
          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
      
      - name: Wait for deployment
        run: sleep 30
      
      - name: Install k6
        run: |
          sudo gpg -k
          sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
          echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
          sudo apt-get update
          sudo apt-get install k6
      
      - name: Run smoke tests
        run: k6 run tests/smoke/health-check.smoke.ts
        env:
          BASE_URL: https://api.production.com
          SMOKE_TEST_PASSWORD: ${{ secrets.SMOKE_TEST_PASSWORD }}
      
      - name: Rollback on failure
        if: failure()
        run: ./rollback.sh

Test Reports

HTML Test Reports

# .github/workflows/test-reports.yml
name: Test Reports

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests with reporters
        run: npm test -- --reporters=default --reporters=jest-html-reporter
      
      - name: Upload test report
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: test-report
          path: test-report.html
      
      - name: Comment PR with results
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const report = fs.readFileSync('test-report.html', 'utf8');
            
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## Test Results\n\n${report}`
            });

Code Coverage Reports

# .github/workflows/coverage.yml
name: Coverage

on: [push]

jobs:
  coverage:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests with coverage
        run: npm test -- --coverage
      
      - name: Generate coverage badges
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/lcov.info
          flags: unittests
          name: codecov-umbrella
      
      - name: Coverage comment
        uses: romeovs/[email protected]
        with:
          lcov-file: ./coverage/lcov.info
          github-token: ${{ secrets.GITHUB_TOKEN }}

Microservices Testing Strategy

Service-Level Tests

# .github/workflows/service-tests.yml
name: Service Tests

on:
  push:
    paths:
      - 'services/**'

jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      services: ${{ steps.filter.outputs.changes }}
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v2
        id: filter
        with:
          filters: |
            user-service:
              - 'services/user-service/**'
            order-service:
              - 'services/order-service/**'
            payment-service:
              - 'services/payment-service/**'

  test-service:
    needs: detect-changes
    if: needs.detect-changes.outputs.services != '[]'
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        service: ${{ fromJSON(needs.detect-changes.outputs.services) }}
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        working-directory: services/${{ matrix.service }}
        run: npm ci
      
      - name: Run tests
        working-directory: services/${{ matrix.service }}
        run: npm test
      
      - name: Build service
        working-directory: services/${{ matrix.service }}
        run: npm run build

Flaky Test Detection

# .github/workflows/flaky-tests.yml
name: Flaky Test Detection

on:
  schedule:
    - cron: '0 2 * * *' # Run nightly

jobs:
  detect-flaky:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests 10 times
        run: |
          for i in {1..10}; do
            echo "Run $i"
            npm test || echo "FAIL" >> results.txt
          done
      
      - name: Check for flaky tests
        run: |
          if grep -q "FAIL" results.txt; then
            echo "Flaky tests detected!"
            exit 1
          fi
      
      - name: Create issue if flaky
        if: failure()
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: 'Flaky tests detected',
              body: 'Automated testing found flaky tests. Please investigate.',
              labels: ['bug', 'flaky-test']
            });

Security Testing in CI/CD

# .github/workflows/security.yml
name: Security Tests

on: [push, pull_request]

jobs:
  dependency-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Run npm audit
        run: npm audit --audit-level=moderate
      
      - name: Check for known vulnerabilities
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

  sast:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Run Semgrep
        uses: returntocorp/semgrep-action@v1
        with:
          config: >-
            p/security-audit
            p/typescript

Best Practices

1. Fast Feedback

# Run fast tests first
jobs:
  lint:         # 30 seconds
  unit-tests:   # 2 minutes
  integration:  # 5 minutes
  e2e:         # 10 minutes

2. Test in Isolation

// Good - isolated test
beforeEach(async () => {
  await db.query('TRUNCATE users CASCADE');
});

// Bad - shared state
let userId;
test('create user', () => {
  userId = createUser();
});

3. Retry Flaky Tests

- name: Run E2E tests
  run: npm run test:e2e
  continue-on-error: true
  
- name: Retry failed tests
  if: failure()
  run: npm run test:e2e -- --retry-failed

4. Skip Tests Conditionally

- name: Run expensive tests
  if: github.event_name == 'push' && github.ref == 'refs/heads/main'
  run: npm run test:load

5. Test Environment Parity

services:
  postgres:
    image: postgres:15  # Same version as production

Monitoring Test Health

Track test metrics over time:

• Test execution time

• Flaky test rate

• Coverage trends

• Failure patterns

// tests/metrics/test-reporter.ts
import { Reporter, Test, TestResult } from '@jest/reporters';

class MetricsReporter implements Reporter {
  async onTestResult(test: Test, testResult: TestResult) {
    // Send metrics to monitoring system
    await sendMetrics({
      testSuite: test.path,
      duration: testResult.perfStats.runtime,
      passed: testResult.numPassingTests,
      failed: testResult.numFailingTests,
      timestamp: Date.now(),
    });
  }
}

export default MetricsReporter;

Key Takeaways

1. Automate all testing - From lint to deployment

2. Fast feedback is critical - Run fast tests first

3. Test in isolation - Each test should be independent

4. Parallelize when possible - Speed up test execution

5. Monitor test health - Track flaky tests and performance

6. Test like production - Use same services and versions

7. Fail fast - Stop pipeline on critical failures

8. Test coverage is important - But not the only metric

Series Conclusion

Through this series, we've covered:

1. Testing Fundamentals - Why testing matters, testing pyramid

2. Unit Testing - Fast, isolated tests for business logic

3. Integration Testing - Testing component interactions

4. API Testing - HTTP endpoints and contracts

5. E2E Testing - Complete user workflows

6. Performance Testing - Load, stress, and benchmarking

7. Test Automation - CI/CD integration and continuous testing

Testing isn't optional—it's fundamental to professional software development. Start with unit tests, add integration tests for critical paths, and E2E tests for key workflows. Automate everything in CI/CD, and you'll ship with confidence.

---

This is the final article in the Software Testing 101 series.