MOQ - verifica l'eccezione è stata generata

Question

Io collaboro con il framework MOQ per i miei test. Ho uno scenario in cui mi aspetto di lanciare un'eccezione di errore. Come posso verificare che sia stato lanciato?

public void Koko(List<string?> list) 
{ 
    foreach(string? str in list) 
    { 
     if (str != null) someProperty.Foo(str); 
     else throw new FormatException(); 
    } 
} 

Grazie in anticipo.

Answer 1

Leggere questo numero Introduction to Moq. Ecco il modo per impostare InvalidOperationException lancio quando DoSomething metodo viene richiamato:

mock.Setup(foo => foo.DoSomething()).Throws<InvalidOperationException>(); 

Poi basta verificare se il metodo è stato chiamato. Se è stato chiamato, quindi eccezione è stata sollevata

mock.Verify(foo => foo.DoSomething()); 

Answer 2

È possibile verificare che viene generata un'eccezione utilizzando NUnit asserisce:

Assert.That(() => testObject.methodToTest(), Throws.TypeOf<FaultException>()); 

Answer 3

Se si desidera verificare È stata generata un'eccezione (per il proprio codice) allora Moq non è il tuo strumento di scelta per questo. È sufficiente utilizzare uno dei framework di test dell'unità disponibili.

xUnit/NUnit

asserzioni fluente

Action act =() => foo.Bar()); 
act.ShouldThrow<SomeException>() 

http://fluentassertions.codeplex.com/documentation

http://www.nunit.org/index.php?p=exceptionAsserts&r=2.6.2

Answer 4

Ok così ho risolto nel modo seguente.

Poiché l'eccezione ha interrotto il test, ho inserito la chiamata al metodo nel blocco Because in try-catch.

Quindi potrei utilizzare una verifica semplice.

Grazie a tutti i collaboratori ...

Answer 5

Posso essere mis-leggere il tuo intento, ma per quanto posso vedere non c'è bisogno di fare nulla per un modello al fine di verificare che l'eccezione è stata gettato.

Sembra di avere una classe con un metodo Foo che prende una stringa - consente di chiamare questa classe interna

public class InnerClass { 
    public virtual void Foo(string str) { 
     // do something with the string 
    } 
} 

e una classe che contiene un classe interna come una proprietà (someProperty) che ha un membro di Koko che prende una stringa Lista < > come parametro

public class OuterClass { 

    private readonly InnerClass someProperty; 

    public OuterClass(InnerClass someProperty) { 
     this.someProperty = someProperty; 
    } 

    public void Koko(List<string> list) { 
     foreach (var str in list) { 
       if (str != null) 
        someProperty.Foo(str); 
       else 
        throw new FormatException(); 
      } 
    } 
} 

NOTA: non riesco a ottenere l'elenco <stringa?> per compilare - mi dice che il tipo sottostante (stringa) deve essere non annullabile. AFAIK, uno ha bisogno solo di rendere nullable i tipi di valori, i tipi di riferimento sono implicitamente annullabili.

Sembra che si voglia verificare che se si passa a un elenco di stringhe in cui uno di essi è nullo viene generata una FormatException.

Se è così, l'unico motivo per un MOQ è di liberarci dal preoccuparci della funzionalità di InnerClass. Foo è un metodo, quindi, a meno che non usiamo mock severi, possiamo semplicemente creare un mock di InnerClass senza altre impostazioni.

C'è un attributo [ExpectedException] con il quale possiamo taggare il nostro test per verificare che l'eccezione sia stata generata.

Questo test verrà superato se viene emessa una FormatException e non riesce se non lo è.

Answer 6

una vecchia questione, ma non il codice sorgente in realtà mostrando ciò che la soluzione era, ecco quello che ho fatto:

var correctExceptionThrown = false; 

try 
{ 
    _myClass.DoSomething(x); 
} 
catch (Exception ex) 
{ 
    if (ex.Message == "Expected message") 
     correctExceptionThrown = true; 
}      

Assert.IsTrue(correctExceptionThrown); 

Nota invece di controllare il messaggio, si può prendere un particolare tipo di eccezione (in genere preferibile) .