/*Prog*/ Delphi-Neftalí /*finProg*/

Con la anterior entrada del blog completamos la serie sobre test unitarios y los frameworks a utilizar con Delphi, con una visión general sobre DUnitX. A continuación tenéis los links a las entradas de la serie.

• Test Unitarios; Introducción (Entrega 1)
• Test Unitarios; Framework DUnit (Entrega 2)
• Convertir Test de DUnit a DUnitX (Entrega 3)
• Test Unitarios; Framework DUnitX (Entrega 4)
• Entornos de Ejecución (“Bonus track”)

Esta última no estaba prevista inicialmente, pero la última ya era bastante extensa y no quise mezclar con el tema de DUnitX este “Bonus track”. Digamos que esta es como un apéndice a la serie.

DUnitX permite ejecutar los test que diseñamos utilizando diferentes salidas. Digamos que el programa de ejecución de test puede estar diseñado en “modo consola”, utilizando un ejecutable VCL o generando un programa FMX. No hablamos de los test en sí, sino del programa que nos muestra la salida y los resultados de la ejecución.

A continuación vamos a repasar casda uno de ellos.

SALIDA “MODO CONSOLA”

Por defecto cuando creamos el proyecto de test, se nos genera un proyecto de tipo CONSOLA, pero no es el único que podemos utilizar.  Este es el más básico y no nos permite interactuar con la ejecución o los resultados.

Si miramos el código del DPR (fichero de proyecto) veremos que aparece:

{$APPTYPE CONSOLE}

Y como ya hemos visto en las entradas anteriores, la salida de los test será algo parecido a la imagen siguiente.

UTILIZAR PROGRAMA VCL

Además del modo consola, que es la salida que se configura por defecto en los test que generamos utilizando el asistente que viene con Delphi, también podemos utilizar un interface generado con VCL.

Si ejecutamos nuestra pruebas de test con este último, la salida de los resultados será algo similar a la imagen siguiente:

En la parte izquierda nos aparecen los test (que podemos seleccionar) y en la parte derecha podemos ver la ventana de resultados.

En este caso ofrece 2 vistas; En “Modo Estructurado” y en “Modo Texto”. La primera es en formato de árbol donde tenemos una visión rápida de los test que han funcionado y de los que han dado error, y la segunda muestra resultado en formato texto, similares a los que vemos en la aplicación anterior de consola. Podéis ver la diferencia en las imágenes siguientes:

Al final los datos son los mismos en todos los casos, pero se nos presentan de diferente forma.

UTILIZAR PROGRAMA FMX (Firemonkey)

En la últimas versiones de Delphi que disponen de desarrollo para plataformas móviles, también podemos utilizar un interface desarrollado utilizando la librería Firemonkey (no es el más ágil de todos). Si ejecutamos los test utilizando esta interfaz para mostrar los resultados, veremos una imagen al acabar los test similar a esta:

En la parte izquierda podemos ver los test a ejecutar y en la parte derecha los resultados. En el caso de los test que fallan, nos muestra algo mas de información de cada uno de los tests que no se han ejecutado correctamente. A continuación las véis ampliadas.

Hasta aquí hemos visto las alternativas que ofrece el paquete DUnitX para mostrar los resultados de la ejecución de los test. Pero no son todos los posibles. Es más, nosotros mismos podríamos crear nuestro propio interface (aplicación) para ejecutar los test y mostrar los resultados como nos fuera más conveniente o cómodo.

PLUGIN TESTINSIGHT

Esto es lo que ha hecho Stefan Glienke con el pluging TestInsight. En este caso él ha optado por desarrollarlo como un plugin pra el IDE de Delphi y añadirle algunas opciones más de las que traen los que hemos visto anteriormente.

TestInsight es un plugin  que soporta versiones posteriores a Delphi XE y que permite integrar dentro del IDE un entorno de pruebas con algunas opciones más de las que posee en entorno estándar. La salida es parecida, pero algo más flexible.

