Mocking is a Code Smell

Unit tests test individual units (modules, functions, classes) in isolation from the rest of the program.

• Generally, units are tested using the public interface of the unit, known as black-box testing. It leads to less brittle tests.
• In white box testing - where tests are aware of implementation details - any change to the implementation details could break the test, even if the public API continues to function as expected.

Code coverage is the amount of code covered by a test. Increasing coverage beyond 90% seems to have little continued correlation with lower bug density.

There are two kinds of coverage: 

• Code coverage: how much of the code is exercised, and 
• Case coverage: how many of the use-case scenarios are covered by the test suites.  

Coverage reports identify code-coverage weaknesses, not case coverages weaknesses.

Less coupling makes code easier to extend and maintain. Tight coupling makes code more rigid and brittle and more likely to break when changes are needed.

Coupling takes different forms: 

• Subclass coupling is dependent on the implementation and hierarchy of the parent class.
• Control dependencies. Code that tells its dependences what to do. If the control API of the dependency changes, the dependent code will break.
• State shape dependencies. Code that only uses a subset of the data structure.
• Event/message coupling. Code that communicates with other units via message passing, events, etc.

Tight coupling has many causes: 

• Mutation vs immutability  
• Side-Effects vs purity/isolated side-effects  
• Responsibility overload vs Do One Thing (DOT)  
• Procedural instructions vs describing structure  
• Class Inheritance vs composition  

Imperative and object-oriented code is more vulnerable to tight coupling than functional code.

All software development is about the process of breaking a big problem down into smaller independent parts, combining the solutions to form an application that solves the big problem. 

Mocking is necessary when the decomposition strategy failed. When decomposition succeeds, a generic composition utility can be used to compose the pieces together.