Como uso o Assert.Throws para afirmar o tipo da exceção?

Como uso Assert.Throwspara afirmar o tipo da exceção e o texto da mensagem real.

Algo assim:

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

O método que estou testando lança várias mensagens do mesmo tipo, com mensagens diferentes, e preciso de uma maneira de testar se a mensagem correta é lançada dependendo do contexto.

Assert.Throws retorna a exceção lançada, que permite afirmar a exceção.

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

Portanto, se nenhuma exceção for lançada ou uma exceção do tipo errado for lançada, a primeira Assert.Throwsasserção falhará. No entanto, se uma exceção do tipo correto for lançada, agora você poderá afirmar a exceção real que salvou na variável.

Ao usar esse padrão, você pode afirmar outras coisas além da mensagem de exceção, por exemplo, no caso de ArgumentExceptione derivados, pode afirmar que o nome do parâmetro está correto:

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

Você também pode usar a API fluente para fazer as seguintes afirmações:

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

ou alternativamente

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

Uma pequena dica ao declarar mensagens de exceção é decorar o método de teste com o SetCultureAttributepara garantir que a mensagem lançada esteja usando a cultura esperada. Isso entra em jogo se você armazenar suas mensagens de exceção como recursos para permitir a localização.

Agora você pode usar os ExpectedExceptionatributos, por exemplo

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

Esta é uma pergunta antiga, mas relevante, com respostas desatualizadas, por isso estou adicionando a solução atual:

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

Isso funciona com using Microsoft.VisualStudio.TestTools.UnitTesting;

Para expandir a resposta do persistente e fornecer mais funcionalidades do NUnit, você pode fazer o seguinte:

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

Exemplos:

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

Percebi que já faz muito tempo que esse problema foi levantado, mas recentemente me deparei com a mesma coisa e sugiro esta função para o MSTest:

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

uso:

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

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

Como estou incomodado com a verbosidade de alguns dos novos padrões da NUnit, uso algo assim para criar código mais limpo para mim:

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

O uso é então:

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