Wie verwende ich Assert.Throws, um den Typ der Ausnahme zu bestätigen?

Wie kann ich Assert.Throwsden Typ der Ausnahme und den tatsächlichen Wortlaut der Nachricht bestätigen?

Etwas wie das:

Assert.Throws<Exception>(
    ()=>user.MakeUserActive()).WithMessage("Actual exception message")

Die Methode, die ich teste, wirft mehrere Nachrichten desselben Typs mit unterschiedlichen Nachrichten aus, und ich brauche eine Möglichkeit, um zu testen, ob die richtige Nachricht je nach Kontext ausgelöst wird.

Assert.Throws Gibt die ausgelöste Ausnahme zurück, mit der Sie die Ausnahme bestätigen können.

var ex = Assert.Throws<Exception>(() => user.MakeUserActive());
Assert.That(ex.Message, Is.EqualTo("Actual exception message"));

Wenn also keine Ausnahme ausgelöst wird oder eine Ausnahme des falschen Typs ausgelöst wird, schlägt die erste Assert.ThrowsZusicherung fehl. Wenn jedoch eine Ausnahme des richtigen Typs ausgelöst wird, können Sie jetzt die tatsächliche Ausnahme bestätigen, die Sie in der Variablen gespeichert haben.

Mit diesem Muster können Sie andere Dinge als die Ausnahmemeldung bestätigen, z. B. im Fall von ArgumentExceptionund Ableitungen, und Sie können behaupten, dass der Parametername korrekt ist:

var ex = Assert.Throws<ArgumentNullException>(() => foo.Bar(null));
Assert.That(ex.ParamName, Is.EqualTo("bar"));

Sie können auch die fließende API verwenden, um diese Asserts auszuführen:

Assert.That(() => foo.Bar(null), 
Throws.Exception
  .TypeOf<ArgumentNullException>()
  .With.Property("ParamName")
  .EqualTo("bar"));

oder alternativ

Assert.That(
    Assert.Throws<ArgumentNullException>(() =>
        foo.Bar(null)
    .ParamName,
Is.EqualTo("bar"));

Ein kleiner Tipp beim Aktivieren von Ausnahmemeldungen besteht darin, die Testmethode mit zu dekorieren SetCultureAttribute, um sicherzustellen, dass die ausgelöste Nachricht die erwartete Kultur verwendet. Dies kommt ins Spiel, wenn Sie Ihre Ausnahmemeldungen als Ressourcen speichern, um die Lokalisierung zu ermöglichen.

Sie können jetzt die ExpectedExceptionAttribute verwenden, z

[Test]
[ExpectedException(typeof(InvalidOperationException), 
 ExpectedMessage="You can't do that!"]
public void MethodA_WithNull_ThrowsInvalidOperationException()
{
    MethodA(null);
}

Assert.That(myTestDelegate, Throws.ArgumentException
    .With.Property("Message").EqualTo("your argument is invalid."));

Dies ist eine alte, aber relevante Frage mit veralteten Antworten, daher füge ich die aktuelle Lösung hinzu:

public void Test() {
    throw new MyCustomException("You can't do that!");
}

[TestMethod]
public void ThisWillPassIfExceptionThrown()
{
    var exception = Assert.ThrowsException<MyCustomException>(
        () => Test(),
        "This should have thrown!");
    Assert.AreEqual("You can't do that!", exception.Message);
}

Das funktioniert mit using Microsoft.VisualStudio.TestTools.UnitTesting;

Um die Antwort von persistent zu erweitern und mehr Funktionen von NUnit bereitzustellen, können Sie Folgendes tun:

public bool AssertThrows<TException>(
    Action action,
    Func<TException, bool> exceptionCondition = null)
    where TException : Exception 
{
    try
    {
        action();
    }
    catch (TException ex)
    {
        if (exceptionCondition != null)
        {
            return exceptionCondition(ex);
        }

        return true;
    }
    catch
    {
        return false;
    }

    return false; 
}

Beispiele:

// No exception thrown - test fails.
Assert.IsTrue(
    AssertThrows<InvalidOperationException>(
        () => {}));

// Wrong exception thrown - test fails.
Assert.IsTrue(
    AssertThrows<InvalidOperationException>(
        () => { throw new ApplicationException(); }));

// Correct exception thrown - test passes.
Assert.IsTrue(
    AssertThrows<InvalidOperationException>(
        () => { throw new InvalidOperationException(); }));

// Correct exception thrown, but wrong message - test fails.
Assert.IsTrue(
    AssertThrows<InvalidOperationException>(
        () => { throw new InvalidOperationException("ABCD"); },
        ex => ex.Message == "1234"));

// Correct exception thrown, with correct message - test passes.
Assert.IsTrue(
    AssertThrows<InvalidOperationException>(
        () => { throw new InvalidOperationException("1234"); },
        ex => ex.Message == "1234"));

Es ist lange her, dass dieses Problem angesprochen wurde, aber ich bin kürzlich auf dasselbe gestoßen und schlage diese Funktion für MSTest vor:

public bool AssertThrows(Action action) where T : Exception 
{ 
try {action();} 
catch(Exception exception) 
{ 
    if (exception.GetType() == typeof(T)) return true; 
} 
return false; 
}

Verwendung:

Assert.IsTrue(AssertThrows<FormatException>(delegate{ newMyMethod(MyParameter); }));

Mehr hier: http://phejndorf.wordpress.com/2011/02/21/assert-that-a-particular-exception-has-occured/

Da mich die Ausführlichkeit einiger der neuen NUnit-Muster stört, verwende ich so etwas, um Code zu erstellen, der für mich persönlich sauberer ist:

public void AssertBusinessRuleException(TestDelegate code, string expectedMessage)
{
    var ex = Assert.Throws<BusinessRuleException>(code);
    Assert.AreEqual(ex.Message, expectedMessage);
}

public void AssertException<T>(TestDelegate code, string expectedMessage) where T:Exception
{
    var ex = Assert.Throws<T>(code);
    Assert.AreEqual(ex.Message, expectedMessage);
}

Die Verwendung ist dann:

AssertBusinessRuleException(() => user.MakeUserActive(), "Actual exception message");