Isolieren von getestetem Code mithilfe von Microsoft Fakes

Artikel
03/12/2013

Microsoft Fakes-Hilfe suchen Sie den Code, den Sie testen, indem Sie andere Teile der Anwendung mit Stubs oder Shims ersetzen.Diese sind kleiner des Codes, den der Kontrolle der Tests sind.Wenn Sie den Code für das Testen suchen, wissen Sie, dass, wenn der Test fehlschlägt, die Ursache und dort nicht an anderer Stelle ist.Stubs und Shims können Sie auch den Code testen, wenn andere Teile der Anwendung noch nicht arbeiten.

Von Fakes gibt es zwei Typen:

Stub ersetzt eine Klasse durch einen kleinen Ersatzmann, der die gleiche Schnittstelle implementiert.Um Stubs zu verwenden, müssen Sie die Anwendung für jede Komponente nur von Schnittstellen abhängt, und nicht auf anderen Komponenten entwerfen.(Durch "Komponente" bedeuten wir eine Klasse oder eine Gruppe von Klassen, die in der Regel in einer Assembly. entworfen und aktualisiert zusammen und enthalten sind)
Shim ändert den kompilierten Code der Anwendung zur Laufzeit, damit, anstatt, einen angegebenen Methodenaufruf auszuführen ausführt, er Shimcode, den das Test bereitstellt.Shims können verwendet werden, um Aufrufe auf Assemblys, die Sie nicht ändern können, solche .NET-Assemblys zu ersetzen.

Fakes ersetzen andere Komponenten

Anforderungen

Visual Studio Ultimate

Auswählen zwischen Stub und Shimtypen

In der Regel würden Sie ein Visual Studio-Projekt berücksichtigen, eine Komponente ist, weil diese Klassen gleichzeitig entwickeln und aktualisieren.Sie können mithilfe der Stubs und der Shims für Aufrufe, dass das Projekt in anderen Projekten in der Lösung wird, oder auf andere Assemblys berücksichtigen, die die Projektverweise.

Als allgemeine Richtlinie, Verwendungsstubs für Aufrufe in der Visual Studio-Projektmappe und Shims für Aufrufe von anderen Assemblys, auf die verwiesen wird.Dies liegt daran, dass in der eigenen Projektmappe es ratsam ist, die Komponenten zu entkoppeln, indem Schnittstellen auf die Weise definiert, die das Roden erfordert.Die externe Assemblys wie "System.dll" in der Regel werden nicht mit separaten Schnittstellendefinitionen bereitgestellt, müssen Sie stattdessen Shims verwenden.

Andere Überlegungen sind:

Leistung. Shims führen langsamer aus, da der Code zur Laufzeit neu schreiben.Stubs verfügen nicht über diesen Leistungsaufwand und sind so schnell, wie virtuelle Methoden wechseln können.

Statische Methoden, versiegelte Typen. Sie können Stubs nur verwenden, um Schnittstellen zu implementieren.Daher können Stubtypen nicht für statische Methoden, nicht virtuelle Methoden, versiegelte virtuelle Methoden, Methoden verwendet werden in versiegelte Typen, u. a.

Interne Typen. können Stubs und Shims mit internen Typen verwendet werden, die verfügbar gemacht werden, indem das Assemblyattribut InternalsVisibleToAttribute verwendet.

Private Methoden Shims können Aufrufe auf private Methoden ersetzen, wenn alle Typen auf der Methodensignatur sichtbar sind.Stubs können sichtbare Methoden nur ersetzen.

Schnittstellen und Zusammenfassungsmethoden. Stubs stellen Implementierungen von Schnittstellen und von Zusammenfassungsmethoden, die in den Tests verwendet werden können.Shims können Schnittstellen und Zusammenfassungsmethoden nicht instrumentieren, da sie nicht Methodentexte haben.

Im Allgemeinen empfiehlt es sich, dass Sie Stubtypen verwenden, um von den Abhängigkeiten in der CodeBases zu suchen.Sie erreichen dies, indem Sie die Komponenten hinter Schnittstellen ausblenden.Shimtypen können verwendet werden, um Komponenten zu suchen von Drittanbietertools, die kein testfähiges API bereitstellen.

Erste Schritte mit Stubs

Fügen Sie ein Schnittstellen

