NUnit Cheatsheet

Frei nach "Ey Mann, wo ist mein Auto?" kann man sagen, dass NUnit ein sehr großes und mächtiges Unittest Framework ist. Und seine Größe wird nur durch seine Mächtigkeit übertroffen.


NUnit ist aber auch sehr gut darin seine Größe und Mächtigkeit zu verbergen. Wenn ich mir die Unittests in meiner Firma gelegentlich so anschaue, dann könnte man meinen NUnit hätte nur die Assert.AreEqual(...) Methode. Eigentlich alle Tests werden über diese Methode realisiert. 
Man könnte jetzt doch sagen "Hey, ist doch super. Mann muss sich nur diese eine Methode merken und kann Unittests schreiben".
Aus Erfahrung habe ich damit aber zwei Probleme:

1. Man schreibt keine Unittests, da man die Bedingung nicht oder nur umständlich mit einer Prüfung auf Gleichheit "erschlagen" kann.
2. Unittests werden groß und kryptisch wenn man versucht alles mit Assert.AreEuqal(...) zu machen.

Hier passt ein Zitat von Paul Watzlawick ziemlich gut: 

"Wer als Werkzeug nur einen Hammer hat, sieht in jedem Problem einen Nagel."

Und damit man nicht immer mit dem AreEqual-Hammer arbeitet habe ich hier jetzt mal einen kleinen Spickzettel für NUnit zusammen geschrieben.

Prinzipiell hat NUnit zwei API Modelle. Da ist zum einen das bekannte "Classic Model" mit den Assert.Are... Methoden. Zum anderen das "Constraint Model" das mit sogenannten Constraints (deutsch Bedingungen) arbeitet.

Ich werde hier nur das "Constraint Model" zeigen, da dies meiner Meinung nach besser lesbar und mächtiger ist.


Cheatsheet

            // Vergleich von 2 Objekten
            Assert.That("lorem ipsum", Is.EqualTo("lorem ipsum"));

            // Vergleich von 2 Zahlen mit absoluter Toleranz
            Assert.That(3.14, Is.EqualTo(Math.PI).Within(0.01));

            // Vergleich von 2 Zahlen mit relativer Toleranz
            Assert.That(3.14, Is.EqualTo(Math.PI).Within(1).Percent);

            // Vergleich auf identische Referenz
            object o = new object();
            object o2 = o;
            Assert.That(o, Is.SameAs(o2));

            // Vergleich auf Null
            object x = null;
            Assert.That(x, Is.Null);

            // Vergleich auf nicht Null
            Assert.That(o, Is.Not.Null);

            // Zahl größer als
            Assert.That(23, Is.GreaterThan(10));

            // Zahl kleiner als
            Assert.That(23, Is.LessThan(100));

            // Innerhalb eines Bereichs
            Assert.That(42, Is.InRange(1, 100));

            // ******************************************************
            // Strings
            // ******************************************************
            // Auf konkreten Type Prüfen
            Assert.That("lorem", Is.TypeOf());

            // Auf substring prüfen
            Assert.That("lorem", Contains.Substring("ore"));

            // Nicht case sensitiv auf Substring prüfen
            Assert.That("lorem", Is.StringContaining("ORE").IgnoreCase);

            // Text mit einem regulären Ausdrück überprüfen
            Assert.That("lorem ipsum", Is.StringMatching("^lorem\\s"));
            
            // ******************************************************
            // Collections
            // ******************************************************
            string[] values = new string[] { "lorem", "ipsum", "dolor", "sit" };

            // Enhält
            Assert.That(values, Has.Member("dolor"));
            Assert.That(values, Has.Some.EqualTo("dolor"));

            // Enhält nicht
            Assert.That(values, Has.No.Member("amet"));