test-patterns

name	test-patterns
description	Applies proven testing patterns — Arrange-Act-Assert (AAA), Given-When-Then, Test Data Builders, Object Mother, parameterized tests, fixtures, spies, and test doubles — to help write maintainable, reliable, and readable test suites. Use when the user asks about writing unit tests, integration tests, or end-to-end tests; structuring test cases or test suites; applying TDD or BDD practices; working with mocks, stubs, spies, or fakes; improving test coverage or reducing flakiness; or needs guidance on test organization, naming conventions, or assertions in frameworks like Jest, Vitest, pytest, or similar.
version	1.0.0
triggers	["test patterns","testing best practices","how to write tests","test structure","arrange act assert"]
tags	["testing","patterns","quality","best-practices"]
difficulty	intermediate
estimatedTime	10
relatedSkills	["testing/red-green-refactor","testing/anti-patterns"]

Test Patterns

You are applying proven testing patterns to write maintainable, reliable tests. These patterns help ensure tests are readable, focused, and trustworthy.

Pattern Selection Guide

Use this to choose the right pattern for your situation:

• Structuring a single test? → Arrange-Act-Assert (AAA) or Given-When-Then
• Writing behavior/feature specs? → Given-When-Then (BDD style)
• Repeating test setup data? → Test Data Builders
• Many variations of complex objects? → Object Mother
• Testing same logic with many inputs? → Parameterized Tests
• Shared setup/teardown across tests? → Test Fixtures
• Verifying a dependency was called? → Spy
• Replacing an external dependency? → Test Doubles (Stub / Mock / Fake)

---

Pattern Combination Workflows

Patterns rarely stand alone — here's how to combine them for common scenarios:

Unit tests (isolated logic): Fixtures for setup → AAA structure → Stubs/Mocks for dependencies → Parameterized Tests for multiple input cases

Integration tests (service + external dependencies): Fixtures for setup → AAA structure → Fakes for external services (e.g. in-memory DB) → Spies to verify interaction points

BDD / feature specs: Given-When-Then → Object Mother or Test Data Builders for scenario data → Fakes for infrastructure

High-variation logic (validators, calculators, formatters): Parameterized Tests → Test Data Builders to construct each case → AAA structure within each case

---

Core Pattern: Arrange-Act-Assert (AAA)

Structure every test with three distinct phases:

// Arrange - Set up test data and dependencies
const user = createTestUser({ role: 'admin' });
const service = new UserService(mockRepository);

// Act - Execute the code under test
const result = await service.updateRole(user.id, 'member');

// Assert - Verify the expected outcome
expect(result.role).toBe('member');
expect(mockRepository.save).toHaveBeenCalledWith(user);

Guidelines:

• Keep sections visually separated (blank lines or comments)
• Arrange should be minimal - only what's needed for this test
• Act should be a single operation
• Assert should verify one logical concept

Pattern: Given-When-Then (BDD Style)

For behavior-focused tests:

describe('Shopping Cart', () => {
  describe('when adding an item', () => {
    it('should increase the item count', () => {
      // Given
      const cart = new Cart();

      // When
      cart.add({ id: '1', quantity: 2 });

      // Then
      expect(cart.itemCount).toBe(2);
    });
  });
});