Comment simuler (avec Moq) les méthodes Unity

Les méthodes d'Extension ne sont pas bonnes pour le test (c'est décrit ici: Se moquant des Méthodes d'Extension avec Moq http://www.clariusconsulting.net/blogs/kzu/archive/2009/12/22/Howtomockextensionmethods.aspx).

Mais probablement il y a des solutions pour s'être moqué de l'Unité méthodes? Dans mon cas, j'ai la fonction suivante:

public class MyManager
{
    public MyManager(IUnityContainer container) : base(container) { }

    public IResult DoJob(IData data)
    {
        IMyLog log = MyContainer.Resolve<IMyLog>();

        ... use log.Id ...

        MyContainer.Resolve<...>();//usage for other purposes...
    }

Je veux être sûr que " DoJob méthode obtiendrez toujours 'IMyLog' objet de conteneur, mais pas à partir d'autres sources... comment pourrais-je tester?

Mon idée de départ était de changer " DoJob méthode de la mise en œuvre et d'utilisation:

IMyLog log = UnityContainer.Resolve(typeof(IMyLog)) as IMyLog;

Mais " Résoudre(Type t, ...) est aussi une méthode d'extension...

Toutes les pensées sont les bienvenus.

P. S. Veuillez noter, que "mon journal' objet est créé loin de MyManager.DoJob...

source d'informationauteur Budda

Supprimer la dépendance à l'égard IUnityContainer et les choses deviennent beaucoup plus facile et plus propre. Au lieu de laisser l'unité injecter des dépendances qui sont extraites dans les interfaces. Ceux-ci sont facilement se moque. Voici un exemple en utilisant un petit truc avec l'Unité qui permet de faire un auto-usine pour IMyLog.

public class MyManager
{
   private readonly Func<IMyLog> logFactory;

   public MyManager(Func<IMyLog> logFactory) 
   {
       this.logFactory = logFactory;
   }

   public IResult DoJob(IData data)
   {
       IMyLog log = logFactory();

       ...
   }
}

Ou si vous n'avez pas besoin de créer une instance à chaque fois:

public class MyManager
{
   private readonly IMyLog myLog;

   public MyManager(IMyLog myLog) 
   {
       this.myLog = myLog;
   }

   public IResult DoJob(IData data)
   {
       ...
   }
}

Je sais je suis en retard à la fête, mais j'ai eu le même problème, résolu en se moquant de la méthode suivante -

IUnityContainer.Resolve(Type t, string name, params ResolverOverride[] resolverOverrides);

Par exemple -

unityMock = new Mock<IUnityContainer>(MockBehavior.Strict);
validatorMock = new Mock<IValidator>(MockBehavior.Strict);
unityMock.Setup(p => p.Resolve(typeof(IValidator), null))
     .Returns(validatorMock.Object);

Juste au cas où quelqu'un a besoin de se moquer de tout cela et ne pouvez pas supprimer la dépendance sur le conteneur.

Suppose, j'ai trouvé la solution plus appropriée pour le test: Il n'est pas nécessaire de se moquer de l'unité de conteneur et de vérifier si 'log' objet a été prise. Je vais juste faire une maquette pour 'Log' objet, d'enregistrer son instance de l'objet dans le conteneur et vérifier à tester si ce log l'objet est vraiment utilisé.

Cela va faire ce qui est nécessaire.

        Mock<IMyLog> mockLog = new Mock<IMyLog>();
        mockLog.Setup(mock=>mock.Id).Returns(TestLogId);

        IUnityContainer container = new UnityContainer();
        container
            .RegisterInstance(mockCommandExecutionLog.Object)
            ...
            ;

        ...

        mockLog.Verify(
            mock => mock.Id,
            Times.Once(),
            "It seems like 'Log' object is not used"
            );

Grâce.

je vais avoir à être en désaccord avec les deux réponses. TheCodeKing, il est tout à fait légitime d'utiliser Cio interface directement. Un exemple peut être un contrôleur de l'usine de ASP.NET projet - où l'on pourrait le faire non négligeable de la résolution à l'aide de plusieurs méthodes sur IUnityContainer interface.

Hmm... avec l'auto-usine d'injection de labdas, on n'a jamais de test de l'unité du Cio interface directement. Vous pouviez juste passer un lambda et vérifiez qu'elle est appelée avec les bons paramètres.

Budda, vous devriez jamais apporter dans un conteneur IoC dans votre unité de test. Les dépendances doit être injecté manuellement.

Ci-dessous est la solution que j'utilise. En gros, j'ai créé une couche d'abstraction au-dessus de IUnityContainer et mis en œuvre une classe simple que les délégués à IUnityContainer. Parce que mon interface ne contient pas de méthodes d'extension, je peux facilement s'en moquer.

public interface IDIContainer {
void RegisterType<TFrom>() where TFrom : class;
void RegisterType<TFrom, TTo>() where TTo : TFrom;
void RegisterType<TFrom, TTo>(string name) where TTo : TFrom;
void RegisterType(Type from, Type to);
void RegisterType(Type from, Type to, string name);
void RegisterInstance<TFrom>(TFrom instance) where TFrom : class;
T Resolve<T>();
T Resolve<T>(string name);
IEnumerable<T> ResolveAll<T>();
bool IsRegistered<TFrom>(string name) where TFrom : class;
bool IsRegistered<TFrom>() where TFrom : class;
}
public class DIContainer : IDIContainer {
IUnityContainer m_Container = new UnityContainer();
#region IDIContainer Members
public void RegisterType<TFrom>() where TFrom : class {
m_Container.RegisterType<TFrom>();
}
public void RegisterType<TFrom, TTo>() where TTo : TFrom {
m_Container.RegisterType<TFrom, TTo>();
}
public void RegisterType<TFrom, TTo>(string name) where TTo : TFrom {
m_Container.RegisterType<TFrom, TTo>(name);
}
public void RegisterType(Type from, Type to) {
m_Container.RegisterType(from, to);
}
public void RegisterType(Type from, Type to, string name) {
m_Container.RegisterType(from, to, name);
}
public void RegisterInstance<TFrom>(TFrom instance) where TFrom : class {
m_Container.RegisterInstance<TFrom>(instance);
}
public T Resolve<T>() {
return m_Container.Resolve<T>();
}
public IEnumerable<T> ResolveAll<T>() {
return m_Container.ResolveAll<T>();
}
public T Resolve<T>(string name) {
return m_Container.Resolve<T>(name);
}
public bool IsRegistered<TFrom>(string name) where TFrom : class {
return m_Container.IsRegistered<TFrom>(name);
}
public bool IsRegistered<TFrom>() where TFrom : class {
return m_Container.IsRegistered<TFrom>();
}
#endregion
}

Maintenant, la réécriture de votre classe à utiliser IDIContainer:

public class MyManager
{
public MyManager(IDIContainer container) : base(container) { }
public IResult DoJob(IData data)
{
IMyLog log = MyContainer.Resolve<IMyLog>();
... use log.Id ...
MyContainer.Resolve<...>();//usage for other purposes...
}
}

Et de réécrire l'unité de test comme suit:

[TestClass]
public class Test {
[TestMethod]
public void TestDoJob() {
Mock<IMyLog> mockLog = new Mock<IMyLog>();
Mock<IDIContainer> containerMock = new Mock<IDIContainer>();
//Setup mock container to return a log mock we set up earlier
containerMock.Setup(c=>c.Resolve<IMyLog>()),Returns(mockLog);
//Verify that all setups have been performed
containerMock.VerifyAll();
}
}

Vous devez vous connecter pour publier un commentaire.