Formulation of test strategy

Core Objectives of Test Strategy Formulation

The essence of a test strategy lies in defining the scope, methods, and resource allocation for testing. In Node.js projects, the test strategy needs to be specifically designed to address asynchronous features, modular architecture, and I/O-intensive operations. An effective test strategy balances test coverage with execution efficiency, ensuring the reliability of critical paths.

Node.js Testing Layered Strategy

Unit Testing Layer

Unit tests focus on validating the functionality of independent modules. Jest and Mocha are commonly used frameworks, particularly effective for pure functions and standalone classes. For example, testing utility functions:

// utils/calculate.js
function calculateDiscount(price, discountRate) {
  if (discountRate < 0 || discountRate > 1) throw new Error('Invalid rate')
  return price * (1 - discountRate)
}

// __tests__/calculate.test.js
test('should apply 20% discount', () => {
  expect(calculateDiscount(100, 0.2)).toBe(80)
})

test('should reject invalid rates', () => {
  expect(() => calculateDiscount(100, 1.2)).toThrow()
})

Integration Testing Layer

Focuses on validating interactions between modules and integration with external services. Supertest is suitable for testing HTTP interfaces:

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

describe('GET /api/products', () => {
  it('should return paginated results', async () => {
    const res = await request(app)
      .get('/api/products?page=2')
      .expect('Content-Type', /json/)
      .expect(200)
    
    expect(res.body).toHaveProperty('meta.totalPages')
    expect(res.body.data).toBeInstanceOf(Array)
  })
})

E2E Testing Layer

Uses Cypress or Playwright to validate complete user workflows:

// cypress/integration/checkout.spec.js
describe('Checkout Process', () => {
  it('completes purchase with guest account', () => {
    cy.visit('/products/123')
    cy.get('[data-testid="add-to-cart"]').click()
    cy.contains('Proceed to Checkout').click()
    cy.fillGuestForm()
    cy.selectPaymentMethod('credit_card')
    cy.contains('Order Confirmation').should('be.visible')
  })
})

Asynchronous Code Testing Strategy

Promise Handling

Different asynchronous patterns require specific assertion methods:

// Testing with returned Promise
test('fetches user data', () => {
  return fetchUser(123).then(data => {
    expect(data.id).toBe(123)
  })
})

// async/await syntax
test('updates user profile', async () => {
  const result = await updateProfile({ name: 'New Name' })
  expect(result.success).toBeTruthy()
})

Timer Simulation

Use Jest's fake timers to test delayed logic:

// services/notifier.js
async function delayedNotify(message, delayMs) {
  await new Promise(resolve => setTimeout(resolve, delayMs))
  sendNotification(message)
}

// __tests__/notifier.test.js
jest.useFakeTimers()
test('sends notification after delay', () => {
  const mockSend = jest.fn()
  sendNotification = mockSend
  
  delayedNotify('Test', 1000)
  jest.advanceTimersByTime(1000)
  
  expect(mockSend).toHaveBeenCalledWith('Test')
})

Test Data Management Strategy

Factory Function Pattern

Create customizable test data:

// test/factories/user.js
const buildUser = (overrides = {}) => ({
  id: faker.datatype.uuid(),
  name: faker.name.fullName(),
  email: faker.internet.email(),
  ...overrides
})

// Usage in test cases
test('handles premium users', () => {
  const user = buildUser({ isPremium: true })
  expect(hasPremiumAccess(user)).toBe(true)
})

Database Fixtures

Use mongodb-memory-server for isolated testing:

const { MongoMemoryServer } = require('mongodb-memory-server')

describe('UserRepository', () => {
  let mongoServer
  let repository

  beforeAll(async () => {
    mongoServer = await MongoMemoryServer.create()
    const uri = mongoServer.getUri()
    repository = new UserRepository(uri)
  })

  afterAll(async () => {
    await repository.disconnect()
    await mongoServer.stop()
  })

  test('saves and retrieves users', async () => {
    const testUser = { name: 'Test', email: 'test@example.com' }
    const saved = await repository.create(testUser)
    const found = await repository.findById(saved.id)
    expect(found.name).toBe(testUser.name)
  })
})

