¿Cómo uso Assert.Throws para afirmar el tipo de excepción?

¿Cómo uso Assert.Throwspara afirmar el tipo de excepción y la redacción real del mensaje?

Algo como esto:

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

El método que estoy probando arroja múltiples mensajes del mismo tipo, con diferentes mensajes, y necesito una forma de probar que se arroja el mensaje correcto según el contexto.

Assert.Throws devuelve la excepción lanzada que le permite hacer valer la excepción.

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

Entonces, si no se lanza una excepción, o si se lanza una excepción del tipo incorrecto, la primera Assert.Throwsaserción fallará. Sin embargo, si se produce una excepción del tipo correcto, ahora puede afirmar la excepción real que ha guardado en la variable.

Al usar este patrón, puede afirmar sobre otras cosas que no sean el mensaje de excepción, por ejemplo, en el caso de ArgumentExceptiony derivados, puede afirmar que el nombre del parámetro es correcto:

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

También puede usar la API fluida para hacer estas afirmaciones:

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

o alternativamente

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

Un pequeño consejo al hacer valer mensajes de excepción es decorar el método de prueba con el SetCultureAttributefin de asegurarse de que el mensaje lanzado utilice la cultura esperada. Esto entra en juego si almacena sus mensajes de excepción como recursos para permitir la localización.

Ahora puede usar los ExpectedExceptionatributos, p. Ej.

[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 es una pregunta antigua pero relevante con respuestas obsoletas, así que estoy agregando la solución actual:

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

Esto funciona con using Microsoft.VisualStudio.TestTools.UnitTesting;

Para ampliar la respuesta del persistente y proporcionar más de la funcionalidad de NUnit, puede hacer esto:

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

Ejemplos:

// 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 mucho tiempo desde que se planteó este problema, me doy cuenta, pero recientemente me encontré con lo mismo y sugiero esta función para 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); }));

Más aquí: http://phejndorf.wordpress.com/2011/02/21/assert-that-a-particular-exception-has-occured/

Como me molesta la verbosidad de algunos de los nuevos patrones de NUnit, uso algo como esto para crear un código que sea más limpio para mí personalmente:

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

El uso es entonces:

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