Podéis descargar la instalación del plugin desde GitHub utilizando el siguiente enlace. Y también acceder a una pequeña Wiki con información.

Si queréis más información os recomiendo revisar esta entrada escrita por Agustín Ortu, donde se hace un repaso completo y mucho más detallado de cómo hacer funcionar este addin para el IDE.

Si ejecutamos el mismo proyecto, pero activando TestInsight, la salida que veremos será similar a esta:

En la parte superior cuenta con una barra de botones y opciones para ejecutar, filtrar, activar, desactivar test e incluso para ejecutarlos de forma repetitiva cuando el IDE esté “ocioso”.

PLANTILLA DE PROYECTO

Finalmente y basándome en esta consulta/respuesta en Stackoverflow, he generado esta plantilla que podéis utilizar en un proyecto de test. En la parte inicial aparecen 4 {$DEFINE}. Comentando tres de ellos y dejando uno sin comentar podéis ejecutar el mismo proyecto utilizando los 4 entornos vistos anteriormente (si habéis instalado TestInsight).

///// Selecciona 1 sólo segun interese  ////////////////////////
{.DEFINE UseWinConsole}
{.DEFINE UseVCL}
{.DEFINE UseFMX}
{$DEFINE UseTestInsight}
////////////////////////////////////////////////////////////////

Si os fijáis tenemos tres con un punto (comentadas) y una con el símbolo $, que es la que está “activa”.

Si miráis al completo el fichero DPR del proyecto, veréis que se añaden unas u otras units al uses de proyecto dependiendo del DEFINE activo, y se ejecutan unas u otras instrucciones dependiendo también del DEFINE seleccionado.

La parte de ejecución, podéis verla a continuación:

/////////////////////////////////////////////////////////////////////////
{$IFDEF TESTINSIGHT}
begin
  TestInsight.DUnitX.RunRegisteredTests;
  exit;
{$ENDIF}
/////////////////////////////////////////////////////////////////////////
{$IFDEF UseVCL}
begin
  Application.Initialize;
  Application.CreateForm(TGUIVCLTestRunner, GUIVCLTestRunner);
  Application.Run;
{$ENDIF}
/////////////////////////////////////////////////////////////////////////
{$IFDEF UseFMX}
begin
  Application.Initialize;
  Application.CreateForm(TGUIXTestRunner, GUIXTestRunner);
  Application.Run;
{$ENDIF}
/////////////////////////////////////////////////////////////////////////
{$IFDEF UseConsole}
var
  runner : ITestRunner;
  results : IRunResults;
  logger : ITestLogger;
  nunitLogger : ITestLogger;
 
begin
   try
      //Create the runner
      runner := TDUnitX.CreateRunner;
      runner.UseRTTI := True;
      //tell the runner how we will log things
      logger := TDUnitXConsoleLogger.Create(true);
      nunitLogger := TDUnitXXMLNUnitFileLogger.Create;
      runner.AddLogger(logger);
      runner.AddLogger(nunitLogger);
 
      //Run tests
      results := runner.Execute;
 
      System.Write('Done.. press  key to quit.');
      System.Readln;
 
   except
      on E: Exception do
         System.Writeln(E.ClassName, ': ', E.Message);
   end;
{$ENDIF}
/////////////////////////////////////////////////////////////////////////

Os adjunto el código completo del proyecto que he estado desarrollando para las anteriores entradas, con estas modificaciones en el DPR.

<Código fuente del proyecto>

Hasta aquí esta última entrada. Como siempre cualquier comentario, sugerencia, mejora, propuestas,… será bienvenida.

Hasta la próxima.

Germán Estévez

Embarcadero MVP.
Analista y Programador de Sistemas Informáticos.
Estudios de Informática (Ingeniería Técnica Superior) en la UPC (Universidad Politécnica de Barcelona).
Llevo utilizando Delphi desde su versión 3. Especialista en diseño de componentes, Bases de Datos, Frameworks de Persistencia, Integración Continua, Desarrollo móvil,…