Performance Testing Strategy

Benchmark Testing

Use benchmark.js to measure critical path performance:

const Benchmark = require('benchmark')
const crypto = require('crypto')

new Benchmark.Suite()
  .add('SHA256', () => {
    crypto.createHash('sha256').update('test').digest('hex')
  })
  .add('MD5', () => {
    crypto.createHash('md5').update('test').digest('hex')
  })
  .on('cycle', event => {
    console.log(String(event.target))
  })
  .run()

Stress Testing

Use Artillery for API load testing:

# load-test.yml
config:
  target: "http://api.example.com"
  phases:
    - duration: 60
      arrivalRate: 50
scenarios:
  - flow:
      - get:
          url: "/products"
      - post:
          url: "/checkout"
          json:
            items: ["prod_123"]

Test Environment Differentiation Strategy

Environment-Sensitive Configuration

Use dotenv to manage test environment variables:

// jest.config.js
module.exports = {
  setupFiles: ['<rootDir>/tests/setupEnv.js']
}

// tests/setupEnv.js
require('dotenv').config({ path: '.env.test' })

// .env.test
DB_URI=mongodb://localhost:27017/test_db
LOG_LEVEL=silent

Service Mocking Strategy

Switch between real services and mocks based on the environment:

// config/test.js
module.exports = {
  paymentService: process.env.USE_REAL_PAYMENTS 
    ? require('../services/realPayment')
    : require('../mocks/paymentMock')
}

// Explicit declaration in tests
process.env.USE_REAL_PAYMENTS = 'true'

Coverage Analysis Strategy

Custom Coverage Standards

Define thresholds in Jest configuration:

// jest.config.js
module.exports = {
  coverageThreshold: {
    global: {
      branches: 80,
      functions: 85,
      lines: 90,
      statements: 90
    },
    'src/utils/': {
      branches: 100,
      lines: 100
    }
  }
}

Path Exclusion Strategy

Ignore code that doesn't require testing:

/* istanbul ignore next */
function deprecatedMethod() {
  console.warn('This will be removed in v2.0')
  // ...original logic
}

Continuous Integration Strategy

Phased Testing Process

GitLab CI example configuration:

stages:
  - test

unit_tests:
  stage: test
  image: node:16
  script:
    - npm run test:unit
    - npm run coverage:upload

integration_tests:
  stage: test
  services:
    - mongodb:4.4
  script:
    - npm run test:integration

e2e_tests:
  stage: test
  script:
    - npm run start:test-server &
    - npm run test:e2e

Parallel Execution Optimization

Utilize Jest's shard parameter:

# In CI scripts
jest --shard=1/3 & jest --shard=2/3 & jest --shard=3/3

Error Tracking Strategy

Error Injection Testing

Deliberately trigger error scenarios:

// tests/errorHandling.test.js
const mockRequest = () => {
  const req = { params: {}, body: {} }
  req.header = jest.fn().mockReturnValue('application/json')
  return req
}

test('handles DB connection errors', async () => {
  const req = mockRequest()
  const res = { status: jest.fn().mockReturnThis(), json: jest.fn() }
  const next = jest.fn()

  // Simulate database connection error
  jest.spyOn(db, 'connect').mockRejectedValue(new Error('Connection failed'))
  
  await databaseMiddleware(req, res, next)
  expect(res.status).toHaveBeenCalledWith(503)
})

Chaos Engineering

Introduce random failures using chaos-js:

const Chaos = require('chaos-js')

Chaos
  .experiment('Payment Service Resilience')
  .withService('payment')
  .method('processPayment')
  .errorRate(0.3) // 30% failure rate
  .latency({ min: 100, max: 2000 }) // Random latency
  .start()