Bagaimana cara menggunakan Assert.Throws untuk menegaskan jenis pengecualian?

Bagaimana cara saya gunakan Assert.Throwsuntuk menegaskan jenis pengecualian dan kata-kata aktual pesan.

Sesuatu seperti ini:

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

Metode yang saya uji melempar banyak pesan dari jenis yang sama, dengan pesan yang berbeda, dan saya perlu cara untuk menguji apakah pesan yang benar dilemparkan tergantung pada konteksnya.

Assert.Throws mengembalikan pengecualian yang dilemparkan yang memungkinkan Anda menegaskan pengecualian.

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

Jadi, jika tidak ada pengecualian yang dilemparkan, atau pengecualian dari tipe yang salah dilemparkan, Assert.Throwspernyataan pertama akan gagal. Namun, jika pengecualian dari jenis yang benar dilempar maka Anda sekarang dapat menegaskan pada pengecualian yang sebenarnya Anda simpan dalam variabel.

Dengan menggunakan pola ini Anda dapat menegaskan hal-hal lain selain pesan pengecualian, misalnya dalam kasus ArgumentExceptiondan turunannya, Anda dapat menegaskan bahwa nama parameter sudah benar:

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

Anda juga dapat menggunakan API yang lancar untuk melakukan pernyataan ini:

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

atau sebagai alternatif

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

Sedikit tip ketika menegaskan pada pesan pengecualian adalah untuk menghias metode pengujian dengan SetCultureAttributeuntuk memastikan bahwa pesan yang dilemparkan menggunakan budaya yang diharapkan. Ini mulai berlaku jika Anda menyimpan pesan pengecualian sebagai sumber daya untuk memungkinkan pelokalan.

Anda sekarang dapat menggunakan ExpectedExceptionatribut, mis

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

Ini adalah pertanyaan lama namun relevan dengan jawaban yang sudah usang jadi saya menambahkan solusi saat ini:

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

Ini bekerja dengan using Microsoft.VisualStudio.TestTools.UnitTesting;

Untuk memperluas jawaban persisten, dan untuk memberikan lebih banyak fungsi NUnit, Anda dapat melakukan ini:

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

Contoh:

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

Ini sudah lama sejak masalah ini diangkat, saya sadar, tetapi saya baru-baru ini mengalami hal yang sama, dan menyarankan fungsi ini untuk MSTest:

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

pemakaian:

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

Lebih lanjut di sini: http://phejndorf.wordpress.com/2011/02/21/assert-that-a-particular-exception-has-occured/

Karena saya terganggu oleh verbositas dari beberapa pola NUnit baru, saya menggunakan sesuatu seperti ini untuk membuat kode yang lebih bersih bagi saya secara pribadi:

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

Maka penggunaannya adalah:

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