NUnit 3.0 und Assert.Throws

Ich schreibe einige Unit-Tests mit NUnit 3.0 und im Gegensatz zu v2.x ExpectedException() aus der Bibliothek entfernt.

Basierend darauf Antwort kann ich definitiv die Logik erkennen, wenn ich versuche, genau zu erfassen, wo im Test erwartet wird, dass das System eine Ausnahme auslöst (anstatt nur "irgendwo im Test" zu sagen).

Ich neige jedoch dazu, meine Schritte "Anordnen", "Handeln" und "Durchsetzen" sehr deutlich zu machen, und dies macht es zu einer Herausforderung.

Ich habe so etwas gemacht wie:

[Test, ExpectedException(typeof(FormatException))]
public void Should_not_convert_from_prinergy_date_time_sample1()
{
    //Arrange
    string testDate = "20121123120122";

    //Act
    testDate.FromPrinergyDateTime();

    //Assert
    Assert.Fail("FromPrinergyDateTime should throw an exception parsing invalid input.");
}

Jetzt muss ich etwas tun wie:

[Test]
public void Should_not_convert_from_prinergy_date_time_sample2()
{
    //Arrange
    string testDate = "20121123120122";

    //Act/Assert
    Assert.Throws<FormatException>(() => testDate.FromPrinergyDateTime());
}

Das ist nicht schrecklich, aber meiner Meinung nach trübt es das Gesetz und die Behauptung. (Offensichtlich ist es für diesen einfachen Test nicht schwer zu befolgen, aber bei größeren Tests kann es schwieriger sein).

Ich habe von einem Kollegen vorgeschlagen, dass ich alles los werde Assert.Throwsund einfach so etwas mache wie:

[Test]
public void Should_not_convert_from_prinergy_date_time_sample3()
{
    //Arrange
    int exceptions = 0;
    string testDate = "20121123120122";

    //Act
    try
    {
        testDate.FromPrinergyDateTime();
    }
    catch (FormatException) { exceptions++;}

    //Assert
    Assert.AreEqual(1, exceptions);
}

Hier halte ich mich an das strenge AAA-Format, aber auf Kosten von noch mehr Aufblähung.

Meine Frage geht also an AAA-Tester: Wie würden Sie eine Art Ausnahmevalidierungstest durchführen, wie ich es hier versuche?

Ich sehe, woher Sie kommen, obwohl es mir nichts ausmacht, in diesem Fall Act / Assert-Schritte zu kombinieren.

Das einzige, was ich mir vorstellen kann, ist, den tatsächlichen Delegaten (hier zu FromPrinergyDateTime) in einer Variablen als "Akt" -Schritt zu speichern und ihn dann zu bestätigen:

[Test]
public void Should_not_convert_from_prinergy_date_time_sample2()
{
    //Arrange
    string testDate = "20121123120122";

    //Act
    ActualValueDelegate<object> testDelegate = () => testDate.FromPrinergyDateTime();

    //Assert
    Assert.That(testDelegate, Throws.TypeOf<FormatException>());
}

Ich verstehe, dass der Schritt "Handeln" nicht wirklich Handeln ist, sondern vielmehr definiert, was die Handlung ist. Es wird jedoch klar umrissen, welche Aktion getestet wird.

In C # 7 gibt es eine andere Option (wenn auch sehr ähnlich zu den vorhandenen Antworten):

[Test]
public void Should_not_convert_from_prinergy_date_time_sample2()
{
    void CheckFunction()
    {
        //Arrange
        string testDate = "20121123120122";

        //Act
        testDate.FromPrinergyDateTime();
    }

    //Assert
    Assert.Throws(typeof(Exception), CheckFunction);
}

Blogbeitrag zum Thema

Sie können ein benutzerdefiniertes Attribut in NUnit 3 erstellen [ExpectedException]. Hier ist der Beispielcode zum Erstellen eines Attributs. (ExpectedExceptionExample Zeigt, wie ein benutzerdefiniertes Attribut für NUnit implementiert wird.) Https://github.com/nunit/nunit-csharp-samples