Testing That a Method is Called Twice, Asserting on 2nd Call

Hi,

In order to solve this scenario we will use sequenced calls to WhenCalled API.
You can find more information about sequencing here.

Please look at this example:

    public class Boo
    {
        public void A(string var1)
        {
        }

        public void MethodCallingA()
        {
            try
            {
                this.A(null);
            }
            catch (Exception e)
            {
                this.A("goodString");
                
            }
        }
    }

    [TestClass, Isolated]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            Boo boo  = new Boo();
            
            Isolate.WhenCalled(() => boo.A(null)).WillThrow(new Exception("first Exception"));
            Isolate.WhenCalled(() => boo.A("goodString")).WithExactArguments().CallOriginal();

            boo.MethodCallingA();

            Isolate.Verify.WasCalledWithExactArguments(() => boo.A("goodString"));

        }

   }

In the test method we set A's behavior so the first call will throw an exception, and the second call will happen only if the parameters are as expected.
The Verify checks if the second call actually happened. If the parameters in the second call was not as expected, the test will fail.

Thanks for the answer.

I see that I should have specified that this is for a non-public (private) method, so WithExactArguments can't be used.

Is there another technique that will work for non-public methods?

Hi John,

You mentioned that the method is private and we should have seen it.

In this case the solution is the same only the syntax is different:

[TestClass, Isolated]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            Boo boo = new Boo();

            Isolate.NonPublic.WhenCalled(boo, "A").WillThrow(new Exception("first Exception"));
            Isolate.NonPublic.WhenCalled(boo, "A").CallOriginal();

            boo.MethodCallingA();

            Isolate.Verify.NonPublic.WasCalled(boo, "A").WithArguments("GoodString");
        }
    }


    public class Boo
    {
        private void A(string var1)
        {
        }

        public void MethodCallingA()
        {
            try
            {
                this.A(null);
            }
            catch (Exception e)
            {
                this.A("GoodString");
            }
        }
    }

May I ask what is it that you are trying to test?
Is it A("GoodString") or is it the code that comes after that in the catch block?