Um Stubs zu verwenden, müssen Sie Code schreiben, den Sie testen möchten dass er nicht explizit Klassen in einer anderen Komponente der Anwendung erwähnt.Durch "Komponente" bedeuten wir eine Klasse oder Klassen, die zusammen entwickelt und aktualisiert werden, und in der Regel enthalten wurde in einem Visual Studio-Projekt.Variablen und Parameter sollten deklariert werden, indem Schnittstellen verwendet und Instanzen anderer Komponenten sollten in übergeben oder erstellt werden, indem eine Factory verwendet.Wenn StockFeed eine Klasse in einer anderen Komponente der Anwendung ist, dann dieses betrachtet werden Sie als fehlerhafte:

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

Stattdessen definieren Sie eine Schnittstelle, die von der anderen Komponente implementiert werden können und die durch einen Stub für Testzwecke auch implementiert werden kann:
```
public int GetContosoPrice(IStockFeed feed)
{ return feed.GetSharePrice("COOO"); }
```
```
Public Function GetContosoPrice(feed As IStockFeed) As Integer
 Return feed.GetSharePrice("COOO")
End Function
```
Fügen Sie eine Fakes-Assembly hinzu
1. In Erweitern Sie im Projektmappen-Explorer, die Verweisliste des Testprojekts.Wenn Sie in Visual Basic arbeiten, müssen Sie Alle Dateien anzeigen auswählen, um die Verweisliste anzuzeigen.
2. Wählen Sie den Verweis auf die Assembly, in der die - Schnittstelle (beispielsweise IStockFeed) definiert ist.Klicken Sie im Kontextmenü diesem Verweis, wählen Sie Fakes-Assembly hinzufügen aus.
3. Generieren Sie die Projektmappe neu.

In den Tests erstellen Sie Instanzen des Stubs und stellen Sie Code für ihre Methoden bereit:

[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

Das spezielle Elemente für Magie hier ist die - Klasse StubIStockFeed.Für jede Schnittstelle in der Assembly, auf die verwiesen wird, generiert der Microsoft Fakes-Mechanismus eine Stubklasse.Der Name der Stubklasse ist die angefügten abgeleiteten vom Namen der Schnittstelle, mit "Fakes.Stub" als Präfix, und Parametertypnamen.

Stubs werden auch für die get-Accessor und die Setter für von Eigenschaften, Ereignisse und für generische Methoden generiert.Weitere Informationen finden Sie unter Verwenden von Stubs, um für Komponententests Teile der Anwendung voneinander zu trennen.

Erste Schritte mit Shims

Angenommen, die Komponente Aufrufe DateTime.Now enthält:

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

Während der Tests werden Sie die - Eigenschaft Now ausgleichen, da die echte Version ungünstig einen anderen Wert an jedem Aufruf zurückgibt.

Um Shims zu verwenden, müssen Sie den Anwendungscode ändern oder ihr eine bestimmte Methode schreiben nicht.

Fügen Sie eine Fakes-Assembly hinzu

Klicken Sie im Projektmappen-Explorer öffnen, die Verweise des Datenbankkomponententest-Projekts und wählen den Verweis auf die Assembly aus, die die Methode enthält, die, Sie fälschen möchten.In diesem Beispiel ist die DateTime-Klasse in System.dll.Um die Verweise in einem Visual Basic-Projekt anzuzeigen, wählen Sie Alle Dateien anzeigen.

Wählen Sie Fakes-Assembly hinzufügen aus.

Fügen Sie einen Shim in einem ShimsContext ein

[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

Shimklassennamen werden gebildet, indem Fakes.Shim zum ursprünglichen Typnamen vorangestellt wird.Parameternamen werden dem Methodennamen angefügt.

Im vorherigen Beispiel verwendet einen Shim für eine statische Methode.Um einen Shim für eine Instanzmethode zu verwenden, schreiben Sie AllInstances zwischen dem Typnamen und dem Methodennamen:

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

Sie können Shims für bestimmte Instanzen, für Konstruktoren und für Eigenschaften auch erstellen.Weitere Informationen finden Sie unter Verwenden von Shims, um zu Komponententests die Anwendung von anderen Assemblys zu trennen.

In diesem Abschnitt

Verwenden von Stubs, um für Komponententests Teile der Anwendung voneinander zu trennen

Verwenden von Shims, um zu Komponententests die Anwendung von anderen Assemblys zu trennen

Codegenerierung, Kompilierung und Benennungskonventionen in Microsoft Fakes

Freigeben über

Isolieren von getestetem Code mithilfe von Microsoft Fakes

Auswählen zwischen Stub und Shimtypen

Erste Schritte mit Stubs

Erste Schritte mit Shims

In diesem Abschnitt

Zusätzliche Ressourcen