Isolation du code sous test avec Microsoft Fakes

Article
03/12/2013

Les false Microsoft vous aider à isoler le code que vous testez en remplaçant d'autres parties de l'application par des stubs ou des cales.Ce sont des petits segments de code qui sont sous le contrôle de vos tests.En isolant votre code de test, vous savez que si le test échoue, la cause est là et non ailleurs.Les stubs et les cales vous permettent également tester votre code même si d'autres parties de votre application ne fonctionnent pas encore.

Les false provenant de deux versions :

stub remplace une classe avec un petit remplaçant qui implémente la même interface.Pour utiliser des stubs, vous devez concevoir votre application de sorte que chaque composant dépend uniquement les interfaces, et non sur d'autres composants.(Par « composant » nous voulons indiquer une classe ou un groupe de classes qui sont conçues et ensemble mises à jour et en général figurant dans un assembly.)
shim modifie le code compilé de votre application au moment de l'exécution afin qu'au lieu d'effectuer un appel de méthode spécifié, il exécute le code shim que votre test fournit.Les cales peuvent être utilisées pour remplacer des appels aux assemblys que vous ne pouvez pas modifier, ces assemblys.NET.

Fakes remplace les autres composants

Configuration requise

Visual Studio Ultimate

Choisir entre le stub et les types du shim

En général, vous considèreriez un projet Visual Studio d'être un composant, car vous développez et mettre à jour ces classes en même temps.Vous envisageriez d'utiliser des stubs et des cales pour les appels que le projet fait à d'autres projets de votre solution, ou à d'autres assemblys dont les références de projet.

Comme un repère général, les stubs d'utilisation pour les appels dans votre solution Visual Studio, et cales pour les appels à d'autres assemblys référencés.En effet dans votre propre solution il est conseillé de découpler des composants en définissant des interfaces de la manière que le déracinement requiert.Mais les assemblys externes tels que System.dll généralement ne sont pas fournis avec définitions d'interface distinctes, vous devez utiliser des cales à la place.

D'autres considérations sont :

Performances. Les cales exécutent plus lent parce qu'elles réécrire votre code au moment de l'exécution.Les stubs n'ont pas cette baisse des performances et sont aussi rapidement que les méthodes virtuelles peuvent disparaître.

Méthodes statiques, types sealed. Vous pouvez uniquement utiliser des stubs pour implémenter des interfaces.Par conséquent, les types de stub ne peuvent pas être utilisés pour les méthodes statiques, non méthodes virtuelles, les méthodes virtuelles sealed, méthodes dans les types sealed, et ainsi de suite.

types internes. Des stubs et les cales peuvent être utilisés avec les types internes qui sont rendus accessibles à l'aide de l'attribut InternalsVisibleToAttributed'assembly.

Méthodes privées. Les cales peuvent remplacer les appels aux méthodes privées si tous les types dans la signature de méthode sont visibles.Les stubs qu'à substituer les méthodes visibles.

Méthodes virtuelles et abstraites Les stubs fournissent des implémentations des interfaces et des méthodes abstraites qui peuvent être utilisées dans le test.Les cales ne peuvent pas instrumenter des interfaces et des méthodes abstraites, car elles n'ont pas de corps de la méthode.

En général nous vous conseillons d'utiliser des types de stub pour isoler dans les dépendances dans votre base de code.Vous pouvez le faire en masquant les composants sous-jacents des interfaces.Les types du shim peuvent être utilisés pour isoler dans les composants tiers qui ne fournissent pas une API testable.

Mise en route avec des stubs

Injecter les interfaces

Pour utiliser des stubs, vous devez écrire le code que vous souhaitez tester de telle sorte qu'il ne mentionne pas explicitement des classes dans un autre composant de votre application.Par « composant » nous voulons indiquer une classe ou des classes qui sont développés et mis à jour ensemble, et généralement contenu dans un projet Visual Studio.Les variables et les paramètres doivent être déclarés à l'aide de les interfaces et les instances d'autres composants doivent être passées ou créées à l'aide d'une fabrique.Par exemple, si StockFeed est une classe dans un autre composant de l'application, puis il soit considéré comme le incorrect :

return (new StockFeed()).GetSharePrice("COOO"); // Bad

À la place, définissez une interface qui peut être implémentée par un autre composant, et qui peut également être implémentée par un stub pour le test :
```
public int GetContosoPrice(IStockFeed feed)
{ return feed.GetSharePrice("COOO"); }
```
```
Public Function GetContosoPrice(feed As IStockFeed) As Integer
 Return feed.GetSharePrice("COOO")
End Function
```
Ajoutez l'assembly de la valeur false
1. Dans l'explorateur de solutions, développez la liste de références du projet de test.Si vous travaillez en Visual Basic, vous devez choisir Afficher tous les fichiers pour afficher la liste des références.
2. Sélectionnez la référence à l'assembly dans lequel l'interface (par exemple IStockFeed) est définie.Dans le menu contextuel de cette référence, choisissez Ajouter un assembly Fakes.
3. Régénérez la solution.

Dans vos tests, construisez des instances avec du stub et fournissez le code pour ses méthodes :

