Come posso usare Assert.Throws per affermare il tipo di eccezione?

Come posso utilizzare Assert.Throwsper affermare il tipo di eccezione e la formulazione effettiva del messaggio.

Qualcosa come questo:

Assert.Throws<Exception>(
    ()=>user.MakeUserActive()).WithMessage("Actual exception message")

Il metodo che sto testando genera più messaggi dello stesso tipo, con messaggi diversi, e ho bisogno di un modo per testare che il messaggio corretto venga lanciato a seconda del contesto.

Assert.Throws restituisce l'eccezione generata che consente di affermare l'eccezione.

var ex = Assert.Throws<Exception>(() => user.MakeUserActive());
Assert.That(ex.Message, Is.EqualTo("Actual exception message"));

Pertanto, se non viene generata alcuna eccezione o viene generata un'eccezione di tipo errato, la prima Assert.Throwsasserzione fallirà. Tuttavia, se viene generata un'eccezione del tipo corretto, ora puoi affermare l'eccezione effettiva che hai salvato nella variabile.

Utilizzando questo modello è possibile affermare altre cose oltre al messaggio di eccezione, ad esempio nel caso di ArgumentExceptione derivati, è possibile affermare che il nome del parametro è corretto:

var ex = Assert.Throws<ArgumentNullException>(() => foo.Bar(null));
Assert.That(ex.ParamName, Is.EqualTo("bar"));

Puoi anche usare l'API fluente per fare questi assert:

Assert.That(() => foo.Bar(null), 
Throws.Exception
  .TypeOf<ArgumentNullException>()
  .With.Property("ParamName")
  .EqualTo("bar"));

o in alternativa

Assert.That(
    Assert.Throws<ArgumentNullException>(() =>
        foo.Bar(null)
    .ParamName,
Is.EqualTo("bar"));

Un piccolo suggerimento quando si asserisce sui messaggi di eccezione è quello di decorare il metodo di test con SetCultureAttributeper assicurarsi che il messaggio generato stia utilizzando la cultura prevista. Questo entra in gioco se si memorizzano i messaggi di eccezione come risorse per consentire la localizzazione.

Ora puoi usare gli ExpectedExceptionattributi, ad es

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

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

Questa è una domanda vecchia ma pertinente con risposte obsolete, quindi sto aggiungendo la soluzione attuale:

public void Test() {
    throw new MyCustomException("You can't do that!");
}

[TestMethod]
public void ThisWillPassIfExceptionThrown()
{
    var exception = Assert.ThrowsException<MyCustomException>(
        () => Test(),
        "This should have thrown!");
    Assert.AreEqual("You can't do that!", exception.Message);
}

Questo funziona con using Microsoft.VisualStudio.TestTools.UnitTesting;

Per espandere la risposta persistente e fornire più funzionalità di NUnit, è possibile effettuare ciò:

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; 
}

Esempi:

// 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"));

È passato molto tempo da quando è stato sollevato questo problema, mi rendo conto, ma di recente mi sono imbattuto nella stessa cosa e suggerisco questa funzione per MSTest:

public bool AssertThrows(Action action) where T : Exception 
{ 
try {action();} 
catch(Exception exception) 
{ 
    if (exception.GetType() == typeof(T)) return true; 
} 
return false; 
}

utilizzo:

Assert.IsTrue(AssertThrows<FormatException>(delegate{ newMyMethod(MyParameter); }));

Altro qui: http://phejndorf.wordpress.com/2011/02/21/assert-that-a-particular-exception-has-occured/

Dato che sono disturbato dalla verbosità di alcuni dei nuovi modelli NUnit, uso qualcosa del genere per creare codice che sia più pulito per me 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);
}

L'utilizzo è quindi:

AssertBusinessRuleException(() => user.MakeUserActive(), "Actual exception message");