Der beste Weg, um Ausnahmen mit Assert zu testen, um sicherzustellen, dass sie ausgelöst werden

Denken Sie, dass dies ein guter Weg ist, um Ausnahmen zu testen? Irgendwelche Vorschläge?

Exception exception = null;
try{
    //I m sure that an exeption will happen here
}
catch (Exception ex){
    exception = ex;
}

Assert.IsNotNull(exception);

Ich benutze MS Test.

Ich habe ein paar verschiedene Muster, die ich benutze. Ich benutze das ExpectedExceptionAttribut die meiste Zeit, wenn eine Ausnahme erwartet wird. Dies reicht in den meisten Fällen aus, es gibt jedoch einige Fälle, in denen dies nicht ausreicht. Die Ausnahme ist möglicherweise nicht abfangbar - da sie von einer Methode ausgelöst wird, die durch Reflektion aufgerufen wird - oder ich möchte nur überprüfen, ob andere Bedingungen gelten, z. B. wenn eine Transaktion zurückgesetzt wird oder noch ein Wert festgelegt wurde. In diesen Fällen verpacke ich es in einen try/catchBlock, der die genaue Ausnahme erwartet, eine, Assert.Failwenn der Code erfolgreich ist, und generische Ausnahmen abfängt, um sicherzustellen, dass keine andere Ausnahme ausgelöst wird.

Erster Fall:

