如何使用私有设置器将模拟接口分配给属性以进行单元测试？

Question

[InheritedExport(typeof(MyAbstractClass))
public abstract class MyAbstractClass
{
    [Import] protected IFoo Foo { get; private set; }
}

public sealed class MyClass : MyAbstractClass
{
    public void DoSomething()
    {
        if (Foo == null) throw new Exception();

        var = Foo.GetBar();
        //etc.
    }
}

基本上，我使用 MEF 导出类并获取“通用”导入。当我想测试这些类时，我可以创建 IFoo 的模拟接口，但是如何使用私有设置器将其真正放入其中？ MEF 以某种方式能够处理它，并且我不确定我还可以如何测试我的 DoSomething 方法。

Answer 1

如果您想保留 MEF 导入，最简单的方法是在每个属性上使用 ImportingConstructorAttribute 而不是 ImportAttribute。

[InheritedExport(typeof(MyAbstractClass))
public abstract class MyAbstractClass
{
    [ImportingConstructor]
    protected MyAbstractClass(IFoo foo)
    {
        //BONUS! Null check here instead...
        if (foo == null) throw new NullArgumentException("foo");

        Foo = foo;
    }

    protected IFoo Foo { get; private set; }
}

public sealed MyClass : MyAbstractClass
{
    [ImportingConstructor]
    public MyClass(IFoo foo) : base(foo) { }

public void DoSomething()
{
    var = Foo.GetBar();
    //etc.
}

。

该解决方案有点糟糕，因为现在您必须让从 MyAbstractClass 扩展的所有类都使用 ImportingConstructorAttribute 并调用 base() 如果您的抽象类被全部使用，特别是如果它决定添加另一个导入的属性，这可能会变得非常难看……现在您必须更改构造函数签名。

我会坚持使用丑陋的反射......丑陋的单元测试比丑陋的代码更好。

Answer 2

我相信您可以使用 MS Moles 框架来完成此任务：

http://research.microsoft。 com/en-us/projects/moles/

Answer 3

我认为唯一的方法是使用反射。

Answer 4

MyAbstractClass 依赖于 IFoo，但您没有将其明确化。您应该添加一个构造函数以使依赖关系明确：

public MyAbstractClass(IFoo foo) { this.Foo = foo; }

现在您可以使用模拟轻松测试它。

所以，我会像这样重写你的类：

[InheritedExport(typeof(MyAbstractClass))
public abstract class MyAbstractClass {
    private readonly IFoo foo;
    public IFoo Foo {
        get {
            Contract.Ensures(Contract.Result<IFoo>() != null);  
            return this.foo;
        }
    }

    protected MyAbstractClass(IFoo foo) {
        Contract.Requires(foo != null);
        this.foo = foo;
    }
}

public class MyClass : MyAbstractClass
{
    [ImportingConstructor]
    public MyClass(IFoo foo) : base(foo) { }
}

否则，你必须使用反射来获取私有设置器。太恶心了。

Answer 5

反思是最好的方法。我喜欢在基本测试程序集中创建一个扩展方法，该方法具有有用的功能，例如访问/设置私有成员等。

另一种选择（如果可以接受将设置器设置为受保护而不是私有 - 这里可能是也可能不是这种情况，但如果您确实有一个具有类似愿望的受保护成员）将使您的测试子类化被测试的类。它感觉很脏，似乎不是一个好主意，但我想不出它为什么不好并且可以实现这里目标的实际原因。

public static class ReflectionExtensions
{
    public static T GetPrivateFieldValue<T>(this object instance, string fieldName)
    {
        var field = instance.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
        if (field != null)
        {
            return (T) field.GetValue(instance);
        }
        throw new ArgumentException("The field specified could not be located.", "fieldName");
    }

    public static void SetReadonlyProperty(this object instance, string propertyName, object value)
    {
        instance.GetType().GetProperty(propertyName).SetValue(instance, value, null);
    }

    public static void SetStaticReadonlyProperty(this Type type, string propertyName, object value)
    {
        type.GetProperty(propertyName).GetSetMethod(true).Invoke(null, new[] { value });
    }
}

Answer 6

尝试在构造函数中传递它：

class MyClass : MyAbstractClass
{
    public MyClass (IFoo foo)
    {
        Foo = foo;
    }
}

并将抽象类中的“私有集”更改为“受保护集”。