3- Integración continua con Delphi (Jenkins) – Primer proyecto
Llegados a este punto (y vistas las entradas anteriores) ya tenemos completa nuestra configuración para poder automatizar un proyecto. Así que vamos a ver los pasos para generar nuestro primer proyecto en Jenkins que nos permitirá automatizar la generación/ejecución de la aplicación de pruebas unitarias (DUnitX).
Antes de continuar os dejo los links a las otras entradas de esta serie (las anteriores y las previstas):
1- Integración continua con Delphi (GIT)
2- Integración continua con Delphi (Jenkins)-Instalación
3- Integración continua con Delphi (Jenkins) – Primer proyecto
4- Integración continua con Delphi (Jenkins) – Pipelines
Para poder continuar con el artículo, primero vamos a crear 2 proyectos de Delphi. El primero será nuestro proyecto de prueba y el segundo serán los Test Unitarios (con DUnitX) sobre ese proyecto.
Ambos ya los tenéis subidos al repositorio con el que estamos trabajando desde el inicio de las entradas de esta serie (ahora ya está público y accesible):
https://github.com/NeftaliBlog/Ejemplos/
Contenido
PROYECTOS DE TRABAJO
- Proyecto de prueba: Continuaré con el proyecto que implementé en la primera entrada y que nos sirvió para ilustrar los primeros pasos con GIT. A este proyecto le he añadido una unit uFunciones.pas las funciones matemáticas básicas, sobre la que crearemos test unitarios con DUnitX. El formulario tiene una estructura como la que veis en la imagen.
- Proyecto de Test Unitarios (DUnitX): Proyecto con DUnitX que contiene los test unitarios sobre las funciones definidas en la unit uFunciones.pas. La estructura de la clase de test es la que veis en la imagen siguiente.
He añadido unos cuantos tests que nos servirán para las pruebas.
No voy a profundizar mucho más, en esta entrada, en el tema de DUnitX y pruebas unitarias. Si os interesa saber más podéis revisar anteriores entradas que he publicado en el blog sobre TDD. En ellas he hablado sobre el tema. A continuación os dejo los links.
- 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 para test unitarios (“Bonus track”)
Por ahora para crear el proyecto de Jenkins, nos vamos a centrar en la aplicación de Test, ya que es el primero que debemos compilar y ejecutar en nuestro proceso (si los test unitarios fallan, ya no hace falta que sigamos con el resto).
FICHERO .BAT PARA COMPILAR PROYECTO DE TESTS
Para este primer ejemplo vamos a crear un fichero .BAT que nos permita compilar nuestro proyecto de tests (PTestFunciones.dproj). Para ello dentro del directorio donde se encuentra nuestro proyecto, basta con crear un fichero COMPILAR.BAT con el siguiente contenido:
@echo off
REM Si el parámetro es vacío… (para compilar en diferentes máquinas)
if not x==%1x goto PROGRAMFILESx86
REM Si el parámetro es x86
goto PROGRAMFILES:PROGRAMFILESx86
call «c:\Program Files (x86)\Embarcadero\Studio\20.0\bin\rsvars.bat»
goto BUILD
:PROGRAMFILES
call «c:\Program Files\Embarcadero\Studio\20.0\bin\rsvars.bat»
REM realizar el Build del proyecto
:BUILD
msbuild.exe /nologo /v:m /t:build /p:Config=Release «PTestFunciones.dproj»
Hay 2 líneas importantes en ese fichero:
La primera importante es la llamada a ejecutar el fichero rsvars.bat, que nos permite preparar el entorno y todo lo que necesita MSBuild para compilar (hay 2 según el directorio de instalación).
La segunda línea importante es la última, que justo llama a MSBuild para compilar el proyecto con los parámetros que se ven arriba.
NOTA: En la llamada al fichero rsvars.bat, hay que tener en cuenta de modificar el path para que corresponda con la versión de delphi con la que trabajáis. En mi caso podéis ver que se trata de la versión 19.0 (Delphi 10.2.2)
Si lo ejecutamos desde la línea de comandos deberíamos obtener la versión release de nuestro proyecto.
CREAR UN PROYECTO EN JENKINS
Nuestro primer Job en Jenkins va a consistir en compilar el proyecto de Test Unitarios y ejecutarlos. Este proyecto debe realizar los siguientes pasos:
- Conectarse al repositorio de GIT
- Descargar el código actualizado del proyecto.
- Compilar el proyecto de test unitarios.
- Ejecutar el proyecto de test.
DUnitX devuelve un resultado que Jenkins “entiende”, así que si todos los pasos comentados anteriormente se ejecutan correctamente, el resultado del JOB de Jenkins será satisfactorio.
Además veremos cómo “ajustar” lo necesario para recibir los resultados (y más datos interesantes) por correo, aprovechando la configuración de correo que vimos en la entrada anterior.
Desde la ventana principal seleccionamos “Nueva Tarea”. El tipo del proyecto será el más simple (proyecto de estilo libre).
A continuación vamos a ir viendo las diferentes secciones a rellenar en el JOB para conseguir lo que necesitamos. Veréis que hay multitud de opciones y variantes, además de las que vamos a comentar, que luego podéis ir probando. Ya no entro en la utilización de plugins, que nos permitirán ampliarlas.
Empezamos por rellenar la “Descripción” de nuestro proyecto.
Lo siguiente que necesitamos es definir cual es el directorio local de la máquina de Jenkins, correspondiente a nuestro proyecto:
En la sección General hay un botón de avanzado que nos permite desplegar más opciones, entre ellas la de “Directorio de trabajo personalizado”. Ahí podemos configurar el path en la máquina de Jenkins donde estará nuestro proyecto.
CONFIGURAR ORIGEN DEL CÓDIGO FUENTE (github)
Antes de la compilación de nuestro proyecto, queremos que se descarguen los últimos cambios desde el repositorio de github, así que debemos configurarlo en la sección de “Configurar el origen del código fuente”.
AVISO: La primera vez que añadimos el repositorio, obtendremos un “warning” diciendo que debemos definir credenciales.
Así que hay que definir unas credenciales para que pueda acceder al repositorio sin problemas. Para ello navegaremos por el menú de Jenkins hasta llegar a esta pantalla y añadimos unas nuevas credenciales:
(Jenkins /Credentials / System / Global Credentials (unresttricted)
Debemos rellenar con los datos necesarios para acceder al repositorio:
Ahora ya podemos recargar la página y continuar con la configuración. Al volver a la configuración del proyecto, ya podemos seleccionar la URL de github y las credenciales que hemos definido para poder acceder a los datos para el repositorio.
DISPARADOR DE EJECUCIONES
La sección “Disparador de ejecuciones” nos permite configurar el “Cómo” y el “Cuando” se ejecuta nuestro proyecto de Jenkins.
Nos vamos a centrar en dos de las opciones (que son las que me parecen más interesantes y útiles).
CONSTRUIR TRAS OTROS PROYECTOS
Esta opción nos permite, tal y como dice su título, encadenar un proyecto tras la ejecución de otro. Además podemos escoger que la ejecución esté condicionada al resultado del primer proyecto.
Esta opción ya nos abre la puerta a encadenar la ejecución de varios proyectos que podamos tener definidos. Hay otras formas, pero esta es una forma muy sencilla de hacerlo.
En nuestro caso, podremos lanzar el proyecto que compila nuestro programa de prueba, condicionado al proyecto que compila y lanza el proyecto de test unitarios.
EJECUTAR PERIÓDICAMENTE
Esta opción nos permite ejecutar de forma periódica un proyecto de Jenkins. Por ejemplo, podemos configurar para que “cada día, por la mañana y por la noche se generen builds de nuestros proyectos”.
La programación de proyectos (tareas) sigue la sintaxis de cron (con pequeñas diferencias). Específicamente, cada línea consta de 5 campos separados por TAB o ESPACIOS en blanco:
- MINUTO
- HORA
- DIA DEL MES
- MES
- DIA DE LA SEMANA
Como ejemplo, en la imagen inferior podéis ver tres programaciones que podemos utilizar:
H 23 * * * -> Ejecutar cada día a las 23:00h
H/15 * * * * -> Ejecutar de forma continuada cada 15 minutos
30 20 * * 1-5 -> Ejecutar a las 20:30h de Lunes a Viernes (1-5)
SECCIÓN DE EJECUTAR
Una vez descargado el código, y definido cuando queremos realizar la ejecución de la tarea, debemos definir “qué queremos ejecutar” dentro del proyecto/tarea Jenkins. En este caso, queremos compilar y ejecutar nuestro proyecto de test unitarios.
COMPILAR UTILIZANDO COMANDOS WINDOWS
Para ellos debemos llegar hasta la sección “Ejecutar”. En este caso vamos a utilizar un fichero .BAT, así que seleccionaremos la opción de “Comando de Windows”. Y como comando escribiremos lo siguiente:
REM —- compilar nuestro proyecto de tests ————
call «.\Proyecto Pruebas CI\compilar.bat»
REM —— Ejecutar los test unitarios ——————–
call «.\Proyecto Pruebas CI\tests\Win32\Release\PTestFunciones.exe»
Como podéis ver he llamado a un fichero .BAT que realiza varias acciones. También podemos colocar la llamada al MSBuild desde esta sección del JOB, pero de esta forma (utilizando un fichero .BAT) me es más fácil realizar cambios en el proceso de compilación, cambiando directamente el fichero de procesamiento por lotes.
COMPILAR UTILIZANDO PLUGIN RAD STUDIO
También podemos utilizar el plugin de RAD Studio como hemos comentado. Si ya lo tenemos instalado, desde la sección de “Ejecutar” seleccionamos la opción:
“Build a RAD Studio project or project group”
En los parámetros para compilar podemos rellenar el Project/ProjectGroup, la versión con la que queremos compilar (si es que hemos instalado el plugin para varias versiones de RAD Studio) y parámetros (switch) opcionales para la compilación.
SECCIÓN “DESPUÉS DE EJECUTAR”
CONFIGURAR ENVÍO DE RESULTADOS POR CORREO
Por último nos queda configurar lo necesario para que al finalizar el Job de Jenkins podamos recibir notificaciones por correo de los resultados (también se pueden configurar otros pasos como el inicio de la ejecución).
Al final de la página para configurar el proyecto tenemos la sección llamada “Post-Build Actions” (“Acciones para ejecutar después” si tenemos la versión en español). En esa sección tenemos 2 opciones referentes a enviar correo.
-
E-mail Notification: Permite enviar un correo de una forma sencilla. Simplemente hemos de configurar la dirección de destino. El resto de opciones son las intrducidas en la configuración de Jenkins (y que vimos en la entrada anterior).
-
Editable Email Configuration: Esta opción nos permite configurar múltiples aspectos del correo que se va a enviar.
En este caso podemos utilizar variables para “personalizar” el correo a recibir. Y añadir texto y variables de entorno al Asunto y al cuerpo del mensaje.
La lista completa devariables disponibles la tenéis en este link:
http://localhost:8080/env-vars.html/
(o cambiando localhost por la IP de vuestra máquina de Jenkins)
Si por ejemplo, en el campo “Default Content”, colocamos lo siguiente:
$DEFAULT_CONTENT
——————————————————
Workspace: ${WORKSPACE}
Jobname: ${JOB_NAME}
Job URL: ${JOB_URL}
Build ID: ${BUILD_ID}
Build number: ${BUILD_NUMBER}
Build URL: ${BUILD_URL}
Build display name: ${BUILD_DISPLAY_NAME}
El resultado del email generado, en este caso, sería algo similar a este:
Depende de lo configurado podemos recibir mensajes al Iniciar, al terminar, cuando hay fallo cuando ha acabado correctamente,…
Y hasta aquí lo visto en esta entrada. Los Jobs, tal y como he comentado, poseen muchas más opciones pero es imposible verlas todas. Más aun si añadimos plugins que nos permiten ampliar las funcionalidades.
Como siempre los comentarios, sugerencias y criticas “constructivas” son bienvenidas.
Hasta la próxima!!
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,…
