Comment puis-je utiliser Assert pour vérifier qu'une exception a été levée avec MSTest ?

Question

Comment utiliser Assert (ou une autre classe de Test) pour vérifier qu'une exception a été levée lors de l'utilisation de MSTest/Microsoft.VisualStudio.TestTools.UnitTesting?

Answer 1

Pour "Visual Studio Team Test", il semble que vous appliquiez l'attribut ExpectedException à la méthode de test.

Exemple de la documentation ici : Une présentation des tests unitaires avec Visual Studio Team Test

[TestMethod]
[ExpectedException(typeof(ArgumentException),
    "Un identifiant utilisateur nul a été inappropriément autorisé.")]
public void NullUserIdInConstructor()
{
   LogonInfo logonInfo = new LogonInfo(null, "P@ss0word");
}

Answer 2

En général, votre framework de test aura une réponse à cela. (Consultez les commentaires de ce fil pour des exemples, il y en a beaucoup !) Mais si votre framework n'est pas assez flexible, vous pouvez toujours faire ceci :

try {
    quelqueChoseQuiDevraitLancerUneException();
    Assert.Fail(); // Si cela arrive à cette ligne, aucune exception n'a été lancée
} catch (BonneException) { }

Comme le souligne @Jonas, cela NE FONCTIONNE PAS pour attraper une Exception de base :

try {
    quelqueChoseQuiDevraitLancerUneException();
    Assert.Fail(); // lève une AssertionException
} catch (Exception) {
    // Attrape l'exception d'assertion, et le test passe
}

Si vous devez absolument attraper Exception, vous devez relancer le Assert.Fail(). Mais vraiment, c'est un signe que vous ne devriez pas écrire ceci à la main ; vérifiez les options de votre framework de test, ou voyez si vous pouvez lancer une exception plus significative à tester.

catch (AssertionException) { throw; }

Vous devriez pouvoir adapter cette approche à ce que vous voulez -- y compris spécifier quels types d'exceptions attraper. Si vous n'attendez que certains types, finalisez les blocs catch avec :

} catch (BonneException) {
} catch (Exception) {
    // pas le bon type d'exception
    Assert.Fail();
}

Answer 3

Ma méthode préférée pour implémenter cela est d'écrire une méthode appelée Throws, et de l'utiliser comme n'importe quelle autre méthode Assert. Malheureusement, .NET ne vous permet pas d'écrire une méthode d'extension statique, donc vous ne pouvez pas utiliser cette méthode comme si elle appartenait réellement à la classe Assert intégrée; créez simplement une autre appelée MyAssert ou quelque chose de similaire. La classe ressemble à ceci:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace YourProject.Tests
{
    public static class MyAssert
    {
        public static void Throws( Action func ) where T : Exception
        {
            var exceptionThrown = false;
            try
            {
                func.Invoke();
            }
            catch ( T )
            {
                exceptionThrown = true;
            }

            if ( !exceptionThrown )
            {
                throw new AssertFailedException(
                    String.Format("Une exception de type {0} était attendue, mais pas lancée", typeof(T))
                    );
            }
        }
    }
}

Cela signifie que votre test unitaire ressemble à ceci:

[TestMethod()]
public void ExceptionTest()
{
    String testStr = null;
    MyAssert.Throws(() => testStr.ToUpper());
}

Ce qui ressemble et se comporte beaucoup plus comme le reste de vos syntaxes de test unitaire.

Answer 4

Si vous utilisez MSTest, qui n'avait initialement pas d'attribut ExpectedException, vous pourriez faire ceci :

try 
{
    SomeExceptionThrowingMethod()
    Assert.Fail("aucune exception lancée");
}
catch (Exception ex)
{
    Assert.IsTrue(ex is SpecificExceptionType);
}

Answer 5

Méfiez-vous de l'utilisation de ExpectedException, car cela peut entraîner plusieurs pièges comme le démontre ici:

Lien

Et ici:

http://xunit.github.io/docs/comparisons.html

Si vous avez besoin de tester des exceptions, il existe des moyens moins critiqués. Vous pouvez utiliser la méthode try{act/fail}catch{assert}, qui peut être utile pour les frameworks qui n'ont pas de support direct pour les tests d'exception autres que ExpectedException.

Une meilleure alternative est d'utiliser xUnit.NET, qui est un framework de tests unitaires très moderne, tourné vers l'avenir et extensible qui a appris des erreurs de tous les autres et s'est amélioré. Une telle amélioration est Assert.Throws, qui fournit une syntaxe beaucoup plus claire pour l'assertion des exceptions.

Vous pouvez trouver xUnit.NET sur github: http://xunit.github.io/