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

Généralement votre framework de tests aurez une réponse pour cela. Mais si elle n'est pas assez souple, vous pouvez toujours le faire:

try {
    somethingThatShouldThrowAnException();
    Assert.Fail(); //If it gets to this line, no exception was thrown
} catch (GoodException) { }

Comme @Jonas fait remarquer, cela NE fonctionne PAS pour la capture d'une base d'Exception:

try {
    somethingThatShouldThrowAnException();
    Assert.Fail(); //raises AssertionException
} catch (Exception) {
    //Catches the assertion exception, and the test passes
}

Si vous devez absolument Exception de catch, vous devez renvoyer l'Affirmer.Fail(). Mais vraiment, c'est un signe que vous ne devriez pas être à la main l'écriture de ce; vérifier votre framework de test pour les options, ou voir si vous pouvez jeter un plus significatif exception à tester.

catch (AssertionException) { throw; }

Vous devriez être en mesure d'adapter cette approche à ce que vous voulez -- y compris la spécification de ce type d'exceptions à attraper. Si vous attendre seulement à certains types de terminer la catch blocs avec:

} catch (GoodException) {
} catch (Exception) {
    //not the right kind of exception
    Assert.Fail();
}

Si vous êtes à l'aide de MSTest, qui à l'origine n'avait pas de ExpectedException attribut, vous pourriez faire ceci:

try 
{
    SomeExceptionThrowingMethod()
    Assert.Fail("no exception thrown");
}
catch (Exception ex)
{
    Assert.IsTrue(ex is SpecificExceptionType);
}

Méfiez-vous de l'utilisation de ExpectedException, car il peut conduire à plusieurs difficultés, comme l'ont démontré ici:

http://geekswithblogs.net/sdorman/archive/2009/01/17/unit-testing-and-expected-exceptions.aspx

Et ici:

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

Si vous avez besoin de test pour les exceptions, il y a moins de froncer les sourcils sur les moyens. Vous pouvez utiliser le try{loi/fail}catch{assert} méthode, qui peut être utile pour les cadres qui n'ont pas de support direct de l'exception tests autres que ExpectedException.

Une meilleure alternative est d'utiliser xUnit.NET qui est très moderne, tourné vers l'avenir, et extensible framework de test unitaire qui a appris de toutes les autres erreurs, et de l'améliorer. Une de ces améliorations est faire Valoir.Jette, qui offre une bien meilleure syntaxe pour faire valoir des exceptions.

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

MSTest (v2) a maintenant une Assertion.ThrowsException fonction qui peut être utilisée comme ceci:

Assert.ThrowsException<System.FormatException>(() =>
            {
                Story actual = PersonalSite.Services.Content.ExtractHeader(String.Empty);
            }); 

Vous pouvez l'installer avec nuget: Install-Package MSTest.TestFramework

Vous pouvez télécharger un paquet de Nuget à l'aide de: H> Install-Package MSTestExtensions qui ajoute Affirmer.Jette() syntaxe dans le style de nUnit/xUnit à MsTest.

De haut niveau instructions: télécharger l'assemblée et hériter de BaseTest et vous pouvez utiliser le Affirmer.Jette() syntaxe.

La principale méthode pour les Lancers de mise en œuvre se présente comme suit:

public static void Throws<T>(Action task, string expectedMessage, ExceptionMessageCompareOptions options) where T : Exception
{
    try
    {
        task();
    }
    catch (Exception ex)
    {
        AssertExceptionType<T>(ex);
        AssertExceptionMessage(ex, expectedMessage, options);
        return;
    }

    if (typeof(T).Equals(new Exception().GetType()))
    {
        Assert.Fail("Expected exception but no exception was thrown.");
    }
    else
    {
        Assert.Fail(string.Format("Expected exception of type {0} but no exception was thrown.", typeof(T)));
    }
}

Divulgation: j'ai mis en place ce package.

Plus D'Infos: http://www.bradoncode.com/blog/2012/01/asserting-exceptions-in-mstest-with.html

Je ne recommandons pas l'utilisation de la ExpectedException attribut (car il est trop contraignant et source d'erreurs) ou d'écrire un bloc try/catch pour chaque test (comme c'est trop compliqué et source d'erreurs). Utilisez un bien-conçu méthode assert -- soit fourni par votre framework de test ou écrire votre propre. Voici ce que j'ai écrit et de l'utilisation.

public static class ExceptionAssert
{
    private static T GetException<T>(Action action, string message="") where T : Exception
    {
        try
        {
            action();
        }
        catch (T exception)
        {
            return exception;
        }
        throw new AssertFailedException("Expected exception " + typeof(T).FullName + ", but none was propagated.  " + message);
    }

    public static void Propagates<T>(Action action) where T : Exception
    {
        Propagates<T>(action, "");
    }

    public static void Propagates<T>(Action action, string message) where T : Exception
    {
        GetException<T>(action, message);
    }

    public static void Propagates<T>(Action action, Action<T> validation) where T : Exception
    {
        Propagates(action, validation, "");
    }

    public static void Propagates<T>(Action action, Action<T> validation, string message) where T : Exception
    {
        validation(GetException<T>(action, message));
    }
}