[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void MethodTest()
{
     var obj = new ClassRequiringNonNullParameter( null );
}

Zweiter Fall:

[TestMethod]
public void MethodTest()
{
    try
    {
        var obj = new ClassRequiringNonNullParameter( null );
        Assert.Fail("An exception should have been thrown");
    }
    catch (ArgumentNullException ae)
    {
        Assert.AreEqual( "Parameter cannot be null or empty.", ae.Message );
    }
    catch (Exception e)
    {
        Assert.Fail(
             string.Format( "Unexpected exception of type {0} caught: {1}",
                            e.GetType(), e.Message )
        );
    }
}

Jetzt, 2017, können Sie es mit dem neuen MSTest V2 Framework einfacher machen :

Assert.ThrowsException<Exception>(() => myClass.MyMethodWithError());

//async version
await Assert.ThrowsExceptionAsync<SomeException>(
  () => myObject.SomeMethodAsync()
);

Ich bin neu hier und habe nicht den Ruf, Kommentare abzugeben oder abzustimmen, wollte aber auf einen Fehler im Beispiel in Andy Whites Antwort hinweisen :

try
{
    SomethingThatCausesAnException();
    Assert.Fail("Should have exceptioned above!");
}
catch (Exception ex)
{
    // whatever logging code
}

In allen mir bekannten Unit-Testing-Frameworks Assert.Failwird eine Ausnahme ausgelöst, sodass der generische Fang den Fehler des Tests tatsächlich maskiert. Wenn SomethingThatCausesAnException()nicht geworfen Assert.Failwird, sprudelt der Wille, aber das wird niemals zum Testläufer heraus, um einen Fehler anzuzeigen.

Wenn Sie die erwartete Ausnahme abfangen müssen (dh um bestimmte Details wie die Nachricht / Eigenschaften der Ausnahme zu bestätigen), ist es wichtig, den spezifischen erwarteten Typ und nicht die Basisausnahmeklasse abzufangen. Dies würde es ermöglichen, dass die Assert.FailAusnahme heraussprudelt (vorausgesetzt, Sie lösen nicht die gleiche Art von Ausnahme aus, die Ihr Unit-Testing-Framework ausführt), ermöglicht jedoch weiterhin die Validierung der Ausnahme, die von Ihrer SomethingThatCausesAnException()Methode ausgelöst wurde .

Ab Version 2.5 verfügt NUnit über die folgenden Methodenebenen Assertzum Testen von Ausnahmen:

Assert.Throws , das auf einen genauen Ausnahmetyp prüft :

Assert.Throws<NullReferenceException>(() => someNullObject.ToString());

Und Assert.Catch, die auf eine Ausnahme eines bestimmten Typs oder einen von diesem Typ abgeleiteten Ausnahmetyp testen:

Assert.Catch<Exception>(() => someNullObject.ToString());

Abgesehen davon möchten Sie beim Debuggen von Komponententests, die Ausnahmen auslösen, möglicherweise verhindern, dass VS die Ausnahme beschädigt .

Bearbeiten

Nur um ein Beispiel für Matthews Kommentar unten zu geben, die Rückgabe des Generikums Assert.Throwsund Assert.Catchist die Ausnahme mit dem Typ der Ausnahme, die Sie dann zur weiteren Prüfung untersuchen können:

// The type of ex is that of the generic type parameter (SqlException)
var ex = Assert.Throws<SqlException>(() => MethodWhichDeadlocks());
Assert.AreEqual(1205, ex.Number);

Leider hat MSTest STILL nur wirklich das ExpectedException-Attribut (zeigt nur, wie sehr sich MS um MSTest kümmert), was IMO ziemlich schrecklich ist, weil es das Arrange / Act / Assert-Muster bricht und es Ihnen nicht erlaubt, genau anzugeben, welche Codezeile Sie für die Ausnahme erwarten auftreten am.

Wenn ich MSTest verwende (/ von einem Client gezwungen), verwende ich immer diese Hilfsklasse:

public static class AssertException
{
    public static void Throws<TException>(Action action) where TException : Exception
    {
        try
        {
            action();
        }
        catch (Exception ex)
        {
            Assert.IsTrue(ex.GetType() == typeof(TException), "Expected exception of type " + typeof(TException) + " but type of " + ex.GetType() + " was thrown instead.");
            return;
        }
        Assert.Fail("Expected exception of type " + typeof(TException) + " but no exception was thrown.");
    }

    public static void Throws<TException>(Action action, string expectedMessage) where TException : Exception
    {
        try
        {
            action();
        }
        catch (Exception ex)
        {
            Assert.IsTrue(ex.GetType() == typeof(TException), "Expected exception of type " + typeof(TException) + " but type of " + ex.GetType() + " was thrown instead.");
            Assert.AreEqual(expectedMessage, ex.Message, "Expected exception with a message of '" + expectedMessage + "' but exception with message of '" + ex.Message + "' was thrown instead.");
            return;
        }
        Assert.Fail("Expected exception of type " + typeof(TException) + " but no exception was thrown.");
    }
}

Anwendungsbeispiel:

AssertException.Throws<ArgumentNullException>(() => classUnderTest.GetCustomer(null));

Als Alternative zur Verwendung von ExpectedExceptionAttributen definiere ich manchmal zwei hilfreiche Methoden für meine Testklassen:

AssertThrowsException() Nimmt einen Delegaten und behauptet, dass er die erwartete Ausnahme mit der erwarteten Nachricht auslöst.

AssertDoesNotThrowException() Nimmt denselben Delegaten und behauptet, dass er keine Ausnahme auslöst.

Diese Kopplung kann sehr nützlich sein, wenn Sie testen möchten, ob in einem Fall eine Ausnahme ausgelöst wird, im anderen jedoch nicht.

Mit ihnen könnte mein Unit-Test-Code folgendermaßen aussehen:

ExceptionThrower callStartOp = delegate(){ testObj.StartOperation(); };

// Check exception is thrown correctly...
AssertThrowsException(callStartOp, typeof(InvalidOperationException), "StartOperation() called when not ready.");

testObj.Ready = true;

// Check exception is now not thrown...
AssertDoesNotThrowException(callStartOp);

Schön und ordentlich, oder?

Meine AssertThrowsException()und AssertDoesNotThrowException()Methoden werden in einer gemeinsamen Basisklasse wie folgt definiert:

protected delegate void ExceptionThrower();

/// <summary>
/// Asserts that calling a method results in an exception of the stated type with the stated message.
/// </summary>
/// <param name="exceptionThrowingFunc">Delegate that calls the method to be tested.</param>
/// <param name="expectedExceptionType">The expected type of the exception, e.g. typeof(FormatException).</param>
/// <param name="expectedExceptionMessage">The expected exception message (or fragment of the whole message)</param>
protected void AssertThrowsException(ExceptionThrower exceptionThrowingFunc, Type expectedExceptionType, string expectedExceptionMessage)
{
    try
    {
        exceptionThrowingFunc();
        Assert.Fail("Call did not raise any exception, but one was expected.");
    }
    catch (NUnit.Framework.AssertionException)
    {
        // Ignore and rethrow NUnit exception
        throw;
    }
    catch (Exception ex)
    {
        Assert.IsInstanceOfType(expectedExceptionType, ex, "Exception raised was not the expected type.");
        Assert.IsTrue(ex.Message.Contains(expectedExceptionMessage), "Exception raised did not contain expected message. Expected=\"" + expectedExceptionMessage + "\", got \"" + ex.Message + "\"");
    }
}

/// <summary>
/// Asserts that calling a method does not throw an exception.
/// </summary>
/// <remarks>
/// This is typically only used in conjunction with <see cref="AssertThrowsException"/>. (e.g. once you have tested that an ExceptionThrower
/// method throws an exception then your test may fix the cause of the exception and then call this to make sure it is now fixed).
/// </remarks>
/// <param name="exceptionThrowingFunc">Delegate that calls the method to be tested.</param>
protected void AssertDoesNotThrowException(ExceptionThrower exceptionThrowingFunc)
{
    try
    {
        exceptionThrowingFunc();
    }
    catch (NUnit.Framework.AssertionException)
    {
        // Ignore and rethrow any NUnit exception
        throw;
    }
    catch (Exception ex)
    {
        Assert.Fail("Call raised an unexpected exception: " + ex.Message);
    }
}

Markieren Sie den Test mit dem ExpectedExceptionAttribute (dies ist der Begriff in NUnit oder MSTest; Benutzer anderer Unit-Test-Frameworks müssen möglicherweise übersetzen).

Bei den meisten .net-Unit-Test-Frameworks können Sie der Testmethode ein Attribut [ExpectedException] hinzufügen. Dies kann Ihnen jedoch nicht sagen, dass die Ausnahme an dem Punkt aufgetreten ist, den Sie erwartet haben. Das ist , wo xunit.net helfen kann.

Mit xunit haben Sie Assert.Throws, damit Sie folgende Dinge tun können:

    [Fact]
    public void CantDecrementBasketLineQuantityBelowZero()
    {
        var o = new Basket();
        var p = new Product {Id = 1, NetPrice = 23.45m};
        o.AddProduct(p, 1);
        Assert.Throws<BusinessException>(() => o.SetProductQuantity(p, -3));
    }

[Fakt] ist das Xunit-Äquivalent von [TestMethod]

Schlagen Sie vor, die saubere Delegatensyntax von NUnit zu verwenden .

Beispiel zum Testen ArgumentNullExeption:

[Test]
[TestCase(null)]
public void FooCalculation_InvalidInput_ShouldThrowArgumentNullExeption(string text)
{
    var foo = new Foo();
    Assert.That(() => foo.Calculate(text), Throws.ArgumentNullExeption);

    //Or:
    Assert.That(() => foo.Calculate(text), Throws.Exception.TypeOf<ArgumentNullExeption>);
}