This document summarizes chapters 5 and 6 from a book on unit testing. Chapter 5 discusses why isolation frameworks are useful for creating fake objects more easily than hand-coding mocks. It also covers simulating fake values and testing events. Chapter 6 distinguishes between constrained and unconstrained isolation frameworks and discusses features that support future-proofing and usability of frameworks. Both chapters emphasize that isolation frameworks make testing easier, faster and less error-prone compared to manually writing mocks.

1. Tech Podcast Night
The art of unit testing ch5-6
by mia

2. 關
於
我
Microsoft Data Platform MVP
Data Scientist
Computer Vision/Algorithm Research
mia5419@gmail.com
https://github.com/pymia/
https://www.linkedin.com/in/mia-chang/
Tech Podcast Night
https://www.facebook.com/TechPodcastNight/
Mia Chang

3. Chap 5
● 5.1 Why use isolation frameworks?
● 5.2 Dynamically creating a fake object
● 5.3 Simulating fake values
● 5.4 Testing for event-related activities
● 5.5 Current isolation frameworks for .NET
● 5.6 Advantages and traps of isolation frameworks
● 5.7 Summary
Chap 6
● 6.1 Constrained and unconstrained frameworks
● 6.2 Values of good isolation frameworks
● 6.3 Features supporting future-proofing and usability
● 6.4 Isolation framework design antipatterns
● 6.5 Summary
Agenda

4. 5.1
DEFINITION An isolation framework is a set of programmable API s that makes creating
fake objects much simpler, faster, and shorter than hand-coding them.
- Using isolation frameworks instead of writing mocks and stubs manually, as in previous
chapters, has several advantages that make developing more elegant and complex
tests easier, faster, and less error prone.
The best way to understand the value of an isolation framework is to see a problem
and its solution. One problem that might occur when using handwritten mocks and
stubs is repetitive code.

5. 5.1
Assume you have an interface a little
more complicated than the ones shown
so far:

6. 5.2
DEFINITION A dynamic fake object is any stub or mock that’s created at runtime
without needing to use a handwritten (hardcoded) implementation of
that object.
Next, we’ll look at NSubstitute and see how it can help you overcome some of the
problems just discussed.

7. 5.3

12. arrange
act
assert
■ Easy to create the object with the
expected properties.
■ Test all the properties of the object in
question.
■ You know the exact values of each
property, fully.
■ The Equals() method is implemented
correctly on the two objects being
compared.

15. ch5 summary
Mocks should be used only when there’s no other way to test the implementation,
because they eventually lead to tests that are harder to maintain if you’re not careful.
If more than 5% of your tests have mock objects (not stubs), you might be over specifying things.
Learn how to use the advanced features of an isolation framework such as NSub, and you can pretty
much make sure that anything happens or doesn’t happen in your tests. All you need is for your code to
be testable.

16. ch5 summary
don’t repeat → more readable
In the next chapter, we’ll dig deeper into isolation frameworks
and see how their design and underlying implementation affect their abilities.

17. Chap 5
● 5.1 Why use isolation frameworks?
● 5.2 Dynamically creating a fake object
● 5.3 Simulating fake values
● 5.4 Testing for event-related activities
● 5.5 Current isolation frameworks for .NET
● 5.6 Advantages and traps of isolation frameworks
● 5.7 Summary
Chap 6
● 6.1 Constrained and unconstrained frameworks
● 6.2 Values of good isolation frameworks
● 6.3 Features supporting future-proofing and usability
● 6.4 Isolation framework design antipatterns
● 6.5 Summary
Agenda

18. 6.1 Constrained and unconstrained frameworks
Constrained frameworks usually work by generating code at runtime that inherits
and overrides interfaces or base classes, just as you did in the previous chapter,
the code you want to fake has to be public and inheritable (nonsealed),
has to have a public constructor, or should be an interface.
Unconstrained frameworks: Microsoft Fakes
https://docs.microsoft.com/en-us/visualstudio/test/isolating-code-under-test-with-microsoft-fakes

19. Pros
■ You can write unit tests for previously untestable
code
■ You can fake third-party systems that you can’t
control and that are potentially very hard to test with.
■ You can choose your own level of design, rather
than be forced into specific patterns.
Cons
■ If you don’t pay close attention,
you can fake your way into a corner by faking things
that aren’t needed.
■ If you don’t pay close attention, some tests can
become unmaintainable because you’re faking APIs
that you don’t own.
Fake a low-enough level of an API in a framework,
it’s very unlikely to change in the future. The deeper
an API is, the more likely many things are built on
top of it.
https://docs.microsoft.com/en-us/visualstudio/test/using-shims-to-isolate-your-application-from-other-as
semblies-for-unit-testing

20. 6.2 Values of good isolation framework
Good isolation frameworks have two values:
■ Future-proofing
■ Usability
Here are some features that support these values
in the newer frameworks:
■ Recursive fakes
■ Ignored arguments by default
■ Wide faking
■ Nonstrict behavior of

21. 6.3 Features supporting future-proofing and usability
Here are some features that support these values
in the newer frameworks:
■ Recursive fakes
■ Ignored arguments by default
■ Wide faking
■ Nonstrict behavior of
Not all isolation frameworks allow recursive fakes, so check for this ability on your favorite
framework. As far as I know, only .NET frameworks currently even consider this ability. I
wish this existed in other languages as well.

22. 6.4 Isolation framework design antipatterns
■ Concept confusion
■ Record and replay
■ Sticky behavior
■ Complex syntax

23. 6.4 Isolation framework design antipatterns
■ Concept confusion
■ Record and replay
■ Sticky behavior
■ Complex syntax

24. 6.4 Isolation framework design antipatterns
■ Concept confusion
■ Record and replay
■ Sticky behavior
■ Complex syntax

25. ch6 summary
Isolation frameworks are divided into two categories: constrained and unconstrained frameworks.
The core techniques for writing unit tests.

26. DeepTest: Automated Testing of
Deep-Neural-Network-driven Autonomous Cars ■ Testing of driver assistance systems.
■ Testing and verification of machine learning.
■ Adversarial machine learning
■ Test amplification.
■ Metamorphic testing.