IDisposable Thoughts

Es bastante común toparnos con casos en los que debemos asegurarnos que el mismo test se cumpla para varias condiciones. Imagínense el desarrollo de una calculadora o mucho mejor, el de alguna pieza de lógica de negocio dependiente de data. En vez de escribir ciclos dentro de nuestro test o peor aún, escribir varios test para el caso, en XUnit.NET tenemos el apoyo de las “Theory” que son test que estan fuertemente ligados a los datos.

Los datos son pasados como parámetros del test y el origen de los datos depende de nuestro proveedor de datos seleccionado. En XUnit.NET Extensions tenemos de “cajita” varios proveedores de datos que podemos usar:

• InlineDataAttribute, los datos se presentan en línea en cada atributo
• ClassDataAttribute, los datos son proporcionados por una clase que implementa IEnumerable<T>
• PropertyDataAttribute, los datos son entregados por la propiedad de una clase que retorna IEnumerable<T>
• SqlServerDataAttribute, los datos vienen de una consulta de una base de datos de SQL Server
• OleDbDataAttribute, los datos tienen como origen una consulta de un proveedor OleDb
• ExcelDataAttribute, los datos tienen como origen una hoja de cálculo de Excel.

El uso de Theory y DataAttribute proporciona una agilidad increíble al probar ciertas condiciones que antes requeririan mucha más pericia. Depende de nosotros sacarle provecho

[Theory]
[InlineData(1, 2, 3)]
[InlineData(4, 5, 9)]
public void It_can_use_correctly_the_data_attribute(int a, int b, int result)
{
    Assert.Equal(result, (a + b));
}

[Theory, ExcelData("myTestData.xls", "SELECT a, b, result FROM Data")]
public void It_can_use_correctly_the_data_from_an_excel_file(int a, int b, int result)
{
    Assert.Equal(result, (a + b));
}

Bien, hasta aquí llegamos con las Extensiones de XUnit.NET, la próxima entrega veremos como extender a nuestro antojo XUnit.NET

FreezeClock es uno de esos atributos maravillosos de XUnit.NET, nos permite “congelar” el reloj (tal como lo dice su nombre) en un tiempo dado y de esa manera comprobar que operaciones que dependen de tiempo se lleven acabo exitosamente. En versiones anteriores a la 1.5 FreezeClock cambiaba el tiempo mostrado por DateTime.Now, pero esto causaba problemas con ciertas implementaciones, así que en XUnit.NET 1.5 se debe utilizar la clase Clock y su propiedad Now (Clock.Now) en vez de DateTime.Now para efectos de las pruebas, de igual manera podríamos ver a Clock.Now como un clon de DateTime.Now en todos sus sentidos.

[Fact]
public void It_should_fail_because_clock_are_not_frozen()
{
    var clock1 = Clock.Now;
    Thread.Sleep(1000);
    var clock2 = Clock.Now;
    Assert.NotEqual(clock1, clock2);
}

[Fact, FreezeClock]
public void It_should_pass_because_clock_are_frozen()
{
    var clock1 = Clock.Now;
    Thread.Sleep(1000);
    var clock2 = Clock.Now;
    Assert.Equal(clock1, clock2);
}

[Fact]
public void Clock_time_must_be_lesser_than_a_second_different_from_now()
{
    var now = DateTime.Now;
    var clock = Clock.Now;
    Assert.True((clock - now).Milliseconds < 1000);
}

A veces es necesario (por alguna razón extraña), mostrar el inicio y el fin de un test en la consola, con el tiempo de inicio y tiempo de fin (imaginémonos un test de performance sencillo); para esos menesteres tenemos a nuestro amigo TraceAttribute, que no hace más que enviar a la salida Trace el inicio y el fin del test, un atributo sencillo de entender.

[Fact, Trace]
public void Must_sent_to_trace_console_start_and_end_time_of_test()
{
    Assert.True(true);
}

AutoRollbackAttribute

Comunmente cuando trabajamos con bases de datos, es bastante común el toparnos con transacciones, o mejor aún, toparnos con código que para simplificarnos las cosas debería correr dentro de una transacción. Por ejemplo, un test contra la base de datos que haga ciertos inserts, pero al final del test no nos importa el resultado y simplemente descartamos la transacción, por lo tanto nada fue insertado o modificado en la base de datos. Para esas tareas tenemos al atributo AutoRollbackAttribute, que simplemente al inicio del test crea una transacción y al final del test descarta la transacción. Es dificil probar código transaccional, pero con la “descripción” de que realiza el test, simplemente podemos ver si hay o no una transacción creada.

// NOTE: It Requires referece to System.Transactions
[Fact]
public void When_no_autorollback_is_present_there_is_no_transaction()
{
    Assert.Null(Transaction.Current);
}

[Fact, AutoRollback]
public void When_autorollback_is_present_there_is_a_transaction()
{
    Assert.NotNull(Transaction.Current);
}