London vs. Chicago: A Tale of Two Mocking StylesWhich One Should You Choose?

In the realm of software testing, mocking is a crucial technique to isolate code and simulate the behavior of complex dependencies. Among the various mocking approaches, London and Chicago styles are the most prominent. This post dives into the intricacies of both styles, comparing and contrasting their merits and demerits to help you make an informed decision on which fits your project needs better.

Introduction

1. Mocking: A Brief Overview: Mocking is a vital part of software testing where certain parts of a system are replaced with dummy implementations to isolate the code under test. This ensures that the tests are not affected by any external factors and remain deterministic. Mocking, when done correctly, helps in achieving a higher level of code coverage and simplifies the testing process.

2. London vs. Chicago: The Two Giants: The London and Chicago styles are two different approaches to mocking. London style focuses on behavior verification, ensuring that the system behaves as expected when the code under test is executed. On the other hand, Chicago style emphasizes state verification, checking the state of the system after the code under test has been executed.

London Style Mocking

1. Behavior Verification: In London style mocking, the emphasis is on behavior verification. Test cases are written to ensure that the code under test interacts with the dependencies in the expected manner. This style is often associated with Behavior Driven Development (BDD) and is usually implemented using mocking frameworks that allow the creation of mock objects.

2. Advantages and Disadvantages: The London style is beneficial when you want to ensure that the system's behavior is as expected, making it suitable for complex systems with intricate interactions. However, it can lead to fragile tests if overused, as changes in the system's behavior may require multiple test updates.

// Example of London style mocking in JavaScript using jest
jest.mock('./dependency.js');  // Mocking a dependency

test('should call dependency', () => {
  const dependency = require('./dependency');
  const functionUnderTest = require('./functionUnderTest');

  functionUnderTest();

  expect(dependency).toHaveBeenCalled();
});

Chicago Style Mocking

1. State Verification: Chicago style mocking, often associated with Classical TDD, focuses on state verification. It checks the state of the system after the code under test has been executed. This style usually involves using real objects instead of mocks, or using mocks in a less intrusive way.

2. Advantages and Disadvantages: This style is more straightforward and tends to result in more robust tests as it's less concerned with the internal workings of the system. However, it might not be suitable for systems with complex interactions or external dependencies.

// Example of Chicago style mocking in JavaScript
const functionUnderTest = require('./functionUnderTest');

test('should update state', () => {
  const result = functionUnderTest();

  expect(result.state).toBe('updated');
});

Making The Right Choice

1. Project Requirements: The choice between London and Chicago style largely depends on the project requirements. If the project involves complex interactions, the London style might be more suitable. Conversely, for projects with clear state transformations, the Chicago style might be the better choice.

2. Mixing Both Styles: It's not a rigid choice; you can mix both styles to suit the needs of different parts of your system, leveraging the strengths of both to create robust, maintainable tests.

Conclusion

1. Informed Decision Making: Understanding the core differences between London and Chicago style mocking is essential for making informed decisions in your testing strategy. Each style has its place and can significantly impact the effectiveness of your testing process.

2. Adaptability is Key: Being adaptable and choosing the right mocking style based on the needs of your project is crucial. It not only enhances the test quality but also makes the codebase more maintainable and robust.

The comparison between London and Chicago style mocking unveils a tale of two robust methodologies, each with its unique strengths and weaknesses. As a developer or a tester, delving into these mocking styles, understanding their nuances, and applying them judiciously based on your project's needs can markedly uplift your testing game, ensuring your software is rigorously tested and ready for the real world.