Moq单元测试C＃类库项目的最佳方法

Question

SalaryManager class has a method named DoCalculation, which calls a GetSum method which is implemented using the factory pattern. The DoCalculation method also does some other operation other than calling the GetSum method. I want to unit test the DoCalculation method by mocking the call to GetSum(). Can some one suggest the best way to implement it in Moq mocking. Below is the sample code,

interface ICalc
{
int GetSum(int a, int b);
}

    class NormalCalc : ICalc
    {
        public int GetSum(int a,int b)
        {
            return a + b;
        }
    }
    class SumFactory
    {
        public static ICalc GetSumObject(int option)
        {
            if (option == 1)
                return new NormalCalc();
            return null;
        }
    }
    class SalaryManager
    {
        private static ICalc CalcRef = SumFactory.GetSumObject(1);

        public int DoCalculation(int a, int b)
        {
            int Sum=CalcRef.GetSum(a, b);
            //Perform some other operation
            //
            //
        }
    }

Answer 1

Don't use static factory method. Convert factory class into inject-able service/interface and inject it into system under test.

public interface ISumFactory {
    ICalc GetSumObject(int option);
}

public class SumFactory : ISumFactory {
    public  ICalc GetSumObject(int option) {
        if (option == 1)
            return new NormalCalc();
        return null;
    }
}
public class SalaryManager {
    private ICalc CalcRef;
    public SalaryManager(ISumFactory factory) {
        CalcRef = factory.GetSumObject(1);
    }

    public int DoCalculation(int a, int b) {
        int Sum = CalcRef.GetSum(a, b);
        //Perform some other operation
        //
        //
        //...;
    }
}

Then mock the dependencies for test and verify expectations.

[TestClass]
public class MyTestClass {
    [TestMethod]
    public void MyTestMethod() {
        //Arrange
        var calcMock = new Mock<ICalc>();
        calcMock.Setup(m => m.GetSum(It.IsAny<int>(), It.IsAny<int>()))
            .Returns((int a, int b) => a + b)
            .Verifiable();

        var factoryMock = new Mock<ISumFactory>();
        factoryMock.Setup(m => m.GetSumObject(1)).Returns(calcMock.Object)
        .Verifiable();

        var sut = new SalaryManager(factoryMock.Object);

        //Act
        var result = sut.DoCalculation(1, 1);

        //Assert
        //...
        factoryMock.Verify();
        calcMock.Verify();
    }
}

Answer 2

In order to mock the GetSum method you will need to inject ICalc dependency to SalaryManager class somehow.

Although SalaryManager creates ICalc using a factory and does not by itself it isn't good enough, the factory method itself is static method that returns a concrete class and you can't change it to return mocked class instead becuase it is a static method, hence according to this design even your unit tests will have to use NormalCalc as Icalc implementation.

You have basically 2 options:

1. Inject ICalc directly to SalaryManager via it's constructor:

    public class SalaryManager { private readonly ICalc _calc; public SalaryManager(ICalc clac) { _calc = calc; } public int DoCalculation(int a, int b) { int Sum = _calc.GetSum(a, b); //... } } 

   Now it is easy to inject a mocked instance of ICalc to your class, just create the a mock of ICalc using moq and pass it to the calss via the constructor.

2. Anotehr option if you still want to use a factory(which seems pretty useless in your case according to what it does, as a side note I tend to use factories while working with DI only when the class depends on an IDisposable object that I don't want to keep alive for the class's entire life time) is to change it from static method to a concrete factory that will implememnt an interface :

    public interface ISumFactory { ICalc GetCalc(int option); } public SumFactory : ISumFactory { public ICalc GetCalc(int option) { if (option == 1) return new NormalCalc(); return null; } } 

   Now you should inject the factory interafce to SalaryManager class via it's constructor and use it when you need it:

    public class SalaryManager { private readonly ICalcFacotry _calcFactory; public SalaryManager(ICalcFacotry clacFacotry) { _calcFactory = clacFacotry; } public int DoCalculation(int a, int b) { ICalc calc = _calcFactory.GetCalc(1); int Sum = calc.GetSum(a, b); //... } } 

   Now in your unit test you can create ICalcFacotry mock and pass it to your class, you should setup the mocked facotry to return an ICalc mock when using the facotry method with 1 as the option.

Answer 3

You can unit test this method without changing your source code.
By using Typmock Isolator you will be able to mock a future instance of a class before it's even created so when you mock a future instance of Iclac it will mock all the classes that implements this interface.

for example:

[TestMethod]
public void TestMethod()
{
    //mock the future instances of Iclac 
    //and when the next NormalClac will be created it will be mocked as well
    var fakeIclac = Isolate.Fake.NextInstance<ICalc>();

    //setting the behavior of GetSum
    Isolate.WhenCalled(() => fakeIclac.GetSum(0, 0)).WillReturn(5);

    var result = new SalaryManager().DoCalculation(0, 0);

    Assert.AreEqual(5, result);
}