44 |
CHAPTER 2 |
A first unit test |
Notice that this time the tests initialize the Calculator object in a [SetUp]-related method. This is a good idea, because it saves time writing the tests, makes the code smaller, and makes sure Calculator is always initialized the same way. It’s also better for test maintainability, because if the constructor for Calculator changes, you only need to change the initialization in one place instead of going through each test and changing the new call.
So far, so good. But what happens when the method we’re testing depends on an external resource, such as the filesystem, a database, a web service, or anything else that’s hard for us to control? That’s when we start creating test stubs, fake objects, and mock objects, which are discussed in the next few chapters.
2.7 Summary
In this chapter, we looked at using NUnit to write simple tests against simple code. We used the [SetUp] and [TearDown] attributes to make sure our tests always use new and untouched state. We used [Ignore] to skip tests that need to be fixed. Test categories can help us group tests in a logical way rather than by class and namespace, and [ExpectedException] helps us make sure our code throws exceptions when it should. Finally, we looked at what happens when we aren’t facing a simple method with a return value, and we need to test the end state of an object. This attribute is handy, and you’ll use it in many of your future tests.
This isn’t enough though. Most test code has to deal with far more difficult coding issues. The next couple of chapters will give you some more basic tools for writing unit tests. You’ll need to pick and choose from these tools when you write tests for various difficult scenarios you’ll come across.
Finally, keep the following points in mind:
It’s common practice to have one test class per tested class, one test project per tested project, and at least one test method per tested method.
Summary 45
Name your tests clearly using the following model: [MethodUnderTest]_[Scenario]_[ExpectedBehavior].
Use the [SetUp] and [TearDown] attributes to reuse code in your tests, such as code for creating and initializing objects all your tests use.
Don’t use [SetUp] and [TearDown] to initialize or destroy objects that aren’t shared throughout the test class in all the tests, because it makes the tests less understandable. Someone reading your code won’t know which tests use the logic inside the setup method and which don’t.
In the next chapter, we’ll look at more real-world scenarios, where the code to be tested is a little more realistic than what you’ve seen so far. It has dependencies and testability problems, and we’ll start discussing the notion of integration tests versus unit tests, and what that means to us as developers who write tests and want to ensure our code’s quality.
46 |
CHAPTER 2 |
A first unit test |
Part 2
Core techniques
aving covered the basics in previous chapters, we’ll now introduce the Hcore testing and refactoring techniques that are necessary for writing
tests in the real world.
In chapter 3, we’ll begin by learning about stubs and how they help us break dependencies. We’ll go over refactoring techniques that make code more testable, and we’ll learn about seams in the process.
Then, in chapter 4, we’ll move on to mock objects and interaction testing and look at how mock objects differ from stubs.
Lastly, in chapter 5, we’ll look at isolation frameworks (also known as mock object frameworks) and how they solve some of the repetitive coding involved in handwritten mocks and stubs. Chapter 5 also compares the leading isolation frameworks in .NET and uses Rhino Mocks for examples, showing its API in common use cases.