CODEWITHSUNDEEP
c#unit-testingvisual-studio-2012mockingmoq
Todd Sprang
Todd Sprang

Reputation: 2919

Visual Studio 2012 Fakes - How do I verify a method was called?

Coming from using Moq, I'm used to being able to Setup mocks as Verifiable. As you know, this is handy when you want to ensure your code under test actually called a method on a dependency.

e.g. in Moq:

// Set up the Moq mock to be verified
mockDependency.Setup(x => x.SomethingImportantToKnow()).Verifiable("Darn, this did not get called.");
target = new ClassUnderTest(mockDependency);
// Act on the object under test, using the mock dependency
target.DoThingsThatShouldUseTheDependency();
// Verify the mock was called.
mockDependency.Verify();

I've been using VS2012's "Fakes Framework" (for lack of knowing a better name for it), which is quite slick and I'm starting to prefer it to Moq, as it seems a bit more expressive and makes Shims easy. However, I can't figure out how to reproduce behavior similar to Moq's Verifiable/Verify implementation. I found the InstanceObserver property on the Stubs, which sounds like it might be what I want, but there's no documentation as of 9/4/12, and I'm not clear how to use it, if it's even the right thing.

Can anyone point me in the right direction on doing something like Moq Verifiable/Verify with VS2012's Fakes?

-- 9/5/12 Edit --
I realized a solution to the problem, but I'd still like to know if there's a built-in way to do it with VS2012 Fakes. I'll leave this open a little while for someone to claim if they can. Here's the basic idea I have (apologies if it doesn't compile).

[TestClass]
public class ClassUnderTestTests
{
    private class Arrangements
    {
        public ClassUnderTest Target;
        public bool SomethingImportantToKnowWasCalled = false;  // Create a flag!
        public Arrangements()
        {
            var mockDependency = new Fakes.StubIDependency  // Fakes sweetness.
            {
                SomethingImportantToKnow = () => { SomethingImportantToKnowWasCalled = true; }  // Set the flag!
            }
            Target = new ClassUnderTest(mockDependency);
        }
    }

    [TestMethod]
    public void DoThingThatShouldUseTheDependency_Condition_Result()
    {
        // arrange
        var arrangements = new Arrangements();
        // act
        arrangements.Target.DoThingThatShouldUseTheDependency();
        // assert
        Assert.IsTrue(arrangements.SomethingImportantToKnowWasCalled);  // Voila!
    }
}

-- 9/5/12 End edit --

Upvotes: 7

Views: 4565

Answers (2)

Todd Sprang
Todd Sprang

Reputation: 2919

Since I've heard no better solutions, I'm calling the edits from 9/5/12 the best approach for now.

EDIT Found the magic article that describes best practices. http://www.peterprovost.org/blog/2012/11/29/visual-studio-2012-fakes-part-3/

Upvotes: 4

Oleg Sych
Oleg Sych

Reputation: 6568

Although it might make sense in complex scenarios, you don't have to use a separate (Arrangements) class to store information about methods being called. Here is a simpler way of verifying that a method was called with Fakes, which stores the information in a local variable instead of a field of a separate class. Like your example it implies that ClassUnderTest calls a method of the IDependency interface.

[TestMethod]
public void DoThingThatShouldUseTheDependency_Condition_Result()
{
    // arrange
    bool dependencyCalled = false;
    var dependency = new Fakes.StubIDependency()
    {
        DoStuff = () => dependencyCalled = true;
    }
    var target = new ClassUnderTest(dependency);

    // act
    target.DoStuff();

    // assert
    Assert.IsTrue(dependencyCalled);
}

Upvotes: 2

Related Questions