2

我有一个像这样的抽象工厂。

public abstract class AbstractFactory
{
    public abstract ISyncService GetSyncService(EntityType entityType);
}

我有这样的具体实现。

public class SyncFactory : AbstractFactory
{
    private readonly IOperatorRepository _operatorRepository;

    public SyncFactory( IOperatorRepository operatorRepository)
    {
        _operatorRepository = operatorRepository;
    }

    public override ISyncService GetSyncService(EntityType entityType)
    {            
            return new OperatorSyncService(_operatorRepository);           
    }
}

这个具体工厂是通过这样的方法访问的。

public void MethodTobeTested()
{
    var syncService =
                new SyncFactory(_operatorRepository).GetSyncService(entityType);
}

现在我需要为 MethodTobeTested() 编写一个单元测试。

我像这样嘲笑 GetSyncService() 的返回值。但它调用的是实际的 OperatorSyncService，而不是 mock。我需要这个模拟来模拟 OperatorSyncService 中的另一个方法

private Mock<SyncFactory> _syncServiceMock;
_syncServiceMock = new Mock<SyncFactory>();

_syncServiceMock.Setup(m => m.GetSyncService(operator)).Returns(_operatorSyncServiceMock.Object);

关于如何解决这个问题的任何想法？

4

3 回答 3

2

在您的 SyncFactory 实现中，您注入 IOperatorRepository 的一个实例。这很棒，因为它允许您在需要时注入不同的版本，并为您创建一个使用 IOperatorRepository 的模拟实现的外观。

您还创建了一个看起来不错的抽象工厂，但看起来问题在于您对工厂的使用；

var syncService =
            new SyncFactory(_operatorRepository).GetSyncService(entityType);

在您的 MethodToBeTested 中，您创建了 SyncFactory 的具体实现，这使得抽象工厂的点有点多余，因为您无法注入不同的实现。我不知道您从哪里获取 _operatorRepository 实例，但我可以看到两种前进方式。

  1. 在包含 MethodToBeTested 的类的构造函数中添加一个参数，该参数采用您的抽象工厂的实例，然后让您的 MethodToBeTested 使用这个注入的工厂而不是创建一个新工厂，这将允许您模拟整个工厂 - 这是我的推荐的方法，因为包含 MethodToBeTested 的类将不再需要知道如何创建工厂实例，如果您遵循单一责任原则，它不应该知道。将不依赖于任何具体的实施。

  2. 如上所述，而是注入 IOperatorRepository 而不是工厂，然后您可以注入一个模拟 IOperatorRepository 但我建议您不要这样做，因为您在创建所有抽象方面做得很好，然后将这项工作搁置一旁并“新建”一个syncFactory 的实例并创建一个具体的依赖项

于 2016-10-12T09:41:25.580 回答
1

MethodToBeTested紧密耦合，SyncFactory因为该方法是手动创建SyncFactory. 这使得模拟依赖非常困难。

假设

public class ClassToBeTested {

    public void MethodTobeTested() {
        var syncService = new SyncFactory(_operatorRepository).GetSyncService(entityType);
        //...other code
    }

}

ClassToBeTested应该重构为

public class ClassToBeTested {
    private readonly AbstractFactory syncFactory;

    public ClassToBeTested (AbstractFactory factory) {
        this.syncFactory = factory
    }

    public void MethodTobeTested() {
        var syncService = syncFactory.GetSyncService(entityType);
        //...other code
    }

}

这将允许依赖项被模拟并注入到要测试的类中，并由要测试的方法访问。现在要测试的类只需要知道它需要知道什么。它现在不再需要注意了IOperatorRepository。

于 2016-10-12T10:45:21.320 回答
0

new方法中的创建MethodTobeTested新实例，因此不能注入模拟。注入工厂，例如作为参数，以便在测试中对其进行模拟。

public void MethodTobeTested(AbstractFactory factory)
{
    EntityType entityType = null;
    var syncService = factory.GetSyncService(entityType);
}

[TestMethod]
public void Method_Condition_Result()
{
    // Arrange
    TestedClass tested = new TestedClass();
    Mock<ISyncService> syncServiceMock = new Mock<ISyncService>();
    Mock<AbstractFactory> factoryMock = new Mock<AbstractFactory>();
    factoryMock.Setup(f => f.GetSyncService(It.IsAny<EntityType>())).Returns(syncServiceMock.Object);

    // Act
    tested.MethodTobeTested(factoryMock.Object);

    // Assert
    // ...
}
于 2016-10-12T10:02:06.087 回答