19. Apr 2021
Lesedauer 6 Min.
NUnit, xUnit oder MSTest?
Unit-Test-Frameworks
Vergleich der drei Frameworks zum Schreiben von Unit-Tests.
dotnetpro
Durch den Einsatz von Unit-Tests kann die korrekte Ausführung von Programmcode sichergestellt und seine Verwendung automatisch dokumentiert werden. Schleichen sich Fehler bei nachträglichen Anpassungen des Codes ein, besteht eine gute Chance, diese durch das Netz der Unit-Tests zu entdecken, bevor der Code beim Kunden installiert wird sowie zeitintensive und für das Image des Unternehmens schädliche Support-Sessions erfolgen müssen.Doch welches Framework ist das richtige? Um Sie bei dieser Frage zu unterstützen, werden hier die drei bekannten Frameworks NUnit, xUnit und MSTest miteinander verglichen und gezeigt, wie die einzelnen Frameworks die unterschiedlichen Anforderungen erfüllen.Visual Studio stellt Projektvorlagen für alle drei Testbibliotheken zur Verfügung. Für die Gegenüberstellung wurden Testprojekte mit den Visual-Studio-Vorlagen aus Bild 1 erstellt. Die Entwicklungsumgebung versieht die Testprojekte automatisch mit einer leeren Testklasse, die bereits einen ersten leeren Test anbietet.
Die Visual-Studio-Projektvorlagenfür die drei Unit-Test-Frameworks(Bild 1)
Autor
Bei NUnit wird zusätzlich eine Methode erstellt, die mit dem Attribut Setup dekoriert ist. Diese Methode wird vor jeder Ausführung eines Unit-Tests in der Klasse ausgeführt. Dies ist durchaus hilfreich, wenn es zum Beispiel notwendig ist, die Instanz der zu testenden Klasse – häufig mit SUT abgekürzt, was für System Under Test steht – neu zu erstellen. Welche Möglichkeiten die Frameworks zum Aufräumen nach der Ausführung der Unit-Tests anbieten, erfahren Sie später.Auf den ersten Blick machen die generierten Klassen von NUnit und xUnit einen besonders schlanken Eindruck. Die Methode Setup bei NUnit ist optional und kann deshalb auch gelöscht werden. Aber wie bereits erwähnt, hat eine solche Funktion durchaus ihre Berechtigung. Listing 1 zeigt die drei automatisch erstellten leeren Testklassen.
Listing 1: Automatisch erstellte Testklassen
// NUnit-Testklasse <br/><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> Tests <br/>{ <br/> [SetUp] <br/> <span class="hljs-keyword">public</span> void Setup() { <br/> } <br/><br/> [Test] <br/> <span class="hljs-keyword">public</span> void Test1() { <br/> <span class="hljs-keyword">Assert</span>.<span class="hljs-keyword">Pass</span>(); <br/> } <br/>} <br/><br/><br/>// XUnit-Testklasse <br/><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> XUnitTest { <br/> [Fact] <br/> <span class="hljs-keyword">public</span> void Test1() { <br/> } <br/>} <br/><br/>// MSTest-Testklasse <br/>[TestClass] <br/><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> MsUnitTest { <br/> [TestMethod] <br/> <span class="hljs-keyword">public</span> void TestMethod1() { <br/> } <br/>} Initialisierung vor jedem Test
Wie schon gesagt bietet NUnit mit dem Attribut Setup die Möglichkeit, Initialisierungsroutinen vor jedem Test durchzuführen. Bei xUnit lässt sich der Konstruktor für diese Maßnahmen verwenden, da für jeden in der Klasse definierten Test eine neue Instanz erstellt wird. In Listing 2 sehen Sie die xUnit-Implementierung. Sie zeigt zwei Unit-Tests, die eine Klassenvariable inkrementieren, die im Konstruktor mit 0 initialisiert wird. Die Tests sind erfolgreich, wenn die Klassenvariable den Wert 1 hat.Listing 2: xUnit – Initialisierung
<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">XUnitTest</span> <br/>{ <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> _counter; <br/><br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">XUnitTest</span>(<span class="hljs-params"></span>) </span>{ <br/> _counter = <span class="hljs-number">0</span>; <br/> } <br/><br/> [Fact] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Test1</span>(<span class="hljs-params"></span>) </span>{ <br/> _counter++; <br/> Assert.True(_counter == <span class="hljs-number">1</span>); <br/> } <br/><br/> [Fact] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Test2</span>(<span class="hljs-params"></span>) </span>{ <br/> _counter++; <br/> Assert.True(_counter == <span class="hljs-number">1</span>); <br/> } <br/>}
Bei dem Framework aus dem Hause Microsoft wird, wie auch bei NUnit, eine Methode mit einem Attribut markiert. Bei MSTest nennt es sich TestInitialize – Listing 3 zeigt ein Beispiel dafür.
Listing 3: MSTest – TestInitialize
[TestClass] <br/><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">MsUnitTest</span> <br/>{ <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">int</span> _counter; <br/><br/> [TestInitialize] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Setup</span>(<span class="hljs-params"></span>) </span>{ <br/> _counter = <span class="hljs-number">0</span>; <br/> } <br/><br/> [TestMethod] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">TestMethod1</span>(<span class="hljs-params"></span>) </span>{ <br/> _counter++; <br/> Assert.IsTrue(_counter == <span class="hljs-number">1</span>); <br/> } <br/><br/> [TestMethod] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">TestMethod2</span>(<span class="hljs-params"></span>) </span>{ <br/> _counter++; <br/> Assert.IsTrue(_counter == <span class="hljs-number">1</span>); <br/> } <br/>} Bereinigung nach dem Test
Das Bereinigen nach der Ausführung einzelner Tests ist ein weiteres wichtiges Leistungsmerkmal der Frameworks. Zunächst zu NUnit. Im Beispiel in Listing 4 wird ein statischer Zähler mit dem Wert 2 initialisiert und in der Methode Teardown, die mit dem gleichnamigen Attribut markiert ist, wird die Variable dekrementiert und ihr aktueller Wert ausgegeben. Die Ausgaben der beiden Tests im Test Explorer von Visual Studio sehen Sie in Bild 2 und Bild 3.Listing 4: NUnit – Bereinigung nach dem Test
<span class="hljs-keyword">private</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> _counter = <span class="hljs-number">2</span>; <br/><br/> [Test] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Test1</span>(<span class="hljs-params"></span>) </span>{ <br/> Assert.Pass(); <br/> } <br/><br/> [Test] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Test2</span>(<span class="hljs-params"></span>) </span>{ <br/> Assert.Pass(); <br/> } <br/><br/> [TearDown] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Teardown</span>(<span class="hljs-params"></span>) </span>{ <br/> --_counter; <br/> Console.WriteLine( <br/> <span class="hljs-string">$"Teardown counter: '<span class="hljs-subst">{_counter}</span>'"</span>); <br/> } 
Ausgabe nachdem zweiten Aufruf bei NUnit(Bild 3)
Autor
NUnit:Ausgabe nach dem ersten Aufruf(Bild 2)
Autor
Um bei xUnit eine Bereinigung nach dem Ausführen der Tests zu ermöglichen, muss IDisposable implementiert werden. Um eine Ausgabe im Ergebnis des Unit-Tests zu erhalten, kommt anstelle von Console.WriteLine(…) eine Instanz von ITestOutputHelper zum Einsatz. Wie in Listing 5 zu sehen ist, wird dazu der Konstruktor um den Parameter ITestOutputHelper ergänzt. Die Ausgaben zeigen Bild 4 und Bild 5.
Listing 5: xUnit – Bereinigung mittels Dispose
<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">XUnitTest</span> : <span class="hljs-title">IDisposable</span> <br/>{ <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> _counter = <span class="hljs-number">2</span>; <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">readonly</span> ITestOutputHelper _outputHelper; <br/><br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">XUnitTest</span>(<span class="hljs-params">ITestOutputHelper outputHelper</span>) </span>{ <br/> _outputHelper = outputHelper; <br/> } <br/><br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Dispose</span>(<span class="hljs-params"></span>) </span>{ <br/> --_counter; <br/> _outputHelper.WriteLine( <br/> <span class="hljs-string">$"Dispose in xUnit counter: '<span class="hljs-subst">{_counter}</span>'"</span>); <br/> } <br/><br/> [Fact] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Test1</span>(<span class="hljs-params"></span>) </span>{ <br/> Assert.True(<span class="hljs-literal">true</span>); <br/> } <br/><br/> [Fact] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Test2</span>(<span class="hljs-params"></span>) </span>{ <br/> Assert.True(<span class="hljs-literal">true</span>); <br/> } <br/>} 
Ausgabe nachdem zweiten Aufruf bei xUnit(Bild 5)
Autor
XUnit:Ausgabe nach dem ersten Aufruf(Bild 4)
Autor
MSTest bietet – wie auch NUnit – ein entsprechendes Attribut an. Es heißt bei MSTest TestCleanup. Listing 6 zeigt den zugehörigen Unit-Test und in Bild 6 und Bild 7 finden Sie die zugehörigen Ausgaben.
Listing 6: MSTest – Bereinigung mit CleanUp
[TestClass] <br/> <span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">MsUnitTest</span> { <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span> _counter = <span class="hljs-number">2</span>; <br/> [TestCleanup] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">CleanUp</span>(<span class="hljs-params"></span>) </span>{ <br/> --_counter; <br/> Console.WriteLine( <br/> <span class="hljs-string">$"CleanUp counter: '<span class="hljs-subst">{_counter}</span>'"</span>); <br/> } <br/> [TestMethod] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">TestMethod1</span>(<span class="hljs-params"></span>) </span>{ } <br/> [TestMethod] <br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">TestMethod2</span>(<span class="hljs-params"></span>) </span>{ } <br/>} 
Ausgabe nachdem zweiten Aufruf bei MSTest(Bild 7)
Autor
MSTest:Ausgabe nach dem ersten Aufruf(Bild 6)
Autor
Mehrfache Ausführung eines Tests
Möchte man eine Funktion auch mit mehreren unterschiedlichen Werten testen, bieten die Frameworks ebenfalls Lösungen an. Listing 7 zeigt für alle drei Testframeworks, wie Sie Tests mehrfach mit unterschiedlichen Parametern ausführen können.Listing 7: Einen Test mehrfach ausführen
// NUnit <br/> [TestCase(<span class="hljs-string">"Franz"</span>, <span class="hljs-string">"Huber"</span>, <br/> ExpectedResult=<span class="hljs-string">"Franz Huber"</span>)] <br/> [TestCase(<span class="hljs-string">"Michi"</span>, <span class="hljs-string">"Alfons"</span>, <br/> ExpectedResult =<span class="hljs-string">"Michi Alfons"</span>)] <br/><br/> public <span class="hljs-built_in">string</span> TestWithMultipleValues( <br/> <span class="hljs-built_in">string</span> <span class="hljs-built_in">first</span>, <span class="hljs-built_in">string</span> <span class="hljs-built_in">second</span>) { <br/> <span class="hljs-built_in">return</span> $<span class="hljs-string">"{first} {second}"</span>; <br/> } <br/><br/>// xUnit <br/> [Theory] <br/> [InlineData(<span class="hljs-string">"Franz"</span>, <span class="hljs-string">"Huber"</span>, <span class="hljs-string">"Franz Huber"</span>)] <br/> [InlineData(<span class="hljs-string">"Michi"</span>, <span class="hljs-string">"Alfons"</span>, <span class="hljs-string">"Michi Alfons"</span>)] <br/><br/> public void TestWithMultipleValues(<span class="hljs-built_in">string</span> <span class="hljs-built_in">first</span>, <br/> <span class="hljs-built_in">string</span> <span class="hljs-built_in">second</span>, <span class="hljs-built_in">string</span> expected) { <br/> Assert.Equal(expected, MethodToTest( <br/> <span class="hljs-built_in">first</span>, <span class="hljs-built_in">second</span>)); <br/> } <br/> private <span class="hljs-built_in">string</span> MethodToTest(<span class="hljs-built_in">string</span> <span class="hljs-built_in">first</span>, <br/> <span class="hljs-built_in">string</span> <span class="hljs-built_in">second</span>) { <br/> <span class="hljs-built_in">return</span> $<span class="hljs-string">"{first} {second}"</span>; <br/> } <br/><br/>// MSTest <br/> [DataTestMethod] <br/> [DataRow(<span class="hljs-string">"Franz"</span>, <span class="hljs-string">"Huber"</span>, <span class="hljs-string">"Franz Huber"</span>)] <br/> [DataRow(<span class="hljs-string">"Michi"</span>, <span class="hljs-string">"Alfons"</span>, <span class="hljs-string">"Michi Alfons"</span>)] <br/><br/> public void TestWithMultipleValues(<span class="hljs-built_in">string</span> <span class="hljs-built_in">first</span>, <br/> <span class="hljs-built_in">string</span> <span class="hljs-built_in">second</span>, <span class="hljs-built_in">string</span> expected) { <br/> Assert.AreEqual(expected, <br/> MethodToTest(<span class="hljs-built_in">first</span>, <span class="hljs-built_in">second</span>)); <br/> } <br/><br/> private <span class="hljs-built_in">string</span> MethodToTest(<span class="hljs-built_in">string</span> <span class="hljs-built_in">first</span>, <br/> <span class="hljs-built_in">string</span> <span class="hljs-built_in">second</span>) { <br/> <span class="hljs-built_in">return</span> $<span class="hljs-string">"{first} {second}"</span>; <br/> }
Bei NUnit wird dafür die Testmethode mit dem Attribut TestCase dekoriert. Die beiden ersten Werte Franz und Hubert werden bei der Ausführung des Tests mittels der Parameter first und second an den Test übergeben. Der dritte Parameter, der als ExpectedResult gekennzeichnet ist, dient zur Prüfung, ob der Test erfolgreich ausgeführt wurde. Er wird mit dem von der Testmethode gelieferten Rückgabewert verglichen.Bei xUnit verhält es sich ähnlich. An die Stelle des Attributs Fact, welches angibt, dass der Test keine Parameter erwartet und nur einmal ausgeführt wird, wird das Attribut Theory gesetzt. Dieses Attribut gibt an, dass der Test einerseits mehrere Parameter entgegennehmen kann und dass er mehrfach ausgeführt wird. Das erwartete Ergebnis wird hier als Parameter expected an den Test übergeben. Die Auswertung obliegt der Klasse Assert des Unit-Tests.Bei MSTest ist die Vorgehensweise ähnlich wie bei xUnit. Es erfolgt eine Markierung, dass der Test mit Daten ausgeführt wird (Attribut DataTestMethod) und mit dem Attribut DataRow werden, wie auch bei xUnit, sowohl die Eingaben als auch das erwartete Resultat geliefert.
Unit-Tests aus dem CI-Build-Prozess ausnehmen
Mit Unit-Tests können auch Programmteile isoliert entwickelt und geprüft werden, die Abhängigkeiten haben. Sollen beispielsweise Zugriffe auf das Outlook-Objektmodell geprüft werden, etwa um eine neue E-Mail zu öffnen, sollte man die Ausführung des Unit-Tests insofern einschränken, dass dieser nicht beim Daily Build ausgeführt wird. Der Grund: Es könnte vorkommen, dass der Test fehlschlägt, weil Outlook auf dem Build-System nicht installiert ist.Dennoch ist die isolierte Entwicklung mit Unit-Tests möglich. NUnit bietet die Option, einen Test mit dem Attribut Explicit zu kennzeichnen, sodass dieser nur dann ausgeführt wird, wenn sein Start über die Benutzeroberfläche erfolgt.Anders sieht es bei xUnit aus. Hier stellen die Bordmittel keine Lösung bereit. Jimmy Bogard hat unter [1] einen Ansatz veröffentlicht, bei welchem sich durch eine Ableitung der Klasse FactAttribute ein eigenes Attribut definieren lässt, dessen Verwendung dazu führt, dass der Unit-Test nur im Debugger ausgeführt wird (Bild 8).
xUnit-Attribut, um den Test nur im Debugger auszuführen(Bild 8)
Autor
Bei MSTest ist hingegen nichts dergleichen zu finden. Auf StackOverflow wurde der Lösungsansatz vorgeschlagen, siehe [2], in der Testmethode zu prüfen, ob der Debugger angebunden ist:
// Einen MSTest nur <span class="hljs-literal">im</span> Debugger ausführen
[TestMethod]
public void TestMethod2()
{
<span class="hljs-keyword">if</span> (!System.Diagnostics.Debugger.IsAttached)
<span class="hljs-keyword">return</span>;
Assert.IsTrue(<span class="hljs-literal">true</span>);
} Test auf erwartete Exceptions
Der letzte Abschnitt befasst sich damit, wie in den drei Frameworks geprüft werden kann, ob eine erwartete Ausnahme ausgelöst wurde und der Test somit als erfolgreich zu werten ist. Die Umsetzung ist in allen drei Frameworks nahezu identisch. Über die Klasse Assert wird die erwartete Ausnahme angegeben und die zu testende Funktion im Delegate angegeben.Um Details der abgefangenen Ausnahme zu prüfen, wird diese als Rückgabewert verfügbar gemacht. Listing 8 zeigt die Varianten der drei Frameworks.Listing 8: Auf eine Exception prüfen
<span class="hljs-regexp">//</span> NUnit <br/> [Test] <br/> public void CatchExpectedException() <br/> { <br/> var ex = Assert.Throws&lt;ArgumentNullException&gt;( <br/> <span class="hljs-function"><span class="hljs-params">()</span> =&gt;</span> int.Parse(<span class="hljs-literal">null</span>)); <br/> Assert.That(ex.Message == <br/> <span class="hljs-string">"Value cannot be null. (Parameter 's')"</span>); <br/> } <br/><br/><span class="hljs-regexp">//</span> xUnit <br/> [Fact] <br/> public void CatchExpectedException() <br/> { <br/> var ex = Assert.Throws&lt;ArgumentNullException&gt;( <br/> <span class="hljs-function"><span class="hljs-params">()</span> =&gt;</span> int.Parse(<span class="hljs-literal">null</span>)); <br/><br/> Assert.Equal( <br/> <span class="hljs-string">"Value cannot be null. (Parameter 's')"</span>, <br/> ex.Message); <br/> } <br/><br/><span class="hljs-regexp">//</span> MSTest <br/> [TestMethod] <br/> public void CatchExpectedException() <br/> { <br/> var ex = Assert.ThrowsException&lt; <br/> ArgumentNullException&gt;( <br/> <span class="hljs-function"><span class="hljs-params">()</span> =&gt;</span> int.Parse(<span class="hljs-literal">null</span>));<br/><br/> Assert.AreEqual( <br/> <span class="hljs-string">"Value cannot be null. (Parameter 's')"</span>, <br/> ex.Message); <br/> } Fazit
In der Handhabung sind sich die Frameworks sehr ähnlich. Eine umfangreiche Dokumentation, wie sie für NUnit vorhanden ist, sucht man bei xUnit vergeblich. Allerdings sind in Internetforen auch für xUnit zahlreiche Beiträge zu finden. Schlussendlich scheint es eher eine Frage des persönlichen Geschmacks zu sein, welches Framework das geeignete ist. Unter [3] bis [6] finden Sie weitere nützliche Hinweise zu den hier untersuchten Testframeworks.Fussnoten
- Jimmy Bogard, Run tests explicitly in xUnit.net, http://www.dotnetpro.de/SL2105UnitTest1
- StackOverflow, MSTest equivalent to NUnit’s Explicit Attribute, http://www.dotnetpro.de/SL2105UnitTest2
- Parametrized Tests with MSTest, http://www.dotnetpro.de/SL2105UnitTest3
- Roy Osherove, Michael Feathers, Robert C. Martin, The Art of Unit Testing (deutsche Ausgabe), mitp, 2015, ISBN 978-3-82669712-8,
- Using XUnit Theory and InlineData to Test C# Extension Methods, http://www.dotnetpro.de/SL2105UnitTest4
- MSTest versus NUnit versus XUnit, http://www.dotnetpro.de/SL2105UnitTest5