[TestClass]
class TestStockAnalyzer
{
    [TestMethod]
    public void TestContosoStockPrice()
    {
      // Arrange:

        // Create the fake stockFeed:
        IStockFeed stockFeed = 
             new StockAnalysis.Fakes.StubIStockFeed() // Generated by Fakes.
                 {
                     // Define each method:
                     // Name is original name + parameter types:
                     GetSharePriceString = (company) => { return 1234; }
                 };

        // In the completed application, stockFeed would be a real one:
        var componentUnderTest = new StockAnalyzer(stockFeed);

      // Act:
        int actualValue = componentUnderTest.GetContosoPrice();

      // Assert:
        Assert.AreEqual(1234, actualValue);
    }
    ...
}

<TestClass()> _
Class TestStockAnalyzer

    <TestMethod()> _
    Public Sub TestContosoStockPrice()
        ' Arrange:
        ' Create the fake stockFeed:
        Dim stockFeed As New StockAnalysis.Fakes.StubIStockFeed
        With stockFeed
            .GetSharePriceString = Function(company)
                                       Return 1234
                                   End Function
        End With
        ' In the completed application, stockFeed would be a real one:
        Dim componentUnderTest As New StockAnalyzer(stockFeed)
        ' Act:
        Dim actualValue As Integer = componentUnderTest.GetContosoPrice
        ' Assert:
        Assert.AreEqual(1234, actualValue)
    End Sub
End Class

La partie particulière de magie ici est la classe StubIStockFeed.Pour chaque interface dans l'assembly référencé, le mécanisme de faux Microsoft génère une classe stub.Le nom de la classe stub est type dérivé noms du nom de l'interface, par « Fakes.Stub » comme préfixe, et de paramètre ajouté.

Des stubs sont également générés pour les accesseurs set et accesseurs Set des propriétés, des événements, et des méthodes génériques.Pour plus d'informations, consultez Utilisation de stubs pour isoler des parties de votre application les unes des autres pour des tests unitaires.

Mise en route avec des cales

Supposez que votre composant contient des appels à DateTime.Now:

// Code under test:
    public int GetTheCurrentYear()
    {
       return DateTime.Now.Year;
    }

Pendant le test, vous souhaitez caler la propriété d' Now, car la véritable version incommodément retourne une valeur différente à chaque appel.

Pour utiliser des cales, vous ne devez pas modifier le code d'application ou y écrire une façon particulière.

Ajoutez l'assembly de la valeur false

Dans l'explorateur de solutions, ouvrez les références de votre projet de test unitaire et sélectionnez la référence à l'assembly qui contient la méthode que vous souhaitez truquer.Dans cet exemple, la classe d' DateTime est dans System.dll.Pour afficher les références dans un projet Visual Basic, choisissez Afficher tous les fichiers.

Choisissez Ajouter un assembly Fakes.

Insérez une shim dans un ShimsContext

[TestClass]
public class TestClass1
{ 
        [TestMethod]
        public void TestCurrentYear()
        {
            int fixedYear = 2000;

            // Shims can be used only in a ShimsContext:
            using (ShimsContext.Create())
            {
              // Arrange:
                // Shim DateTime.Now to return a fixed date:
                System.Fakes.ShimDateTime.NowGet = 
                () =>
                { return new DateTime(fixedYear, 1, 1); };

                // Instantiate the component under test:
                var componentUnderTest = new MyComponent();

              // Act:
                int year = componentUnderTest.GetTheCurrentYear();

              // Assert: 
                // This will always be true if the component is working:
                Assert.AreEqual(fixedYear, year);
            }
        }
}

<TestClass()> _
Public Class TestClass1
    <TestMethod()> _
    Public Sub TestCurrentYear()
        Using s = Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create()
            Dim fixedYear As Integer = 2000
            ' Arrange:
            ' Detour DateTime.Now to return a fixed date:
            System.Fakes.ShimDateTime.NowGet = _
                Function() As DateTime
                    Return New DateTime(fixedYear, 1, 1)
                End Function

            ' Instantiate the component under test:
            Dim componentUnderTest = New MyComponent()
            ' Act:
            Dim year As Integer = componentUnderTest.GetTheCurrentYear
            ' Assert: 
            ' This will always be true if the component is working:
            Assert.AreEqual(fixedYear, year)
        End Using
    End Sub
End Class

Les noms de classe du shim consistent en faisant Fakes.Shim au type d'origine nom.Les noms de paramètres sont ajoutés au nom de la méthode.

L'exemple précédent utilise une shim pour une méthode statique.Pour utiliser une shim pour une méthode d'instance, l'écriture AllInstances entre le nom de type et le nom de la méthode :

System.IO.Fakes.ShimFile.AllInstances.ReadToEnd = ...

Vous pouvez également créer des cales pour les instances spécifiques, des constructeurs, et pour les propriétés.Pour plus d'informations, consultez Utilisation de shims pour isoler votre application des autres assemblys pour des tests unitaires.

Dans cette section

Utilisation de stubs pour isoler des parties de votre application les unes des autres pour des tests unitaires

Utilisation de shims pour isoler votre application des autres assemblys pour des tests unitaires

Génération et compilation de code et conventions d'affectation de noms dans Microsoft Fakes

Partager via

Isolation du code sous test avec Microsoft Fakes

Choisir entre le stub et les types du shim

Mise en route avec des stubs

Mise en route avec des cales

Dans cette section

Ressources supplémentaires