Pattern 1: Arrange-Act-Assert (AAA)

The Arrange-Act-Assert (AAA) pattern structures test cases into three clear phases, making them easy to understand and maintain:

• Arrange: Set up the environment and initialize any necessary data.
• Act: Execute the behavior or function you want to test.
• Assert: Verify that the outcome matches expectations.

Example: Testing with AAA in JavaScript

test("should add two numbers correctly", () => {
    // Arrange
    const a = 2;
    const b = 3;
    const expected = 5;

    // Act
    const result = add(a, b);

    // Assert
    expect(result).toBe(expected);
});

Using the AAA pattern improves readability, ensuring that each part of the test is clearly defined and easy to follow.

Pattern 2: Dependency Injection for Test Isolation

Dependency Injection (DI) enables tests to control dependencies by injecting mock or stub data. This pattern isolates the component under test, making tests more reliable and faster by removing external dependencies.

Example: Injecting a Mock Service in a Unit Test

class UserService {
    constructor(apiClient) {
        this.apiClient = apiClient;
    }

    async getUser(id) {
        return await this.apiClient.fetchUser(id);
    }
}

// Test with injected mock
test("should return user data", async () => {
    const mockApiClient = { fetchUser: jest.fn().mockResolvedValue({ name: "Alice" }) };
    const userService = new UserService(mockApiClient);

    const user = await userService.getUser(1);
    expect(user).toEqual({ name: "Alice" });
});

By injecting a mock `apiClient`, this test verifies the `getUser` behavior independently, avoiding real API calls and improving test reliability.

Pattern 3: Mocking and Stubbing External Dependencies

Mocks and stubs simulate external dependencies, allowing tests to focus on the behavior of the code under test. Mocking replaces a function with a simulated version, while stubbing provides controlled responses for specific scenarios.

Example: Mocking with Jest

import { fetchData } from "./dataService";

jest.mock("./dataService");

test("should call fetchData with correct parameters", () => {
    fetchData.mockResolvedValue({ data: "mocked data" });

    const data = fetchData("url");
    expect(fetchData).toHaveBeenCalledWith("url");
});

In this example, `fetchData` is mocked to provide a predictable response, making it easier to test the calling code without relying on the actual function implementation.

Pattern 4: Behavior Verification with Spy

Spies allow tests to verify if specific functions are called and with what parameters. This is particularly useful for tracking interactions between components or verifying event handling.

Example: Verifying Calls with a Spy

const myFunction = jest.fn();

myFunction("test");
expect(myFunction).toHaveBeenCalled();
expect(myFunction).toHaveBeenCalledWith("test");

Spies capture details about function calls, enabling tests to assert the correct interactions between components without affecting the underlying code.

Pattern 5: Test Doubles for Integration Testing

Test doubles like fakes, mocks, and stubs are used to simulate dependencies during integration testing, providing control over responses and improving reliability in complex environments.

Example: Using a Fake Database in Node.js

class FakeDatabase {
    constructor() {
        this.data = {};
    }

    save(key, value) {
        this.data[key] = value;
    }

    fetch(key) {
        return this.data[key];
    }
}

// Integration test with a fake database
test("should save and fetch data", () => {
    const db = new FakeDatabase();
    db.save("user", { name: "Alice" });

    const user = db.fetch("user");
    expect(user).toEqual({ name: "Alice" });
});

Using a fake database allows this test to validate save and fetch operations without relying on an actual database, improving speed and isolation.

Best Practices for Testing Design Patterns

• Write Clear Assertions: Ensure that assertions clearly describe expected outcomes, making tests easy to understand and debug.
• Isolate Dependencies: Use dependency injection, mocks, and stubs to isolate code under test from external dependencies.
• Organize Tests by Pattern: Use the Arrange-Act-Assert structure to make tests more readable and maintainable.

Conclusion

Testing design patterns, such as Arrange-Act-Assert, Dependency Injection, and behavior verification with spies, offer structured approaches for creating reliable, maintainable tests. These patterns ensure that tests are isolated, clear, and effective, allowing developers to confidently maintain and scale applications over time. By leveraging these patterns, teams can create robust testing suites that safeguard application quality.