In the following example you will see how you can specify the behavior of the static constructor when the target type is mocked. The first thing you need to do is to set up the target type for mocking all static calls. You do this using one of the following calls to the Mock.SetupStatic method.

C#	Copy
void Mock.SetupStatic( Type staticType ); void Mock.SetupStatic( Type targetType, Behavior behavior ); void Mock.SetupStatic( Type staticType, StaticConstructor staticConstructor ); void Mock.SetupStatic( Type targetType, Behavior behavior, StaticConstructor staticConstructor );

As you can see you have a number of choices. You always have to provide the type of the target class you want to set up for mocking. You can also specify the behavior of the mock. The default behavior is Behavior.Loose.

The StaticConstructor parameter defines the default behavior of the static constructor. You can choose from the following values:

• NonMocked
• Mocked

Let's see a complete example using the class Foo from the sample code in the beginning.

• C#
• VB

CopyC#

[TestMethod]
public void ShouldArrangeStaticFunction()
{
    // Arrange
    Mock.SetupStatic(typeof(Foo), StaticConstructor.Mocked);
    int expected = 0;

    Mock.Arrange(() => Foo.FooProp).Returns(0);

    // Assert
    Assert.AreEqual(expected, Foo.FooProp);  
}

CopyVB

<TestMethod()>
Public Sub ShouldArrangeStaticFunction()
    ' Arrange
    Mock.SetupStatic(GetType(Foo), StaticConstructor.Mocked)
    Dim expected As Integer = 0

    Mock.Arrange(Function() Foo.FooProp).Returns(0)

    ' Assert            
    Assert.AreEqual(expected, Foo.FooProp)
End Sub

Here we have set up the static constructor mock of the target type Foo. Using the StaticConstructor parameter in the call to SetupStatic we have specified that we want to mock the call to the static constructor and therefore the call to the Foo.FooProp will not throw a NotImplementedException.

Let's start with the simplest example, namely how to mock the static Submit method. First, we need to call the following:

C#	Copy
Mock.SetupStatic(typeof(Foo), StaticConstructor.Mocked);

Visual Basic	Copy
Mock.SetupStatic(GetType(Foo), StaticConstructor.Mocked)

This call setups the Foo type for static mocking and prepares all the static methods as mockable.

This is actually the only difference between static and instance mocking. From now on you continue as if you are mocking instance methods.

Let's act.

C#	Copy
Foo.Submit();

Visual Basic	Copy
Foo.Submit()

In the Submit method implementation we throw an exception, but as we mocked the Foo class that exception should not be thrown. Finally, we can assert that the method was actually called.

C#	Copy
Mock.Assert(() => Foo.Submit());

Visual Basic	Copy
Mock.Assert(Sub() Foo.Submit())

With Mock.SetupStatic(typeof(Foo), StaticConstructor.Mocked); we setup that all static methods from this class will me mocked. In certain cases you'd need to mock only methods that are setup with Mock.Arrange. To achieve this you need to set the Behavior to Strict in the Mock.SetupStatic call.

• C#
• VB

CopyC#

[TestMethod]
[ExpectedException(typeof(MockException))]
public void ShouldThrowWhenNotArranged()
{
    //Arrange
    Mock.SetupStatic(typeof(Foo), Behavior.Strict, StaticConstructor.Mocked);

    Mock.Arrange(() => Foo.Execute(10)).Returns(10);

    //Assert
    Assert.AreEqual(10, Foo.Execute(10));

    // Act
    // throws MockException as there is no arrange associated with the Submit method
    Foo.Submit();
}

CopyVB

<TestMethod()>
<ExpectedException(GetType(MockException))>
Public Sub ShouldThrowWhenNotArranged()
    ' Arrange
    Mock.SetupStatic(GetType(Foo), Behavior.Strict, StaticConstructor.Mocked)

    Mock.Arrange(Function() Foo.Execute(10)).Returns(10)

    ' Assert
    Assert.AreEqual(10, Foo.Execute(10))

    ' Act
    ' Throws MockException as there is no arrange associated with the Submit method.
    Foo.Submit()
End Sub

Once we set the Behavior to Strict, only calls setup through arrange are mocked. Other calls will throw a MockException.

Follows an example of mocking static method in F#:

F#	Copy
[<Test()>] member this.ShouldMockStaticCall() = Mock.SetupStatic<Foo>() Mock.Arrange(fun ignore -> Foo.EchoStatic()).Returns(1); Assert.AreEqual(1, Foo.EchoStatic())

The static EchoStatic method is arranged to return 1.

You can also set up a static property get:

• C#
• VB

CopyC#

[TestMethod]
public void ShouldFakeStaticPropertyGet()
{
    // Arrange
    Mock.SetupStatic(typeof(Foo), Behavior.Strict, StaticConstructor.Mocked);

    bool called = false;

    Mock.Arrange(() => Foo.FooProp).DoInstead(() => { called = true; }).Returns(1);

    // Assert
    Assert.AreEqual(Foo.FooProp, 1);
    Assert.IsTrue(called);
}

CopyVB

