Özel durumun türünü iddia etmek için Assert.Throws'u nasıl kullanabilirim?

Assert.ThrowsKural dışı durumun türünü ve gerçek ileti ifadelerini iddia etmek için nasıl kullanılır ?

Bunun gibi bir şey:

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

Test ettiğim yöntem, farklı iletilerle aynı türden birden çok ileti atar ve içeriğe bağlı olarak doğru iletinin atılmasını sınamanın bir yoluna ihtiyacım var.

Assert.Throws atılan istisnayı döndürür.

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

Dolayısıyla, herhangi bir istisna atılmazsa veya yanlış türde bir istisna atılırsa, ilk Assert.Throwsiddia başarısız olur. Ancak, doğru türde bir istisna atılırsa, şimdi değişkene kaydettiğiniz gerçek istisna hakkında iddia edebilirsiniz.

Bu kalıbı kullanarak, istisna mesajından başka şeyler üzerinde iddia edebilirsiniz, örneğin ArgumentExceptionve türevlerde, parametre adının doğru olduğunu iddia edebilirsiniz:

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

Akıcı API'yı şu önerileri yapmak için de kullanabilirsiniz:

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

Veya alternatif olarak

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

İstisna mesajlar konusunda küçük bir ipucu SetCultureAttribute, atılan mesajın beklenen kültürü kullandığından emin olmak için test yöntemini ile süslemektir . İstisna mesajlarınızı yerelleştirmeye izin verecek kaynaklar olarak saklarsanız bu devreye girer.

Artık ExpectedExceptionözellikleri kullanabilirsiniz , ör.

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

Bu, eski çözümü de içeren eski ve alakalı bir sorudur, bu yüzden mevcut çözümü ekliyorum:

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

İle çalışır using Microsoft.VisualStudio.TestTools.UnitTesting;

Kalıcı yanıtı genişletmek ve NUnit'in daha fazla işlevselliğini sağlamak için şunları yapabilirsiniz:

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

Örnekler:

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

Bu sorunun ortaya çıkmasından bu yana uzun zaman geçti, anlıyorum, ama son zamanlarda aynı şeyle karşılaştım ve MSTest için bu işlevi öneriyorum:

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

kullanımı:

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

Daha fazlası için: http://phejndorf.wordpress.com/2011/02/21/assert-that-a-particular-exception-has-occured/

Bazı yeni NUnit modellerinin ayrıntılarından rahatsız olduğum için, kişisel olarak benim için daha temiz kod oluşturmak için böyle bir şey kullanıyorum:

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

Kullanım sonra:

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