Software Testing 101

A comprehensive guide to software testing using TypeScript microservices as practical examples. This series covers everything from unit tests to CI/CD automation, based on real-world production experience.

About This Series

Testing isn't just about finding bugs—it's about building confidence in your code. Through my years building and maintaining TypeScript microservices in production, I've learned that comprehensive testing is what separates hobby projects from production-ready systems.

This series provides practical, real-world testing strategies without fake scenarios. Every example comes from actual microservices handling production traffic.

Series Overview

Part 1: Introduction and Testing Fundamentals

Learn why testing matters and understand the testing pyramid. Covers:

• The importance of testing in production systems

• The testing pyramid (70% unit, 20% integration, 10% E2E)

• Different types of software testing

• Testing frameworks for TypeScript (Jest, Vitest, Mocha)

• Test structure and organization (AAA pattern)

• Test coverage and what it means

• Common testing mistakes to avoid

Key takeaway: Testing is insurance against production disasters. Follow the testing pyramid for fast, reliable test suites.

Part 2: Unit Testing with TypeScript

Master unit testing with real TypeScript examples. Covers:

• What makes a good unit test (fast, isolated, repeatable)

• Testing synchronous and asynchronous code

• Mocking and stubbing dependencies

• Testing error handling and edge cases

• Parameterized tests for multiple scenarios

• Test factories for complex objects

• Test-Driven Development (TDD) approach

• Best practices from production

Key takeaway: Unit tests are your foundation—fast, isolated tests that catch most bugs before integration.

Part 3: Integration Testing

Test how components work together. Covers:

• Database integration testing

• Repository and service layer testing

• Testing with Docker containers (Testcontainers)

• Message queue integration (Redis, RabbitMQ)

• Test data management and cleanup

• Integration test patterns

• Test transactions and isolation

Key takeaway: Integration tests verify components interact correctly—test with real databases and services when possible.

Part 4: API Testing and Contract Testing

Ensure your APIs behave correctly. Covers:

• REST API testing with Supertest

• Testing HTTP status codes and headers

• Authentication and authorization testing

• OpenAPI/Swagger validation

• Contract testing with Pact (consumer/provider)

• Rate limiting and CORS testing

• API versioning strategies

• Error response testing

Key takeaway: API contracts are critical—test status codes, headers, and ensure services agree on interfaces.

Part 5: End-to-End Testing

Validate complete user workflows. Covers:

• E2E testing with Playwright

• Testing authentication flows

• Complex multi-step workflows (e-commerce checkout)

• Page Object Model pattern

• Test fixtures and setup

• Visual regression testing

• Mobile testing

• API mocking and interception

Key takeaway: E2E tests provide highest confidence—test critical user journeys, not every edge case.

Part 6: Performance and Load Testing

Ensure your system handles load. Covers:

• Load testing with k6

• Realistic user scenarios

• Different test types (load, stress, spike, soak)

• Database performance testing

• Performance benchmarking

• Memory leak detection

• Running load tests in CI/CD

• Setting performance thresholds

Key takeaway: Performance testing prevents production outages—find bottlenecks before users do.

Part 7: Test Automation and CI/CD

Automate testing in your pipeline. Covers:

• CI/CD testing strategies

• GitHub Actions workflows

• Matrix testing (multiple Node versions)

• Parallel test execution

• Test caching for speed

• Deployment smoke tests

• Test reporting and coverage

• Flaky test detection

• Security testing in CI/CD

Key takeaway: Automated testing in CI/CD catches bugs early and enables confident deployments.

Testing Principles

Throughout this series, we follow these principles:

1. The Testing Pyramid

        /\
       /  \
      /E2E \          10% - Slow, expensive, high confidence
     /------\         
    /        \
   /Integration\      20% - Medium speed, test interactions
  /-------------\
 /               \
/   Unit Tests   \    70% - Fast, cheap, catch most bugs
------------------

2. Test Independently

Each test should:

• Run in isolation

• Not depend on other tests

• Create its own test data

• Clean up after itself

3. Test Behavior, Not Implementation

Focus on what code does, not how it does it. Tests should survive refactoring.

4. Fast Feedback

• Unit tests: milliseconds

• Integration tests: seconds

• E2E tests: minutes

Run fast tests first for quick feedback.

5. Realistic Test Data

Use data that represents actual use cases, not [email protected] or foo/bar.

Technology Stack

This series uses:

• Language: TypeScript

• Runtime: Node.js 20+

• Unit Testing: Jest

• API Testing: Supertest

• E2E Testing: Playwright

• Load Testing: k6

• Database: PostgreSQL

• Cache: Redis

• CI/CD: GitHub Actions

• Containers: Docker, Testcontainers

Project Structure

my-microservice/
├── src/
│   ├── api/
│   │   ├── user-controller.ts
│   │   └── __tests__/
│   │       ├── user-api.test.ts
│   │       └── user-api.integration.test.ts
│   ├── services/
│   │   ├── user-service.ts
│   │   └── __tests__/
│   │       ├── user-service.test.ts
│   │       └── user-service.integration.test.ts
│   └── repositories/
│       ├── user-repository.ts
│       └── __tests__/
│           └── user-repository.integration.test.ts
├── e2e/
│   ├── pages/
│   │   ├── login.page.ts
│   │   └── dashboard.page.ts
│   └── auth.spec.ts
├── load-tests/
│   ├── user-api.test.ts
│   └── checkout-flow.test.ts
├── jest.config.js
├── playwright.config.ts
└── package.json

Running Tests

# Install dependencies
npm install

# Run all tests
npm test

# Run specific test types
npm run test:unit           # Unit tests only
npm run test:integration    # Integration tests only
npm run test:e2e           # E2E tests only

# Run with coverage
npm test -- --coverage

# Run specific test file
npm test -- user-service.test.ts

# Run in watch mode
npm test -- --watch

# Run load tests
k6 run load-tests/user-api.test.ts

Test Coverage Goals

In my production projects:

• Unit tests: 80-90% coverage

• Integration tests: Focus on critical paths

• E2E tests: Cover main user journeys

• Performance tests: Validate SLAs and scalability

Remember: 100% coverage ≠ bug-free. Test quality matters more than coverage percentage.

Who This Series Is For

This series is for:

• Backend developers building APIs

• Full-stack developers testing complete systems

• Teams adopting TypeScript for microservices

• Anyone wanting to improve their testing skills

You should have:

• Basic TypeScript/JavaScript knowledge

• Understanding of HTTP and REST APIs

• Familiarity with async/await

• Experience with Node.js

Real-World Impact

From my production experience, comprehensive testing has:

• Prevented outages: Caught critical bugs before deployment

• Enabled refactoring: Changed code confidently without breaking things

• Improved velocity: Faster development with fewer regressions

• Reduced debugging time: Tests pinpoint exactly what broke

• Better sleep: Confidence in production systems

Getting Started

Start with Part 1: Introduction and Testing Fundamentals to understand testing principles, then progress through each part based on your needs.

You can read the series in order or jump to specific topics:

• Need to test APIs? → Part 4

• Building UI? → Part 5

• Performance concerns? → Part 6

• Setting up CI/CD? → Part 7

Additional Resources

• Jest Documentation

• Playwright Documentation

• k6 Documentation

• Testing Library

• Martin Fowler - Testing

Contributing

Found an error or have suggestions? Feel free to contribute improvements to this series.

About the Author

These articles are based on my experience building and maintaining TypeScript microservices in production environments, handling millions of requests daily. Every example and pattern comes from real systems, not theoretical scenarios.

---

Start your testing journey: Part 1: Introduction and Testing Fundamentals →