Real Unit Testing with Test Doubles

A unit test differentiates itself from other test categories by using test doubles; actually, you would rarely see a unit test without a test double.

There is a lot of confusion on the web about what that means. My aim in this chapter is to clarify this term so that you can use it in the right context and give you as many explained examples of the topic so you feel confident in selecting the right test double for the test at hand.

In this chapter, we will:

• Explain the concepts and usage of test doubles
• Discuss more testing categories

By the end of the chapter, you will understand what is special about unit testing and will be able to use test doubles to start writing realistic unit tests.

Technical requirements

The code for this chapter can be found at the following GitHub repository:

https://github.com/PacktPublishing/Pragmatic-Test-Driven-Development-in-C-Sharp-and-.NET/tree/main/ch04

Understanding and using test doubles

You would rarely write a unit test without using a test double. Think of the term double in the same sense as a Hollywood stunt, where a stunt takes the place of a real actor in some situations. Test double is an umbrella term for an object that is used to replace a dependency with a test equivalent (double) for the sake of testing a SUT. They are meant to satisfy one or more of the following requirements:

Requirement 1: Enable the test code to compile.

Requirement 2: Eliminate side effects according to the unit test requirements.

Requirement 3: Embed a canned (predetermined) behavior that relates somehow to the real behavior.

Requirement 4: Take a note of and verify the activities that were exerted on a dependency within a unit test (we will name this requirement later as spying).

We will be referring to these four conditions when we discuss individual test double types, so you may want to bookmark this section.

Do you want your...

More testing categories

You’ve probably heard about plenty of testing categories other than unit testing. There is integration testing, regression testing, automation testing, load testing, pen testing, component testing—and the list goes on. Well, we won’t cover all these test categories, as explaining them all will not fit in this book. What we will do instead is discuss the two categories that have commonalities with unit testing. The first one is integration testing and the second one is what I call Sintegration testing. We will also have an honorable mention of acceptance testing due to its importance in building a full test categories suite.

Unit testing, integration testing, and Sintegration testing have one major difference that sets them apart. It is how they deal with dependencies. Understanding the differences will help clarify how unit testing fits into the test ecosystem.

Integration testing

Integration testing is, fortunately, easy to understand...

Summary

In this chapter, we compared unit tests with its siblings: integration and Sintegration tests. We listed test doubles and gave an example of each, and we have also seen xUnit and NSubstitute in action.

Our journey with understanding unit testing and test doubles will not stop here, but we will cover more examples of the two topics across the rest of the book.

So far, you can consider the experience from this chapter to take you to TDD level 3 out of 5! And now, you should be able to write a basic unit test that uses test doubles.

We have not covered the advantages and disadvantages of unit testing—yes, it has disadvantages! We have also not covered how TDD relates to unit testing and the best practices of unit testing because this is the role of the next chapter, Test-Driven Development Explained.

Further reading

To learn more about the topics discussed in the chapter, you can refer to the following links:

• Martin Fowler’s definition of test doubles: https://martinfowler.com/bliki/TestDouble.html
• NSubstitute: https://nsubstitute.github.io