AutoMockContainer与非接口依赖关系automocking类的支持

Question

我有具有非接口依赖一个构造函数：

public MainWindowViewModel(IWorkItemProvider workItemProvider, WeekNavigatorViewModel weekNavigator) 

我使用Moq.Contrib automockcontainer。如果我尝试automock MainWindowViewModel类，由于WeekNavigatorViewModel依赖关系，我得到一个错误。

是否有任何支持嘲讽非接口类型的automocking容器？

正如Mark所示：是的你可以！ :-)我用Mark在他的回答中提供的东西替换了Moq.Contrib AutoMockContainer，唯一的区别是自动生成的mock被注册为单例，但是您可以将其设置为可配置。下面是最终的解决方案：

/// <summary> 
/// Auto-mocking factory that can create an instance of the 
/// class under test and automatically inject mocks for all its dependencies. 
/// </summary> 
/// <remarks> 
/// Mocks interface and class dependencies 
/// </remarks> 
public class AutoMockContainer 
{ 
    readonly IContainer _container; 

    public AutoMockContainer(MockFactory factory) 
    { 
     var builder = new ContainerBuilder(); 

     builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource()); 
     builder.RegisterSource(new MoqRegistrationSource(factory)); 

     _container = builder.Build(); 
    } 

    /// <summary> 
    /// Gets or creates a mock for the given type, with 
    /// the default behavior specified by the factory. 
    /// </summary> 
    public Mock<T> GetMock<T>() where T : class 
    { 
     return (_container.Resolve<T>() as IMocked<T>).Mock; 
    } 

    /// <summary> 
    /// Creates an instance of a class under test, 
    /// injecting all necessary dependencies as mocks. 
    /// </summary> 
    /// <typeparam name="T">Requested object type.</typeparam> 
    public T Create<T>() where T : class 
    { 
     return _container.Resolve<T>(); 
    } 

    public T Resolve<T>() 
    { 
     return _container.Resolve<T>(); 
    } 

    /// <summary> 
    /// Registers and resolves the given service on the container. 
    /// </summary> 
    /// <typeparam name="TService">Service</typeparam> 
    /// <typeparam name="TImplementation">The implementation of the service.</typeparam> 
    public void Register<TService, TImplementation>() 
    { 
     var builder = new ContainerBuilder(); 

     builder.RegisterType<TImplementation>().As<TService>().SingleInstance(); 
     builder.Update(_container); 
    } 

    /// <summary> 
    /// Registers the given service instance on the container. 
    /// </summary> 
    /// <typeparam name="TService">Service type.</typeparam> 
    /// <param name="instance">Service instance.</param> 
    public void Register<TService>(TService instance) 
    { 
     var builder = new ContainerBuilder(); 

     if (instance.GetType().IsClass) 
      builder.RegisterInstance(instance as object).As<TService>(); 
     else 
      builder.Register(c => instance).As<TService>(); 

     builder.Update(_container); 
    } 

    class MoqRegistrationSource : IRegistrationSource 
    { 
     private readonly MockFactory _factory; 
     private readonly MethodInfo _createMethod; 

     public MoqRegistrationSource(MockFactory factory) 
     { 
      _factory = factory; 
      _createMethod = factory.GetType().GetMethod("Create", new Type[] { }); 
     } 

     public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor) 
     { 
      var swt = service as IServiceWithType; 
      if (swt == null) 
      { 
       yield break; 
      } 

      if (!swt.ServiceType.IsInterface) 
       yield break; 

      var existingReg = registrationAccessor(service); 
      if (existingReg.Any()) 
      { 
       yield break; 
      } 

      var reg = RegistrationBuilder.ForDelegate((c, p) => 
      { 
       var createMethod = _createMethod.MakeGenericMethod(swt.ServiceType); 
       return ((Mock)createMethod.Invoke(_factory, null)).Object; 
      }).As(swt.ServiceType).SingleInstance().CreateRegistration(); 

      yield return reg; 
     } 

     public bool IsAdapterForIndividualComponents 
     { 
      get { return false; } 
     } 
    } 
} 

Answer 1

您可以自己很容易地写一个，如果你利用一个DI容器支持刚刚在时间分辨率请求的类型。

我最近使用Autofac和Moq编写了一个完全用于此目的的原型，但也可以使用其他容器。

这里是适当的IRegistrationSource：

public class AutoMockingRegistrationSource : IRegistrationSource 
{ 
    private readonly MockFactory mockFactory; 

    public AutoMockingRegistrationSource() 
    { 
     this.mockFactory = new MockFactory(MockBehavior.Default); 
     this.mockFactory.CallBase = true; 
     this.mockFactory.DefaultValue = DefaultValue.Mock; 
    } 

    public MockFactory MockFactory 
    { 
     get { return this.mockFactory; } 
    } 

    #region IRegistrationSource Members 

    public IEnumerable<IComponentRegistration> RegistrationsFor(
     Service service, 
     Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor) 
    { 
     var swt = service as IServiceWithType; 
     if (swt == null) 
     { 
      yield break; 
     } 

     var existingReg = registrationAccessor(service); 
     if (existingReg.Any()) 
     { 
      yield break; 
     } 

     var reg = RegistrationBuilder.ForDelegate((c, p) => 
      { 
       var createMethod = 
        typeof(MockFactory).GetMethod("Create", Type.EmptyTypes).MakeGenericMethod(swt.ServiceType); 
       return ((Mock)createMethod.Invoke(this.MockFactory, null)).Object; 
      }).As(swt.ServiceType).CreateRegistration(); 

     yield return reg; 
    } 

    #endregion 
} 

现在，您可以设置容器的单元测试是这样的：

[TestMethod] 
public void ContainerCanCreate() 
{ 
    // Fixture setup 
    var builder = new ContainerBuilder(); 
    builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource()); 
    builder.RegisterSource(new AutoMockingRegistrationSource()); 
    var container = builder.Build(); 
    // Exercise system 
    var result = container.Resolve<MyClass>(); 
    // Verify outcome 
    Assert.IsNotNull(result); 
    // Teardown 
} 

这就是你需要开始。

MyClass是一个具有抽象依赖性的具体类。以下是构造函数签名：

public MyClass(ISomeInterface some) 

请注意，您不必在生产代码中使用Autofac（或任何其他DI容器）。