| ... |
... |
@@ -1,32 +1,32 @@ |
| 1 |
|
-=== Purpose === |
|
1 |
+### Purpose |
| 2 |
2 |
|
| 3 |
|
-* Mocking simplifies unit testing by replacing the dependencies of the unit being tested with simplified, simulated versions called mocks. |
| 4 |
|
-* Example: Consider a unit under test that relies on a database. In testing, the database can be mocked to return a static value, eliminating the need for an actual database. |
|
3 |
+* **Mocking simplifies unit testing by replacing the dependencies** of the unit being tested with simplified, simulated versions called mocks. Example: Consider a unit under test that relies on a database. In testing, the database can be mocked to return a static value, eliminating the need for an actual database. |
| 5 |
5 |
|
|
5 |
+### Benefits of Mocking |
| 6 |
6 |
|
| 7 |
|
-=== Benefits of Mocking === |
|
7 |
+* **Isolation of units** to test each unit separately, dramatically reducing complexity and increasing test execution speed by replacing loaded modules with mocks. |
|
8 |
+* **Simplifies the re-creation of specific scenarios** (use cases, boundary cases) in which a dependency behaves in a particular way. |
|
9 |
+* **Expose hidden internals** of production code without compromising encapsulation. |
|
10 |
+* **Injection of test-specific behaviors** not present in production code. |
|
11 |
+* **Enables the simulation of indirect dependencies** by letting mocks return other mocks. |
| 8 |
8 |
|
| 9 |
|
-* Isolation of units to test each unit separately, dramatically reducing complexity and increasing test execution speed by replacing loaded modules with mocks. |
| 10 |
|
-* Simplifies the re-creation of specific scenarios (use cases, boundary cases). |
| 11 |
|
-* Expose hidden internals of production code without compromising encapsulation. |
| 12 |
|
-* Injection of test-specific behaviors not present in production code. |
| 13 |
|
-* Enables the simulation of indirect dependencies by letting mocks return other mocks. |
|
13 |
+### Types of Mocks |
| 14 |
14 |
|
| 15 |
|
- |
| 16 |
|
-=== Types of Mocks === |
| 17 |
|
- |
| 18 |
18 |
Stubs are by far the most common type of mock. Keep your tests as simple as possible. Make them more complex only when necessary. |
| 19 |
19 |
|
| 20 |
|
-* Stubs: Simplest form, returning a hardcoded value or providing an empty method body. |
| 21 |
|
-* Fake object: Include minimal logic to handle different case scenarios. |
| 22 |
|
-* Spy: Injected to capture interaction data with fake objects when such data is not directly accessible. |
| 23 |
|
-* Mock objects: Contain complex logic, simulate behaviors such as computation and exception handling, and even run tests. |
|
17 |
+* **Stubs**: Simplest form, returning a hardcoded value or providing an empty method body. |
|
18 |
+* **Fake object**: Include minimal logic to handle different case scenarios. |
|
19 |
+* **Spy**: Records internal data of the unit being tested when such data is not directly accessible. |
|
20 |
+* **Mock object**: Contains complex logic, simulates behaviors such as computation and exception handling, and can even run tests. |
| 24 |
24 |
|
|
22 |
+### |
| 25 |
25 |
|
| 26 |
|
-=== Tips === |
|
24 |
+### Tips |
| 27 |
27 |
|
| 28 |
|
-* Mock third-party libraries for unit tests to ensure proper unit functionality. Instead, use the third-party libraries in component and integration tests. |
| 29 |
|
-* Minimize the dependencies of a unit. The fewer dependencies, the easier it is to mock and test the logic. |
| 30 |
|
-** If a class has too many dependencies, split the class or extract two dependencies into a new class. This also results in smaller, more cohesive classes/units. |
| 31 |
|
-** If there is more than one test class for a production class, the production class is probably too large. |
| 32 |
|
-** If the test code is very complex and hard to understand, the production class is probably too large. |
|
26 |
+* **Mock third-party libraries in unit tests** to ensure proper unit functionality. However, they should not be mocked in component and integration tests. |
|
27 |
+* Aim for a **minimal number of dependencies in a unit** for easier testing and mocking: |
|
28 |
+ * Limit dependencies in a unit in a similar way to the best practices for function arguments: the fewer the better, with an absolute maximum of three. |
|
29 |
+ * Prefer many small classes/units to one large one for easier testing. |
|
30 |
+ * If a class has excessive dependencies, consider splitting it up or extracting some dependencies into a new class to create smaller, more cohesive units. |
|
31 |
+ * If a production class requires more than one test class, it's probably a sign that the class is too large. |
|
32 |
+ * Overly complex test code may indicate an overly large production class. |
