Need help to understand Moq better

Question

I've been looking at the Moq documentation and the comments are too short for me to understand each of things it can do.

The first thing I don't get is It.IsAny<string>(). //example using string

Is there an advantage of using this over just putting some value in? I know people say to use this if you don't care about the value, but if you don't care about the value can't you just do "a" or something? This just seems like more typing.

Secondly, when would be an example be of when you would not care about the value? I thought Moq needs the value to match up stuff.

I don't get what It.Is<> is for at all or how to use it. I don't understand the example and what it is trying to show.

Next, I don't get when to use Times (and its AtMost methods and similar). Why would you limit the number of times something is set up? I have some AppConfig value that I need to use twice. Why would I want to limit it to, say, once? This would just make the test fail. Is this to stop other people from adding another one to your code or something?

I don't get how to use mock.SetupAllProperties(); What does it set up the properties with?

I don't also get why there are so many different ways to set up a property and what their differences are. The documentation has:

SetupGet(of property)
SetupGet<TProperty>

I noticed that a lot of the stuff in Moq shows () and <> - what's the difference between them and what would they look like in use?

I also don't get why they have SetupGet. Would you not use SetupSet to set a property? SetupSet has five different ways to use it in the documentation. Plus another one called SetupProperty. So I don't understand why there are so many.

On a side note, I am wondering if variables used in lambdas are independent of other lambdas. E.g.:

mock.setup(m => m.Test);
stop.setup(m => m.Test);

Would this be ok or would there be some conflict between the variable m?

Finally, I was watching this video and I am wondering if it shows Visual Studio. His Intellisense looks different. A lightbulb pops up for him (I am happy mine does not, as it brings back painful memories of netbeans), and there are lines going from one opening brace to the closing brace and etc.

John Foster John Foster · Accepted Answer · 2009-07-03T20:47:04

It.IsAny / It.Is

These can be useful when you're passing a new reference type within the code under test. For instance, if you had a method along the lines of:

public void CreatePerson(string name, int age) {
    Person person = new Person(name, age);
    _personRepository.Add(person);
}

You might want to check the add method has been called on the repository,

[Test]
public void Create_Person_Calls_Add_On_Repository () {
    Mock<IPersonRepository> mockRepository = new Mock<IPersonRepository>();
    PersonManager manager = new PersonManager(mockRepository.Object);
    manager.CreatePerson("Bob", 12);
    mockRepository.Verify(p => p.Add(It.IsAny<Person>()));
}

If you wanted to make this test more explicit you can use It.Is by supplying a predicate the person object must match,

[Test]
public void Create_Person_Calls_Add_On_Repository () {
    Mock<IPersonRepository> mockRepository = new Mock<IPersonRepository>();
    PersonManager manager = new PersonManager(mockRepository.Object);
    manager.CreatePerson("Bob", 12);
    mockRepository.Verify(pr => pr.Add(It.Is<Person>(p => p.Age == 12)));
}

This way the test will through an exception if the person object that was used to call the add method didn't have the age property set to 12.

Times

If you had a method along the lines of:-

public void PayPensionContribution(Person person) {
    if (person.Age > 65 || person.Age < 18) return;
    //Do some complex logic
    _pensionService.Pay(500M);
}

One of the things that you might want to test is that the pay method does not get called when a person aged over 65 is passed into the method

[Test]
public void Someone_over_65_does_not_pay_a_pension_contribution() {
    Mock<IPensionService> mockPensionService = new Mock<IPensionService>();
    Person p = new Person("test", 66);
    PensionCalculator calc = new PensionCalculator(mockPensionService.Object);
    calc.PayPensionContribution(p);
    mockPensionService.Verify(ps => ps.Pay(It.IsAny<decimal>()), Times.Never());
}

Similarly, it's possible to imagine situations where you're iterating over a collection and calling a method for each item in the collection and you'd like to make sure that it's been called a certain amount of times, other times you simply don't care.

SetupGet / SetupSet

What you need to be aware of with these guys is that they reflect how your code is interacting with the mock rather than how you're setting up the mock

public static void SetAuditProperties(IAuditable auditable) {
    auditable.ModifiedBy = Thread.CurrentPrincipal.Identity.Name;
}

In this case, the code is setting the ModifiedBy property of the IAuditable instance while it's getting the Name property of the current instance of IPrincipal,

[Test]
public void Accesses_Name_Of_Current_Principal_When_Setting_ModifiedBy() {
    Mock<IPrincipal> mockPrincipal = new Mock<IPrincipal>();
    Mock<IAuditable> mockAuditable = new Mock<IAuditable>();

    mockPrincipal.SetupGet(p => p.Identity.Name).Returns("test");

    Thread.CurrentPrincipal = mockPrincipal.Object;
    AuditManager.SetAuditProperties(mockAuditable.Object);

    mockPrincipal.VerifyGet(p => p.Identity.Name);
    mockAuditable.VerifySet(a => a.ModifiedBy = "test");
}

In this case, we're setting up the name property on the mock of IPrincipal so it returns "test" when the getter is called on the Name property of Identity we're not setting the property itself.

SetupProperty / SetupAllProperties

Looking at the test above if it was changed to read

[Test]
public void Accesses_Name_Of_Current_Principal_When_Setting_ModifiedBy() {
    Mock<IPrincipal> mockPrincipal = new Mock<IPrincipal>();
    Mock<IAuditable> mockAuditable = new Mock<IAuditable>();
    mockPrincipal.SetupGet(p => p.Identity.Name).Returns("test");

    var auditable = mockAuditable.Object;

    Thread.CurrentPrincipal = mockPrincipal.Object;
    AuditManager.SetAuditProperties(auditable);

    Assert.AreEqual("test", auditable.ModifiedBy);
}

The test would fail. This is because the proxy created by Moq doesn't actually do anything in the set method of a property unless you tell it to. In effect, the mock object looks a bit like this

public class AuditableMock : IAuditable {
     public string ModifiedBy { get { return null; } set { } }

}

To get the test to pass you have to tell Moq to set up the property to have the standard property behavior. You can do this by calling SetupProperty and the mock will look more like

public class AuditableMock : IAuditable {
     public string ModifiedBy { get; set; }
}

and the test above would pass as the value "test" would now get stored against the mock. When mocking complex objects you might want to do this for all properties, hence the SetupAllProperties shortcut

Finally, the lightbulb in the IDE is the ReSharper plugin.