Utilisation d'IoC pour les tests unitaires

Comment un conteneur IoC peut-il être utilisé pour les tests unitaires? Est-il utile de gérer les simulations dans une énorme solution (plus de 50 projets) en utilisant l'IoC? Des expériences? Des bibliothèques C # qui fonctionnent bien pour l'utiliser dans les tests unitaires?

De manière générale, un conteneur DI ne devrait pas être nécessaire pour les tests unitaires, car les tests unitaires consistent à séparer les responsabilités.

Considérez une classe qui utilise l'injection de constructeur

public MyClass(IMyDependency dep) { }

Dans toute votre application, il se peut qu'il y ait un énorme graphique de dépendances caché derrière IMyDependency, mais dans un test unitaire, vous l'aplatissez en un seul test double .

Vous pouvez utiliser des simulations dynamiques comme Moq ou RhinoMocks pour générer le Test Double, mais ce n'est pas obligatoire.

var dep = new Mock<IMyDependency>().Object;
var sut = new MyClass(dep);

Dans certains cas, un conteneur à simulation automatique peut être agréable à avoir, mais vous n'avez pas besoin d'utiliser le même conteneur DI que celui utilisé par l'application de production.

Comment un conteneur Ioc peut-il être utilisé pour les tests unitaires?

IoC appliquera des paradigmes de programmation qui faciliteront les tests unitaires isolés (c'est-à-dire en utilisant des simulations): utilisation d'interfaces, pas de new (), pas de singletons ...

Mais utiliser le conteneur IoC pour les tests n'est pas vraiment une exigence, il fournira juste quelques installations, par exemple l'injection de simulacres, mais vous pouvez le faire manuellement.

Est-il utile de gérer les simulations dans une énorme solution (plus de 50 projets) en utilisant l'IoC?

Je ne sais pas ce que vous entendez par la gestion des simulations à l'aide d'IoC. Quoi qu'il en soit, les conteneurs IoC peuvent généralement faire plus que simplement injecter des simulations lorsqu'il s'agit de tests. Et si vous disposez d'un support IDE décent qui rend le refactoring possible, pourquoi ne pas l'utiliser?

Une expérience?

Oui, sur une solution énorme, vous avez plus que jamais besoin d'une solution non sujette aux erreurs et défavorable au refactoring (c'est-à-dire via un conteneur IoC de type sécurisé ou un bon support IDE).

J'utilise souvent un conteneur IoC dans mes tests. Certes, ce ne sont pas des "tests unitaires" au sens pur. IMO Ils sont plus BDDish et facilitent la refactorisation. Les tests sont là pour vous donner confiance pour refactoriser. Des tests mal écrits peuvent être comme verser du ciment dans votre code.

Considérer ce qui suit:

[TestFixture]
public class ImageGalleryFixture : ContainerWiredFixture
{
    [Test]
    public void Should_save_image()
    {
        container.ConfigureMockFor<IFileRepository>()
            .Setup(r => r.Create(It.IsAny<IFile>()))
            .Verifiable();

        AddToGallery(new RequestWithRealFile());

        container.VerifyMockFor<IFileRepository>();
    }

    private void AddToGallery(AddBusinessImage request)
    {
        container.Resolve<BusinessPublisher>().Consume(request);
    }
}

Il y a plusieurs choses qui se produisent lors de l'ajout d'une image à la galerie. L'image est redimensionnée, une miniature est générée et les fichiers sont stockés sur AmazonS3. En utilisant un conteneur, je peux plus facilement isoler uniquement le comportement que je veux tester, qui dans ce cas est la partie persistante.

Une extension de conteneur auto-mocking est utile lorsque vous utilisez cette technique: http://www.agileatwork.com/auto-mocking-unity-container-extension/

En utilisant des conteneurs avec la capacité de résoudre des services non enregistrés / inconnus comme SimpleInjector , DryIoc (son mien) peut renvoyer des simulations pour des interfaces non encore implémentées.

Ce qui signifie que vous pouvez commencer le développement avec une première implémentation simple et ses dépendances simulées, et les remplacer par des éléments réels au fur et à mesure de votre progression.