-->
Stub types are one of two technologies that the Microsoft Fakes framework provides to let you easily isolate a component you are testing from other components that it calls. A stub is a small piece of code that takes the place of another component during testing. The benefit of using a stub is that it returns consistent results, making the test easier to write. And you can run tests even if the other components are not working yet.
Craftsman 90016496 drill/driver parts - manufacturer-approved parts for a proper fit every time! We also have installation guides, diagrams and manuals to help you along the way! Get the best deals on Harley-Davidson Motorcycle Driver Backrests Parts when you shop the largest online selection at eBay.com. Free shipping on many items Browse your favorite brands affordable prices.
For an overview and quick start guide to Fakes, see Isolate code under test with Microsoft Fakes.
To use stubs, you have to write your component so that it uses only interfaces, not classes, to refer to other parts of the application. This is a good design practice because it makes changes in one part less likely to require changes in another. For testing, it allows you to substitute a stub for a real component.
In the diagram, the component StockAnalyzer is the one we want to test. It normally uses another component, RealStockFeed. But RealStockFeed returns different results every time its methods are called, making it difficult to test StockAnalyzer. During testing, we replace it with a different class, StubStockFeed.
Because stubs rely on your being able to structure your code in this way, you typically use stubs to isolate one part of your application from another. To isolate it from other assemblies that are not under your control, such as System.dll, you would normally use shims. See Use shims to isolate your application from other assemblies for unit testing.
How to use stubs
Design for dependency injection
To use stubs, your application has to be designed so that the different components are not dependent on each other, but only dependent on interface definitions. Instead of being coupled at compile time, components are connected at run time. This pattern helps to make software that is robust and easy to update, because changes tend not to propagate across component boundaries. We recommend following it even if you don't use stubs. If you are writing new code, it's easy to follow the dependency injection pattern. If you are writing tests for existing software, you might have to refactor it. If that would be impractical, you could consider using shims instead.
Let's start this discussion with a motivating example, the one in the diagram. The class StockAnalyzer reads share prices and generates some interesting results. It has some public methods, which we want to test. To keep things simple, let's just look at one of those methods, a very simple one that reports the current price of a particular share. We want to write a unit test of that method. Here's the first draft of a test:
One problem with this test is immediately obvious: share prices vary, and so the assertion will usually fail.
Another problem might be that the StockFeed component, which is used by the StockAnalyzer, is still under development. Here's the first draft of the code of the method under test:
As it stands, this method might not compile or might throw an exception because work on the StockFeed class is not yet complete. Interface injection addresses both of these problems. Interface injection applies the following rule:
The code of any component of your application should never explicitly refer to a class in another component, either in a declaration or in a new statement. Instead, variables and parameters should be declared with interfaces. Component instances should be created only by the component's container.
By 'component', we mean a class, or a group of classes that you develop and update together. Typically, a component is the code in one Visual Studio project. It's less important to decouple classes within one component, because they are updated at the same time.
It is also not so important to decouple your components from the classes of a relatively stable platform such as System.dll. Writing interfaces for all these classes would clutter your code.
You can decouple the StockAnalyzer code from the StockFeed by using an interface like this:
In this example, StockAnalyzer is passed an implementation of an IStockFeed when it is constructed. In the completed application, the initialization code would perform the connection:
There are more flexible ways of performing this connection. For example, StockAnalyzer could accept a factory object that can instantiate different implementations of IStockFeed in different conditions.
Generate stubs
You've decoupled the class you want to test from the other components that it uses. As well as making the application more robust and flexible, the decoupling allows you to connect the component under test to stub implementations of the interfaces for test purposes.
You could simply write the stubs as classes in the usual way. But Microsoft Fakes provides you with a more dynamic way to create the most appropriate stub for every test.
To use stubs, you must first generate stub types from the interface definitions.
Add a Fakes Assembly
In Solution Explorer,
- For an older .NET Framework Project (non-SDK style), expand your unit test project's References node.
- For an SDK-style project targeting .NET Framework, .NET Core, or .NET 5.0, expand the Dependencies node to find the assembly you would like to fake under Assemblies, Projects, or Packages.
- If you're working in Visual Basic, select Show All Files in the Solution Explorer toolbar to see the References node.
Select the assembly that contains the class definitions for which you want to create shims. For example, if you want to shim DateTime, select System.dll.
On the shortcut menu, choose Add Fakes Assembly.
Write your test with stubs
The special piece of magic here is the class StubIStockFeed. For every public type in the referenced assembly, the Microsoft Fakes mechanism generates a stub class. The name of the stub class is the derived from the name of the interface, with 'Fakes.Stub' as a prefix, and the parameter type names appended.
Stubs are also generated for the getters and setters of properties, for events, and for generic methods.
Verify parameter values
You can verify that when your component makes a call to another component, it passes the correct values. You can either place an assertion in the stub, or you can store the value and verify it in the main body of the test. For example:
Stubs for different kinds of type members
Methods
As described in the example, methods can be stubbed by attaching a delegate to an instance of the stub class. The name of the stub type is derived from the names of the method and parameters. For example, given the following IMyInterface interface and method MyMethod:
We attach a stub to MyMethod that always returns 1:
If you do not provide a stub for a function, Fakes generates a function that returns the default value of the return type. For numbers, the default value is 0 and for class types it is null (C#) or Nothing (Visual Basic).
Sealed Unit Parts Driver Parts
Properties
Property getters and setters are exposed as separate delegates and can be stubbed separately. For example, consider the Value property of IMyInterface:
We attach delegates to the getter and setter of Value to simulate an auto-property:
If you do not provide stub methods for either the setter or the getter of a property, Fakes generates a stub that stores values so that the stub property works like a simple variable.
Events
Events are exposed as delegate fields. As a result, any stubbed event can be raised simply by invoking the event backing field. Let's consider the following interface to stub:
To raise the Changed event, we simply invoke the backing delegate:
Generic methods
It's possible to stub generic methods by providing a delegate for each desired instantiation of the method. For example, given the following interface containing a generic method:
You could write a test that stubs the GetValue<int> instantiation:
If the code were to call GetValue<T> with any other instantiation, the stub would simply call the behavior.
Sealed Unit Parts Driver Manual
Stubs of virtual classes
In the previous examples, the stubs have been generated from interfaces. You can also generate stubs from a class that has virtual or abstract members. For example:
In the stub generated from this class, you can set delegate methods for DoAbstract() and DoVirtual(), but not DoConcrete().
Sealed Unit Parts Driver Hp
If you do not provide a delegate for a virtual method, Fakes can either provide the default behavior, or it can call the method in the base class. To have the base method called, set the CallBase property:
Debug stubs
The stub types are designed to provide a smooth debugging experience. By default, the debugger is instructed to step over any generated code, so it should step directly into the custom member implementations that were attached to the stub.
Stub limitations
Method signatures with pointers aren't supported.
Sealed classes or static methods can't be stubbed because stub types rely on virtual method dispatch. For such cases, use shim types as described in Use shims to isolate your application from other assemblies for unit testing
Change the default behavior of stubs
Each generated stub type holds an instance of the IStubBehavior interface (through the IStub.InstanceBehavior property). The behavior is called whenever a client calls a member with no attached custom delegate. If the behavior has not been set, it uses the instance returned by the StubsBehaviors.Current property. By default, this property returns a behavior that throws a NotImplementedException exception.
The behavior can be changed at any time by setting the InstanceBehavior property on any stub instance. For example, the following snippet changes a behavior that does nothing or returns the default value of the return type: default(T):
The behavior can also be changed globally for all stub objects for which the behavior has not been set by setting the StubsBehaviors.Current property:
See also