Usando NUnit para probar cualquier tipo de excepción

Question

Tengo una clase que crea un archivo.

Ahora estoy haciendo pruebas de integración para asegurarme de que la clase está bien.

Estoy pasando nombres inválidos de directorios y archivos para asegurarme de que se lanzan las excepciones.

En mis pruebas son que estoy utilizando:

[Test] 
public void CreateFile_InvalidFileName_ThrowsException() 
{ 
    //Arrange 
    var logger = SetupLogger("?\\"); 

    //Act 

    //Assert 
    Assert.Throws<Exception>(()=> logger.CreateFile()); 
} 

Sin embargo, en este escenario la prueba está fallando como un ArgumentException es lanzada. Pensé que al agregar Just Exception pasaría.

¿Hay alguna manera de hacer que esto pase usando Exception?

Answer 1

La ayuda para Assert.Throws<> afirma que "Verifica un delegado lanza un tipo particular de excepción cuando se le llama"

probar la versión Assert.That ya que la captura de cualquier Exception:

private class Thrower 
{ 
    public void ThrowAE() { throw new ArgumentException(); } 
} 

[Test] 
public void ThrowETest() 
{ 
    var t = new Thrower(); 
    Assert.That(() => t.ThrowAE(), Throws.Exception); 
} 

Answer 2

Puede etiquetar su método de prueba con el atributo ExpectedException. Eso debería funcionar.

[ExpectedException(typeof(Exception))] 
    public void TestException() 
    { 

    } 

Answer 3

Sus excepciones deben ser determinista, y usted debe ser capaz de escribir casos de prueba que establecen las condiciones bajo las cuales se produce una excepción específica, y se debe probar para esa excepción específica.

Por lo tanto, la prueba debe ser reescrito como

CreateFile_InvalidFileName_ThrowsArgumentException 

y

Assert.Throws<ArgumentException>(() => logger.CreateFile()); 

Editar:

Por cierto, creo que el constructor debe estar detectando nombres de los archivos no válidos y tirar allí . Y entonces debería ser un contrato para el constructor que el nombre del archivo sea válido.

Answer 4

En general, solo debe probar excepciones específicas para asegurarse de que su código responde correctamente a los diferentes errores.

Si realmente necesita permitir cualquier excepción por el bien de su prueba, solo use un bloque de prueba/captura estándar y asegura el éxito/falla.

Answer 5

Escriba su propio método y usar eso para validación.

/// <summary> 
    /// Throwses the specified action. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    /// <param name="action">The action.</param> 
    /// <returns></returns> 
    public static T Throws<T>(Action action) where T : Exception 
    { 
     try 
     { 
      action(); 
     } 
     catch (T ex) 
     { 
      return ex; 
     } 

     Assert.Fail("Expected exception of type {0}.", typeof(T)); 
     return null; 
    } 

Answer 6

Para NUnit 2,5 y por encima de

// Allow both ApplicationException and any derived type 
Assert.Catch<ApplicationException>(() => logger.CreateFile()); 

// Allow any kind of exception 
Assert.Catch(() => logger.CreateFile()); 

Answer 7

Throws.InstanceOf() permite pasar un tipo de excepción base, en lugar de un tipo derivado más específico.

[Test] 
public void CreateFile_InvalidFileName_ThrowsException() 
{ 
    //Arrange 
    var logger = SetupLogger("?\\"); 

    //Act 

    //Assert 
    Assert.That(() => logger.CreateFile(), Throws.InstanceOf<Exception>()); 
}