IDisposable Thoughts

El día de ayer publiqué mi primer post corto acerca de XUnit.Net, e inmediatamente después alguien me hizo una pregunta, la cuál parafraseando va algo así:

“Puedo testear o ver el mensaje retornado por la excepción y así asegurarme que es una excepción específica”

No voy a discutir si esto esta bien o mal (en cuanto a la especificidad de la excepción), pero me parece interesante la pregunta. Como mencionamos ayer, podemos probar que una excepción es arrojada mediante el método “Throws” de la clase Assert:

public void ThrowOperation()
{
    throw new InvalidOperationException("My message");
}

[Fact]
public void TestAssertWithException()
{
    Assert.Throws<InvalidOperationException>(() => ThrowOperation());
}

El detalle es que Assert.Throws no solamente se asegura que la excepción fue arrojada, sino que efectivamente retorna la excepción al sistema como un retorno más, de esta manera podemos hacer cosas como:

public void ThrowOperation()
{
    throw new InvalidOperationException("My message");
}

[Fact]
public void TestAssertWithMessage()
{
    var ex = Assert.Throws<InvalidOperationException>(() => ThrowOperation());
    Assert.Equal("My message", ex.Message);
}

De esta manera no sólo podemos probar que la excepción es efectivamente arrojada, sino que también podemos probar sin ningún problema otros atributos de la excepción como tal. ¿Interesante verdad?

Cómo siempre, cualquier pregunta o comentario somos oidos abiertos

Continuando con mi corta serie acerca de XUnit, algo que es sumamente útil en las pruebas es verificar si un item se encuentra o no en una colección. En XUnit.Net esto es sumamente fácil, simplemente usamos los métodos Contains y DoesNotContains los cuales también funcionan con strings.

private readonly int[] numbers = {1, 2, 3, 4, 5, 6};

[Fact]
public void It_must_return_true_if_number_is_in_collection()
{
    Assert.Contains(1, numbers);
}

[Fact]
public void It_must_return_true_if_number_is_not_in_collection()
{
    Assert.DoesNotContain(7, numbers);
}

[Fact]
public void It_must_return_true_if_string_contains_substring()
{
    Assert.Contains("hola", "hola mundo");
}

[Fact]
public void It_must_return_true_if_string_does_not_contains_substring()
{
    Assert.DoesNotContain("adios", "hola mundo");
}

De igual manera tenemos métodos para verificar si una colección se encuentra vacía o no, obviamente nuestros métodos en cuestion seran Empty y NotEmpty (estos no funcionan con strings).

private int[] numbers = { 1, 2, 3, 4, 5, 6 };

[Fact]
public void It_must_return_true_if_collection_is_not_empty()
{
    Assert.NotEmpty(numbers);
}

[Fact]
public void It_must_return_true_if_collection_is_empty()
{
    int[] empty = {};
    Assert.Empty(empty);
}

Un par de Assert’s extras que vienen con XUnit.NET y son sumamente útiles, son aquellos capaces de trabajar con rangos, y estos pueden usar nuestros IComparer<T>, como siempre, nada explica mejor que un FactSet

[Fact]
public void It_must_assert_number_is_in_a_range_of_numbers()
{
    Assert.InRange(1, 1, 3);
    Assert.InRange(2, 1, 3);
    Assert.InRange(3, 1, 3);
    Assert.NotInRange(4, 1, 3);
    Assert.NotInRange(0, 1, 3);
}

[Fact]
public void It_must_assert_letter_is_in_a_range_of_letters()
{
    Assert.InRange("a", "a", "d");
    Assert.NotInRange("e", "a", "d");
    Assert.NotInRange("B", "a", "b");
    Assert.InRange("B", "a", "b", StringComparer.InvariantCultureIgnoreCase);
}

Otro aspecto que solemos probar es si una instancia es asignable, del tipo o derivada (implementada) a partir de otro tipo, en otras palabras, si hereda o implementa a alguien más. Esto es facil con IsType e IsAssignableFrom

[Fact]
public void It_must_assert_object_is_of_same_type()
{
    var item = new MySimpleEntity();
    Assert.IsType<MySimpleEntity>(item);
    Assert.IsNotType<IDoable>(item);
}

[Fact]
public void It_must_assert_object_is_assignable_from_type()
{
    var item = new MySimpleEntity();
    Assert.IsAssignableFrom<IDoable>(item);
}

Y por último, a veces necesitamos probar que una instancia representa la misma instancia que otra, no precisamente que es “igual”, esto lo logramos con “Same”:

[Fact]
public void It_must_assert_object_is_the_same_instance()
{
    var item = new MySimpleEntity();
    var other = item;
    var another = new MySimpleEntity();

    Assert.Same(item, other);
    Assert.NotSame(item, another);
}

Bien, continuaremos luego con más XUnit.NET, todo esto como un empujon para animarlos a probar TDD y en especial esta Testing Framework sumamente útil

Saludos!