<TestMethod()>
Public Sub ShouldFakeStaticPropertyGet()
    ' Arrange
    Mock.SetupStatic(GetType(Foo), Behavior.Strict, StaticConstructor.Mocked)

    Dim called As Boolean = False

    Mock.Arrange(Function() Foo.FooProp).DoInstead(Sub() called = True).Returns(1)

    ' Act
    Assert.AreEqual(Foo.FooProp, 1)
    Assert.IsTrue(called)
End Sub

We replace the actual implementation of Foo.FooProp with called = true; and return 1. After acting we verify that the method was actually called with return value 1.

Now, let's mock a static property set. In the example below, we arrange the Foo.FooProp property. We use DoInstead to set a local boolean variable to true once it is assigned 10. After that, we verify that what we have expected actually happened in our test.

• C#
• VB

CopyC#

[TestMethod]
public void ShouldFakeStaticPropertySet()
{
    // Arrange
    Mock.SetupStatic(typeof(Foo), Behavior.Strict, StaticConstructor.Mocked);

    bool called = false;

    Mock.ArrangeSet(() => { Foo.FooProp = 10; }).DoInstead(() => { called = true; });

    // Act - this line should not throw any mockexception.
    Foo.FooProp = 10;

    // Assert
    Assert.IsTrue(called);
}

CopyVB

<TestMethod()>
Public Sub ShouldFakeStaticPropertySet()
    ' Arrange
    Mock.SetupStatic(GetType(Foo), Behavior.Strict, StaticConstructor.Mocked)

    Dim called As Boolean = False

    Mock.ArrangeSet(Sub() Foo.FooProp = 10).DoInstead(Sub() called = True)

    ' Act - this line should not throw any mockexception.
    Foo.FooProp = 10

    ' Assert
    Assert.IsTrue(called)
End Sub

Go to Mock Properties topic to learn more about mocking properties.

Going further, you can mock internal methods like in the following example.

• C#
• VB

CopyC#

[TestMethod]
public void ShouldFakeInternalStaticCall()
{
    // Arrange
    Mock.SetupStatic<FooInternal>();

    // Act
    FooInternal.DoIt();
}

CopyVB

<TestMethod()>
Public Sub ShouldFakeInternalStaticCall()
    ' Arrange
    Mock.SetupStatic(Of FooInternal)()

    ' Act
    FooInternal.DoIt()
End Sub

Here, calling FooInternal.DoIt should not throw an exeption as you are allowed to setup static internal methods.

In the demonstrated examples, the class itself that we mock is a non static class - only the methods are static. To mock a static class you need to use the non generic version of the Mock.SetupStatic method, i.e.

• C#
• VB

CopyC#

[TestMethod]
public void ShouldMockStaticClass()
{
    // Arrange
    Mock.SetupStatic(typeof(FooStatic));

    // Act - doesn't throw MockException
    FooStatic.Do();
}

CopyVB

<TestMethod()>
Public Sub ShouldMockStaticClass()
    ' Arrange
    Mock.SetupStatic(GetType(FooStatic))

    ' Act - doesn't throw MockException
    FooStatic.[Do]()
End Sub

An extension method is a new language feature of C# starting with the 3.0 specifications, as well as Visual Basic.NET starting with 9.0. Extension methods enable you to "add" methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type. Extension methods are a special kind of static methods, but they are called as if they were instance methods on the extended type.

Mocking extension method is similar to mocking any instance methods. The only difference is that we don’t need Mock.Create<T>() call to initialize the class for mocking as extension mocking is by default partial.

Let's see an example of how to mock extension methods. Consider the following class:

• C#
• VB

CopyC#

public class Bar
{
    public void Execute()
    {
        throw new NotImplementedException();
    }
}

CopyVB

Public Class Bar
    Public Sub Execute()
        Throw New NotImplementedException()
    End Sub
End Class

And a class that contains extension methods for the Foo class:

• C#
• VB

CopyC#

public static class BarExtensions
{
    public static int Echo(this Bar foo, int arg)
    {
        return default(int);
    }
}

CopyVB

Public Module BarExtensions
    <System.Runtime.CompilerServices.Extension()>
    Public Function Echo(foo As Bar, arg As Integer) As Integer
        Return 0
    End Function
End Module

Let's mock the Echo extension method.

• C#
• VB

CopyC#

[TestMethod]
public void ShouldFakeExtensionMethod()
{
    // Arrange
    var foo = new Bar();

    Mock.Arrange(() => foo.Echo(10)).Returns(11);

    // Act
    var actual = foo.Echo(10);

    // Assert
    Assert.AreEqual(11, actual);
}

CopyVB

<TestMethod()>
Public Sub ShouldFakeExtensionMethod()
    ' Arrange
    Dim foo = New Bar()

    Mock.Arrange(Function() foo.Echo(10)).Returns(11)

    ' Act
    Dim actual = foo.Echo(10)

    ' Assert
    Assert.AreEqual(11, actual)
End Sub

First we create an instance of the Foo class. Notice that we create a standard instance of the class, not a mock instance. Then we setup the call to Echo through Arrange in the same way we do it for non static methods. Finally, we assert the return value as usual.

Other Resources