c# - tipos - ¿Hay alguna prueba más apropiada para probar si el constructor lanza una excepción?

tipos de excepciones en c#

Question

Normalmente se prueba, si se lanza una excepción en un método determinado, de la siguiente manera. Yo uso FluentAssertions :

[Fact]
public void Exception_gets_thrown()
{
    // Arrange
    var foo = new Foo("validArgument");

    // Act/Assert
    foo.Invoking(f => f.Bar(null))            // null is an invalid argument
       .ShouldThrow<ArgumentNullException>();
}

Pero, ¿cómo probar, si se lanza una excepción en el constructor? Simplemente lo hice así, pero ¿hay alguna forma más apropiada a través de FluentAssertions ?

[Fact]
public void Constructor_throws_Exception()
{
    // Arrange
    Action a = () => new Foo(null);         // null is an invalid argument

    // Act/Assert
    a.ShouldThrow<ArgumentNullException>();
}

Answer 1

Agregué un método auxiliar como el siguiente para usarlo cuando se prueban constructores:

static Action Constructor<T>(Func<T> func)
{
    return () => func();
}

que luego uso de esta manera:

Constructor(() => new Foo("bar", null))
.ShouldThrow<ArgumentNullException>()
.And
.ParamName
.Should()
.Be("baz");

Sé que es una cuestión de gusto personal, pero esto me parece un poco más limpio que tener que declarar y asignar un delegado primero.

Esto haría que el código en la pregunta original se vea así:

[Fact]
public void Constructor_throws_Exception()
{    
    // Act/Assert
    Constructor(() => new Foo(null)).ShouldThrow<ArgumentNullException>();
}

Answer 2

Así es exactamente como se supone que debe probar las excepciones y para eso se ShouldThrow<T>() y ShouldNotThrow<T>() . De hecho, el enfoque de Invoking() podría estar marcado como obsoleto en la próxima versión grande (2.0.0).