Utilizzo di NUnit per verificare qualsiasi tipo di eccezione

Question

Ho una classe che crea un file.

Ora sto facendo test di integrazione per assicurarmi che la classe sia ok.

Sto passando nomi di directory e file non validi per accertarmi che vengano emesse eccezioni.

Nel mio test sono sto usando:

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

    //Act 

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

Tuttavia, in questo scenario il test sta fallendo come un ArgumentException viene generata. Ho pensato aggiungendo solo l'eccezione che sarebbe passata.

C'è un modo per rendere questo passaggio usando solo Eccezione?

Answer 1

L'aiuto per Assert.Throws<> afferma che "Verifica un delegato getta un particolare tipo di eccezione quando viene chiamato"

provare la versione Assert.That come si cattura qualsiasi 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

È possibile contrassegnare il metodo di prova con l'attributo ExpectedException. Questo dovrebbe funzionare

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

    } 

Answer 3

vostri eccezioni dovrebbero essere deterministico, e si dovrebbe essere in grado di scrivere i casi di test che si insediano condizioni in cui verrà generata un'eccezione specifica, e si dovrebbe provare per quella specifica eccezione.

Così, il test deve essere riscritta come

CreateFile_InvalidFileName_ThrowsArgumentException 

e

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

Edit:

A proposito, credo che il vostro costruttore dovrebbe essere rilevando i nomi di file non validi e gettando lì . E quindi dovrebbe essere un contratto per il costruttore che il nome del file sia valido.

Answer 4

In generale, è necessario verificare solo eccezioni specifiche per assicurarsi che il codice risponda correttamente a diversi errori.

Se è davvero necessario consentire qualsiasi eccezione per il proprio test, utilizzare solo un blocco try/catch standard e gli insuccessi Success/Failure normali.

Answer 5

Scrivi la tua metodo e usalo per la convalida.

/// <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

Per NUnit 2.5 e sopra

// 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() permette di passare un tipo di eccezione base, invece di un tipo derivato più specifico.

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

    //Act 

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