Jak korzystać z Assert.Throws, aby potwierdzić typ wyjątku?

Jak użyć, Assert.Throwsaby potwierdzić typ wyjątku i faktyczne sformułowanie wiadomości.

Coś takiego:

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

Metoda, którą testuję, rzuca wiele wiadomości tego samego typu, z różnymi wiadomościami, i potrzebuję sposobu na sprawdzenie, czy poprawna wiadomość jest generowana w zależności od kontekstu.

Assert.Throws zwraca zgłoszony wyjątek, który pozwala potwierdzić ten wyjątek.

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

Jeśli więc nie zostanie zgłoszony żaden wyjątek lub zgłoszony zostanie wyjątek niewłaściwego typu, pierwsze Assert.Throwspotwierdzenie zakończy się niepowodzeniem. Jeśli jednak zostanie zgłoszony wyjątek odpowiedniego typu, możesz teraz potwierdzić faktyczny wyjątek zapisany w zmiennej.

Korzystając z tego wzorca, możesz potwierdzić inne rzeczy niż komunikat wyjątku, np. W przypadku ArgumentExceptioni pochodnych możesz potwierdzić, że nazwa parametru jest poprawna:

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

Możesz również użyć płynnego interfejsu API do wykonywania tych zapewnień:

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

lub alternatywnie

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

Mała wskazówka przy potwierdzaniu komunikatów o wyjątkach polega na udekorowaniu metody testowej, SetCultureAttributeaby upewnić się, że komunikat o błędzie używa oczekiwanej kultury. Ma to zastosowanie w przypadku przechowywania wiadomości wyjątków jako zasobów umożliwiających lokalizację.

Możesz teraz używać ExpectedExceptionatrybutów, np

[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."));

To jest stare, ale istotne pytanie z nieaktualnymi odpowiedziami, więc dodaję bieżące rozwiązanie:

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);
}

To działa z using Microsoft.VisualStudio.TestTools.UnitTesting;

Aby rozwinąć odpowiedź na trwałe i zapewnić większą funkcjonalność NUnit, możesz to zrobić:

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; 
}

Przykłady:

// 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"));

Rozumiem, że od dawna nie było tego problemu, ale ostatnio natknąłem się na to samo i zasugerowałem tę funkcję dla MSTest:

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

stosowanie:

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

Więcej tutaj: http://phejndorf.wordpress.com/2011/02/21/assert-that-a-particular-exception-has-occured/

Ponieważ przeszkadza mi gadatliwość niektórych nowych wzorców NUnit, używam czegoś takiego do tworzenia kodu, który jest dla mnie czystszy:

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);
}

Użycie jest wtedy:

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