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).