Ignorar excepciones en xUnit.net

Question

Tengo algunos casos en los que no me importa qué excepción se produce (siempre que se produzca alguna excepción). Por desgracia,

Assert.Throws<Exception>(someDelegate); 

no pasa a menos que exactamente se inicia una instancia de Exception (por lo que no es una instancia de una clase derivada). Sé que puedo obtener el comportamiento que quiero con

Exception exception = Record.Exception(someDelegate); 
Assert.NotNull(exception); 

pero no se lee correctamente. ¿Me estoy perdiendo algo en xUnit que tiene el comportamiento que quiero? Aquí hay dos pruebas que indican lo que quiero decir:

[Fact] 
public void Throws_exception_and_passes() { 
    Exception exception = Record.Exception(
     () => { throw new InvalidOperationException(); } 
    ); 
    Assert.NotNull(exception); 
} 

[Fact] 
public void Throws_exception_and_fails() { 
    Assert.Throws<Exception>(
     () => { throw new InvalidOperationException(); } 
    ); 
} 

Answer 1

por la documentación aquí:

http://xunit.codeplex.com/wikipage?title=HowToUse&referringTitle=Home

Se tiene que especificar el tipo de excepción que desea ser lanzado. En general, esta es una buena práctica. Debería poder predecir en qué escenarios arrojaría una prueba qué tipo de excepción. Debería poder diseñar tanto su método como su prueba de una manera que le permita predecir esto.

Existen varias formas de evitar esto, como hacer un intento de atraparlo, pero debe considerar cambiar un poco su diseño.

Answer 2

xUnit no se interpondrá en su camino si quiere hacer su propia Custom Assertion, algo así como:

public static bool Throws<T>(this Action action, bool discardExceptions = false) 
    where T : Exception 
{ 
    try 
    { 
     action.Invoke(); 
    } 
    catch (T) 
    { 
     return true; 
    } 
    catch (Exception) 
    { 
     if (discardExceptions) 
     { 
      return false; 
     } 
     throw; 
    } 
    return false; 
} 

O:

public static bool Throws(this Action action) 
{ 
    try 
    { 
     action.Invoke(); 
    } 
    catch (Exception) 
    { 
     return true; 
    } 
    return false; 
} 

Answer 3

Como usted ha identificado si no lo hace Assert.Throws<T> ajuste la cuenta, la única cosa de OOTB en xUnit que le queda es usar Record.Exception.

Como usted ha identificado, la principal forma de hacer un 'Assert tiros anything` es hacer

Assert.NotNull(Record.Exception(lambda)) 

mire - no es bonito. Esto es probable por diseño; hay muy pocas cosas en xUnit.net que son por accidente (a diferencia de un diseño considerado cuidadosamente).

Record.Exception devuelve un resultado por un motivo (y si usaba F #, tendría que |> ignore para descartar el valor). Siempre debe poder Assert algo sobre la naturaleza de la excepción que está ocurriendo para que un problema real en su código no sea ignorado por casualidad, ya que cambia su código a lo largo del tiempo, que es la razón de todas estas pruebas en el primer lugar. Tal vez eso podría tomar la forma de

var exception = Record.Exception(sut.Something); 
Assert.True(typeof(SomeException).IsAssignableFrom(exception)); 

En cuanto a eso, es más seguro que un Assert.NotNull(), pero aún no se siente bien. Es hora de, como se discutió en GOOS, escuchar sus pruebas (y en el caso de un marco de prueba obstinado, su marco de prueba).Sin embargo

---

El mayor problema en su pregunta es que en un ejemplo real de una prueba real, siempre hay una manera de hacer que su interfaz más clara o expresar sus expectativas de otra manera, por lo que la verdadera respuesta es Mu.

Answer 4

que solo estaba buscando en el xUnit.net source y aquí es el culpable:

private static Exception Throws(Type exceptionType, Exception exception) 
{ 
    Guard.ArgumentNotNull("exceptionType", exceptionType); 

    if (exception == null) 
     throw new ThrowsException(exceptionType); 

    if (!exceptionType.Equals(exception.GetType())) 
     throw new ThrowsException(exceptionType, exception); 

    return exception; 
} 

Lo que resolver su problema es si este cambio se aplica:

if(!exceptionType.Equals(exception.GetType())) 

a:

if(!exception.GetType().IsAssignableTo(exceptionType)) 

¿Podría ofrecer enviar un parche?

Answer 5

No existía en el momento de esta pregunta, pero ahora uno puede utilizar Assert.ThrowsAny<Exception> para la prueba de cualquier excepción derivada de Exception (y por lo tanto ninguna excepción en absoluto), junto con variantes como Assert.ThrowsAny<ArgumentException> que prueba para cualquier excepción derivada de ArgumentException y así sucesivamente.

Answer 6

public static void SuppressException<TSut>(this TSut value, Action<TSut> action) where TSut : class 
    { 
     try 
     { 
      action.Invoke(value); 
     } 
     catch (Exception) 
     { 
      //do nothing 
     } 
    }