使用最小起订量多次调用相同的方法并获得不同的收益

Question

I am writing a unit test case where I need to rollback the first payment when the first payment is a success and the second payment fails. The unit test code looks like the following:

1. Process first payment successfully.
2. Process second payment. External system will throw similar transaction fault exception. Parse similar transaction fault exception to get exceptionid and process second transaction again, using the exception id.
3. When the second transaction is actually processed, the system returns a "Payment declined fault exception".
4. The system should then void the first payment.

I have written the unit test for (1). How SO community have pointers on how to take care of part 2, 3, 4?

        [TestMethod]    
            public void IfTheSecondPaymentFailsThenTheFirstPaymentShouldBeVoided()
            {
//Arrange        
        var iPaymentMock = new Mock<IPaymentMock>();
                var paymentSpecificationResponse = new PreregisteredAccountSpec();    
                iPaymentMock.Setup(
                        counter => counter.ProcessPayment
                            (
                                It.IsAny<Context>(),
                                It.IsAny<PreregisteredAccountSpec>(),  
                                It.IsAny<Guid>())
                            ).
                        Returns(paymentSpecificationResponse);  
//Act
var twoPaymentProcessor = new TwoPaymentProcessor(iPaymentMock.Object);
twoPaymentProcessor.Submit();

//assert
     iPaymentMock.Verify((
                    counter => counter.ProcessPaymentSpecification
                    (
                        It.IsAny<Context>(),
                        It.IsAny<PreregisteredAccountSpec>(),  
                        It.IsAny<Guid>()
                    )
                ), Times.Once());  
            }

Answer 1

It looks like you want to use SetupSequence rather than Setup on the mock. This allows you to do something like

iPaymentMock.SetupSequence(counter => counter.ProcessPayment
    (
         It.IsAny<Context>(),
         It.IsAny<PreregisteredAccountSpec>(),  
         It.IsAny<Guid>())
    )
    .Returns(paymentSpecificationResponse)
    .Throws(new Exception());

I might have the specifics of what you're wanting wrong but SetupSequence allows you to have multiple returns on a mock, order of calls is important though.

Answer 2

I'm not too sure how one might approach the tests for 2, 3, and 4 but in answer to the general question from the title, one can get different returns from multiple invocations of a mock by using a lamba in the Returns() clause.

Say we have the following

public interface IPayment
{
    Result ProcessPayment();
}

public class Result
{

    public Result(int id)
    {
        Id = id;
    }

    public int Id { get; }
}

We can have each call to ProcessPayment() return a different value as follows

[TestMethod]
public void DifferentResultsOnEachInvocation()
{
    var results = new[] {
                    new Result(1),
                    new Result(2),
                    new Result(3)
                };

    var index = 0;

    var mockPayment = new Mock<IPayment>();
    mockPayment.Setup(mk => mk.ProcessPayment()).Returns(()=>results[index++]);

    var res = mockPayment.Object.ProcessPayment();
    Assert.AreEqual(1, res.Id);

    res = mockPayment.Object.ProcessPayment();
    Assert.AreEqual(2, res.Id);

    res = mockPayment.Object.ProcessPayment();
    Assert.AreEqual(3, res.Id);

}

If the setup simply returns results[index++] this is crystallized upon setup and each invocation returns the first element of the array. By making it a lamba, it is evaluated each time ProcessPayment() is called.