with - throw new exception c# example

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

Question

¿Cómo uso Assert.Throws para 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 el mensaje correcto se emite según el contexto.

Answer 1

Ahora puede utilizar los atributos ExpectedException , por ejemplo,

[Test]
[ExpectedException(typeof(InvalidOperationException), 
 ExpectedMessage="You can''t do that!"]
public void MethodA_WithNull_ThrowsInvalidOperationException()
{
    MethodA(null);
}

Answer 2

Hace mucho tiempo que no surgió 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/

Answer 3

Para ampliar la respuesta de persistente y proporcionar más funcionalidades 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"));

Answer 4

Ya que me molesta la verbosidad de algunos de los nuevos patrones 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(() => service.Create(content), "Name already exists");

Answer 5

Assert.Throws devuelve la excepción que se lanza, lo 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 ninguna excepción, o se lanza una excepción del tipo incorrecto, la primera afirmación de Assert.Throws fallará. Sin embargo, si se lanza una excepción del tipo correcto, ahora puede hacer valer la excepción real que ha guardado en la variable.

Al usar este patrón, puede hacer valer otras cosas que no sean el mensaje de excepción, por ejemplo, en el caso de ArgumentException y sus 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"));

Un pequeño consejo al afirmar en los mensajes de excepción es decorar el método de prueba con el SetCultureAttribute para asegurarse de que el mensaje lanzado está utilizando la cultura esperada. Esto entra en juego si almacena sus mensajes de excepción como recursos para permitir la localización.

Answer 6

Assert.That(myTestDelegate, Throws.ArgumentException
    .With.Property("Message").EqualTo("your argument is invalid."));