Exemple d'utilisation:

    [TestMethod]
    public void Run_PropagatesWin32Exception_ForInvalidExeFile()
    {
        (test setup that might propagate Win32Exception)
        ExceptionAssert.Propagates<Win32Exception>(
            () => CommandExecutionUtil.Run(Assembly.GetExecutingAssembly().Location, new string[0]));
        (more asserts or something)
    }

    [TestMethod]
    public void Run_PropagatesFileNotFoundException_ForExecutableNotFound()
    {
        (test setup that might propagate FileNotFoundException)
        ExceptionAssert.Propagates<FileNotFoundException>(
            () => CommandExecutionUtil.Run("NotThere.exe", new string[0]),
            e => StringAssert.Contains(e.Message, "NotThere.exe"));
        (more asserts or something)
    }

NOTES

Retour de l'exception au lieu de soutenir une validation de rappel est une idée raisonnable, sauf que cela rend la syntaxe d'appel de cette assertion très différent de celui des autres affirme-je utiliser.

Contrairement à d'autres, j'utilise "propage" au lieu de "lance" puisque nous ne pouvons tester si une exception se propage à partir d'un appel. Nous ne pouvons pas tester directement qu'une exception est levée. Mais je suppose que vous pourriez l'image lève pour dire: jeté et n'est pas pris.

DERNIÈRE PENSÉE

Avant de passer à ce genre d'approche que j'ai considéré en utilisant le ExpectedException attribut lorsqu'un test seulement vérifié le type d'exception et à l'aide d'un bloc try/catch si plus de la validation est nécessaire. Mais, non seulement je dois penser à la technique à utiliser pour chaque test, mais de modifier le code d'une technique à l'autre à mesure que les besoins changé n'était pas trivial effort. En utilisant une approche cohérente de la sauve de l'effort mental.

Donc en résumé, cette approche sports: facilité d'utilisation, la flexibilité et la robustesse (dur de faire mal).

Puisque vous parlez de l'utilisation d'autres classes de test, une meilleure option que la ExpectedException attribut est d'utiliser Shoudly's Le devrait.Jeter.

Should.Throw<DivideByZeroException>(() => { MyDivideMethod(1, 0); });

Disons que nous avons une obligation de l' client doit avoir un adresse pour créer un ordre. Si pas, le CreateOrderForCustomer méthode qui devrait aboutir à un ArgumentException. Ensuite, nous pourrions écrire:

[TestMethod]
public void NullUserIdInConstructor()
{
  var customer = new Customer(name := "Justin", address := null};

  Should.Throw<ArgumentException>(() => {
    var order = CreateOrderForCustomer(customer) });
}

C'est mieux que d'utiliser un ExpectedException attribut parce que nous sommes d'être précis sur ce que doit jeter l'erreur. Cela rend les exigences lors de nos tests, plus claire et aussi rend le diagnostic plus facile lorsque le test échoue.

Notez qu'il existe également un Should.ThrowAsync asynchrone de la méthode de test.

Eh bien, je vais assez bien résumer ce que tout le monde ici l'a dit avant...de toute façon, voici le code que j'ai construit selon les bonnes réponses 🙂 Tout reste à faire est de copier et d'utiliser...

///<summary>
///Checks to make sure that the input delegate throws a exception of type TException.
///</summary>
///<typeparam name="TException">The type of exception expected.</typeparam>
///<param name="methodToExecute">The method to execute to generate the exception.</param>
public static void AssertRaises<TException>(Action methodToExecute) where TException : System.Exception
{
    try
    {
        methodToExecute();
    }
    catch (TException) {
        return;
    }  
    catch (System.Exception ex)
    {
        Assert.Fail("Expected exception of type " + typeof(TException) + " but type of " + ex.GetType() + " was thrown instead.");
    }
    Assert.Fail("Expected exception of type " + typeof(TException) + " but no exception was thrown.");  
}

Découvrez nUnit Docs pour des exemples:

[ExpectedException( typeof( ArgumentException ) )]

Dans le cas de l'utilisation NUnit, essayez ceci:

Assert.That(() =>
        {
            Your_Method_To_Test();
        }, Throws.TypeOf<Your_Specific_Exception>().With.Message.EqualTo("Your_Specific_Message"));

Même si c'est une vieille question, je voudrais ajouter une nouvelle pensée de la discussion. J'ai étendu l'Organiser, d'Agir, de faire Valoir de motif à prévoir, Organiser, d'Agir, de faire Valoir. Vous pouvez faire une exception prévue pointeur, puis affirmer qu'il a été attribué. C'est plus propre que de faire votre Affirme dans un bloc catch, en laissant votre article de la Loi sur la plupart uniquement pour une seule ligne de code pour appeler la méthode en cours de test. Vous aussi vous n'avez pas à Assert.Fail(); ou return à partir de plusieurs points dans le code. Toute autre exception levée va provoquer le test à l'échec, car il ne sera pas dans le piège, et si une exception de votre type attendu est levée, mais elle n'était pas celle que vous attendiez, faire Valoir à l'encontre du message ou d'autres propriétés de l'exception de l'aide assurez-vous que votre test ne passera pas par inadvertance.

[TestMethod]
public void Bar_InvalidDependency_ThrowsInvalidOperationException()
{
    //Expectations
    InvalidOperationException expectedException = null;
    string expectedExceptionMessage = "Bar did something invalid.";

    //Arrange
    IDependency dependency = DependencyMocks.Create();
    Foo foo = new Foo(dependency);

    //Act
    try
    {
        foo.Bar();
    }
    catch (InvalidOperationException ex)
    {
        expectedException = ex;
    }

    //Assert
    Assert.IsNotNull(expectedException);
    Assert.AreEqual(expectedExceptionMessage, expectedException.Message);
}