¿Cuál es el equivalente de DoesNotThrow de NUnit en xUnit?

DoesNotThrow es utilizado en NUnit para verificar que un delegado pasado como argumento en el test no lanza una excepción.

Dicho de otro modo.

Si en nuestro test el método a probar y de importancia para nosotros dentro de él produce una excepción, DoesNotThrow nos lo indicará.

Aunque también podríamos esperar que nuestro Test devolviera una excepción, lo cual realizaríamos utilizando a la inversa algo como lo siguiente decorando nuestro Test:

[ExpectedException(typeof(YourException))]

Sin embargo y en este escenario, estoy analizando únicamente la posibilidad de que el test lance una excepción (sea cual sea) y que en teoría no espero que ocurra.

Dentro de NUnit, aunque tenemos DoesNotThrow para código síncrono, en el caso de que queramos que nuestro código sea asíncrono tenemos DoesNotThrowAsync.

A pesar de todos estos detalles, la forma general de llamar a DoesNotThrow es de la forma:

Assert.DoesNotThrow(() => { /* custom code block here */ });

o bien (y normalmente):

Assert.DoesNotThrow(() => MyMethod());

Un ejemplo de este uso sería por ejemplo el siguiente Test en C#:

using NUnit.Framework;

namespace FooTests
{
    [TestFixture]
    public class MyUnitTest
    {
        [Test]
        public void TestMethod1()
        {
            var demo = new Demo();
            Assert.DoesNotThrow(() => demo.FooMethod());
        }
    }

    public class Demo
    {
        public void FooMethod()
        {
        }
    }

}

Ahora bien, también podríamos sustituir

Assert.DoesNotThrow(() => demo.FooMethod())

de forma fluent por

Assert.That(() => demo.FooMethod(), Throws.Nothing);

Pero todo esto es con NUnit.
Imaginemos ahora que dejamos a NUnit a un lado y nos ponemos manos a la obra con xUnit.
¿Cómo podríamos hacer lo mismo?.

En xUnit no existe DoesNotThrow, pero existe una forma muy elegante de hacer prácticamente lo mismo.

Básicamente deberíamos hacer algo parecido a lo siguiente:

var ex = Record.Exception(() => demo.FooMethod());
Assert.Null(ex);

Record nos permite grabar o registrar las acciones del usuario con el Test, por lo que una vez hecho esto, lo único que tenemos que ver es si se ha producido una excepción en nuestro Test como he puesto anteriormente.

El ejemplo de Test con xUnit completo quedaría de la siguiente forma:

using Xunit;

namespace FooTests
{
    public class MyUnitTest
    {
        [Fact]
        public void TestMethod1()
        {
            var demo = new Demo();

            var ex = Record.Exception(() => demo.FooMethod());
            Assert.Null(ex);
        }
    }

    public class Demo
    {
        public void FooMethod()
        {
        }
    }

}

Para forzar que el Test no pase, podríamos cambiar el código del método a probar de esta forma:

public void FooMethod() => throw new System.Exception();

Como podemos observar, entre NUnit y xUnit, validar si en nuestro Test se ha producido o no alguna excepción para un método o líneas concretas de ejecución es en ambos casos muy similar.

Happy Coding!