Basic Mocking

New to Telerik JustMock? Download free 30-day trial

Create and Arrange Mocks at the Same Time

The built-in feature for creating mocks by specific arrangement saves time when it comes to tiresome set up of arrangements. This functionality allows you to create mocks of a certain class (the system under test) and to arrange their behavior at the same time through the Mock.CreateLike method.

Using Mock.CreateLike

Let's take the following system under test for example:

Sample Setup

public interface IInstallInfo 
{ 
    List<IInstallPackage> InstallPackages { get; set; } 
} 
 
public interface IInstallPackage 
{ 
    IInstallerInfo Installer { get; set; } 
} 
 
public interface IInstallerInfo 
{ 
    string Name { get; set; } 
    DetectionInfoBase BlockingCondition { get; set; } 
} 
 
public class DetectionInfoBase 
{ 
    public string Name { get; set; } 
}

For simple tests with few arrangements, this provides only marginal benefit. The real benefit comes with complex tests with multiple arrangements, like the one demonstrated in Example 1.

Example 1: Create and Arrange with Mock.Create and Mock.Arrange

[TestMethod] 
public void TestWithALotOfArrangements() 
{ 
    var blockingCondition1 = Mock.Create<DetectionInfoBase>(); 
    Mock.Arrange(() => blockingCondition1.Name).Returns("foo"); 
 
    var installer1 = Mock.Create<IInstallerInfo>(); 
    Mock.Arrange(() => installer1.BlockingCondition).Returns(blockingCondition1); 
    Mock.Arrange(() => installer1.Name).Returns("blocked1"); 
 
    var package1 = Mock.Create<IInstallPackage>(); 
    Mock.Arrange(() => package1.Installer).Returns(installer1); 
 
    var blockingCondition2 = Mock.Create<DetectionInfoBase>(); 
    Mock.Arrange(() => blockingCondition2.Name).Returns("bar"); 
 
    var installer2 = Mock.Create<IInstallerInfo>(); 
    Mock.Arrange(() => installer2.BlockingCondition).Returns(blockingCondition2); 
    Mock.Arrange(() => installer2.Name).Returns("blocked2"); 
 
    var package2 = Mock.Create<IInstallPackage>(); 
    Mock.Arrange(() => package2.Installer).Returns(installer2); 
 
    var installInfo = Mock.Create<IInstallInfo>(); 
    Mock.Arrange(() => installInfo.InstallPackages).ReturnsCollection(new List<IInstallPackage> { package1, package2 }); 
}

To first explain the functionality in more details, let’s see Example 2 which shows how you can rewrite the above test using the capabilities provided by Mock.CreateLike.

Example 2: Using Mock.CreateLike

[TestMethod] 
public void ShouldExplainStepByStep() 
{ 
    // Create mock, whose Name property returns "blocked1". The == operator here is equivalent to calling .Returns("blocked1") while arranging inst.Name 
    Mock.CreateLike<IInstallerInfo>(inst => inst.Name == "blocked1"); 
 
    // Create inner mocks recursively and set Installer.Name to return "blocked1" 
    Mock.CreateLike<IInstallPackage>(pkg => pkg.Installer.Name == "blocked1"); 
 
    // Create inner mocks recursively and arrange several return values. The && operator is used to make a list of several arrangements. 
    Mock.CreateLike<IInstallPackage>(pkg => pkg.Installer.Name == "blocked1" && pkg.Installer.BlockingCondition.Name == "foo"); 
 
    // Arrange a property to return a list of mocks. Mock.Create can be called recursively within the expression. 
    Mock.CreateLike<IInstallInfo>(me => me.InstallPackages == new List<IInstallPackage> { Mock.Create<IInstallPackage>() });  
}

The API is even more powerful and you can define all the arrangements from the above test in a single line:

Example 3: Using Mock.CreateLike to create and arrange memebers on a single line

[TestMethod] 
public void TestShowingTheMocksByExampleUsability() 
{ 
    var installInfo = Mock.CreateLike<IInstallInfo>(me => 
            me.InstallPackages == new List<IInstallPackage> 
        { 
            Mock.CreateLike<IInstallPackage>(pkg => pkg.Installer.Name == "blocked1" 
                    && pkg.Installer.BlockingCondition.Name == "foo"), 
            Mock.CreateLike<IInstallPackage>(pkg => pkg.Installer.Name == "blocked2" 
                    && pkg.Installer.BlockingCondition.Name == "bar"), 
        }); 
}

The syntax reflects the hierarchical structure of the complex arrangement much better and makes trivial arrangements (like for the values of properties) easy.

Using Matchers with Mock.CreateLike

When creating mocks with Mock.CreateLike, you can also use argument matchers in method arguments, just like in regular Mock.Arrange() expressions.

Sample setup

public interface IEqualityComparer 
{ 
    bool Equals(object a, object b); 
}

Example 4: Mock.CreateLike with argument matchers

[TestMethod] 
public void ShouldUseMatchers() 
{ 
    // Create a mock and arrange the Equals method, when called with any arguments, to forward the call to Object.Equals with the given arguments 
    Mock.CreateLike<IEqualityComparer>(cmp => cmp.Equals(Arg.AnyObject, Arg.AnyObject) == Object.Equals(Param._1, Param._2)); 
}

You can even refer to the arguments of the method when specifying its return value, like demonstrated in Example 4. In this example, the Param._1 and Param._2 bits are placeholders for the actual arguments passed to the arranged method. In other words, the arrangement means that Object.Equals will be called instead of cmp.Equals, and the parameters of cmp.Equals will be transferred as parameters of Object.Equals.

When you need to use argument matchers and the type you need is not present in the Arg.Any~ properties, you can also use a custom type by matching it using the Arg.IsAny<T>() method.

Using CreateLike With Additional Expectation Clauses

With Mock.CreateLike you can arrange return values. If you would like to set additional expectation clauses like DoNothing, DoInstead, Occurs, etc., you should use Mock.Arrange. To show how you can do that, let’s use the setup shown below.

Sample setup

public interface IConnection 
{ 
    string Driver { get; } 
    bool Open(string parameters); 
}

For simple cases, you can create a test like the one in Example 5.

Example 5: Arrange return values

[TestMethod] 
public void SampleTest() 
{ 
    var conn = Mock.CreateLike<IConnection>(me => me.Driver == "MSSQL" && me.Open(Arg.AnyString) == true); 
    Assert.IsTrue(conn.Open(@".\SQLEXPRESS")); 
}

However, if you need to add expectations to Open(), you cannot with the above syntax. You should use Mock.Arrange to add them.

Example 6: Arrange return values and set additional expectations

[TestMethod] 
public void ShouldUseCreateLikeAlongWithStandartArrangements() 
{ 
    var conn = Mock.CreateLike<IConnection>(me => me.Driver == "MSSQL"); 
    Mock.Arrange(() => conn.Open(Arg.AnyString)).Returns(true).MustBeCalled(); 
    Assert.IsTrue(conn.Open(@".\SQLEXPRESS")); 
    Mock.Assert(conn); 
}

At any time, for any mock, you can add additional arrangements using Mock.Arrange for mock objects created with Mock.CreateLike.

In this article
Related articles
Not finding the help you need? Improve this article