Ejemplo 2018-07: Fork j8583.

Resumen: 
Compilar j8583 en Java 6.

Descripción:
Este post será distinto a los anteriores.

En muchos sistemas legados, es normal encontrarnos con versiones antiguas de Java. En mi caso, ya les conté que he realizado un programa para autorizar transacciones. Dichas operaciones son recibidas en formato XML. Pero, el servicio que convierte la trama ISO8583 a XML, no reconocía el campo LLLLVAR del estándar.

La versión de la librería j8583 que usamos era 1.10.2. Todo bien. Pero uno de los campos (bit 127) estaba mapeado como LLLVAR y debíamos modificarlo.Un poco de buscar en internet y la solución se encontraba en la versión vigente (1.12.0). Como ya imaginarán, estaba compilado en Java 7 y no nos servía.

La solución, descargar las fuentes actuales y recompilarlo. Ante los errores, corregirlos y generar el jar.

Pero, con la intención de compartir este trabajo con alguien que tenga la misma necesidad; solicité al dueño del proyecto poder publicarlo y/o integrarlo al proyecto original. La respuesta fue:

Otras formas de colaborar son:

1. Reportar bugs
2. Solucionar bugs reportados e integrarlos
3. Realizar documentación y videos tutoriales

Código Fuente:
https://bitbucket.org/edgargs/j8583-java6.git
Bibliografía:
https://bitbucket.org/chochos/j8583
  
Configuración:
VSCode  1.23.1
Gradle 4.9
Java 6.0

Ejemplo 2018-06: Test SOAP.

Resumen: 
Testing de un WS Soap.

Descripción:
En el post anterior hice un ejemplo usando Spock para testear una librería. Pero, para las pruebas de integración, se usaba el programa SoapUI

Quize hacer el intento de escribir un test que consuma dicho WS. Luego de googlear; me encontré con dos librerías para escribir el cliente Soap. Son: GroovyWS y Reficio (soap-client). Decidí emplear el segundo, aunque tiene muchas dependencias.

Aprovecharé para mostrar un poco del uso de la famosa librería j8583, usando código Groovy. Se construye un mensaje "100" para consultar saldos de una tarjeta.

En este ejemplo usamos el método setupSpec() para realizar la comunicación con el servicio. Para ello, indicamos la ruta del WSDL y el método a invocar. Con esto, obtendremos la estructura de la petición.

Luego, generamos el mensaje. Esta petición es un XML, y lo construimos con el XmlSlurper.

Invocamos mediante el método client.post. Dado que es otro XML, parseamos la respuesta y recuperamos la etiqueta return.

Finalmente, evaluamos la respuesta.

Código Fuente:
https://github.com/edgargs/wsautorizador-test.git

Bibliografía:
http://projects.reficio.org/soap-ws/1.0.0-SNAPSHOT/manual.html 
  
Configuración:
Groovy  2.4.13
Spock 1.0

Ejemplo 2018-05: Pruebas Unitarias con Spock.

Resumen: 
Realizar TDD con Spock.

Descripción:
Debo confesar que anteriormente, no hacía Unit Test a mis programas. Aunque, reconocía la importancia y necesidad. Y como no quería las pruebas desde SaopUI, los implementé con Spock.

Sinceramente, es muy fácil escribir los test con Spock. Como indica las buenas prácticas: primero escribí la prueba, y luego el código que soporta dicha funcionalidad. El ciclo se repite hasta tener un código funcional y óptimo, porque continuamente vas depurando y mejorándolo. Por cierto, no nos olvidemos de emplear los patrones de diseño.

Entonces, como ejemplo desarrollé una librería que responda a los mensajes 0800 (echo test). El mensaje se recibe y responde en XML.

Construimos el mensaje con (Messages/TXN_FIN_REQ/TRACE,MESSAGE_TYPE). Lo enviamos al método y evaluamos el resultado (otro XML).

La implementación es en Java y xmlbeans (Apache) para parsear los mensajes. Evaluamos el tipo de mensaje y el trace recibido.

Al procesar los mensajes echo, construimos la respuesta pasándole el trace original.

Ejecutamos los test y vemos el resultado.

Código Fuente:
https://github.com/edgargs/autorizador-test.git

Bibliografía: 
https://www.paradigmadigital.com/dev/testing-orientado-bdd-spock-12/
  
Configuración:
Groovy  2.4.13
Spock 1.0

Ejemplo 2018-04: Procesos en paralelo con GPars.

Resumen: 
Ejecución de procesos en paralelo con GPars.

Descripción:
Uno de los ejemplos que hice, fue de concurrencia (). En él, hice uso de las clases que da Java (Executors, Future, etc). Pero parte del ecosistema de Groovy tenemos a GPars (Concurrency & Parallelism Framework).

 En el siguiente ejemplo, centrémonos en el método sendItems. De un conjunto de 30 items, se procesará en grupo de 10 (hilos): imprimir el valor del item y esperar 5 segundos.

La ejecución produce el siguiente resultado: tres grupos donde la secuencia de items no es secuencial.

 
Código Fuente:
https://gist.github.com/edgargs/938f69d7d945cf09df8eafbd9cde1094
 
Bibliografía: 
http://www.gpars.org/guide/guide/dataParallelism.html
https://www.ibm.com/developerworks/library/j-gpars/
  
Configuración:
Groovy  2.4.13
GPars 1.2.1

Ejemplo 2018-03: Parsear archivos XML.

Resumen: 
Manipular XML de forma sencilla con Groovy.

Descripción:
En una charla que di, me preguntaron sobre la forma de parsear XML. Quedó como tarea pendiente demostrar lo fácil que es. Este ejemplo nos acerca en la manera como podríamos emplearlo en nuestros proyectos.

En mi caso, por razones ajenas a mi voluntad, existe un programa que graba las peticiones en formato XML. Y luego llama a otro programa que leerá el archivo y generará la respuesta, en otro archivo (con formato XML). Durante las pruebas, hacer seguimiento a un transacción específica fue muy difícil. Debía buscar en ambos archivos (request y response) y ubicar los campos que debía evaluar.

Cómo solución, cree un script para procesar todas las peticiones de un día, generar un tabla (archivo con columnas) y poder visualizar la información necesaria.

Tenemos primero, el uso del operador "<<" para asignar elementos a una lista.

Considerar que existen dos opciones para parsear:

• groovy.util.XmlParser
  
• groovy.util.XmlSlurper
  

Hay diferencias sutiles, pero yo recomiendo XmlSlurper. De esta forma, acceder a un atributo lo podemos hacer con @.

Otro componente apreciado, es el operador "with".

Luego de formar el texto, agregamos la línea al archivo con el operador "<<".

Código Fuente:
https://gist.github.com/edgargs/ea58ee730ef5a48ff39271d6391e8360
 
Bibliografía: 
http://groovy-lang.org/processing-xml.html
  
Configuración:
Groovy  2.4

Ejemplo 2018-02: Java vs Groovy.

Resumen: 
Ejemplo de convertir una clase Java a código Groovy.

Descripción:
Muchas veces, poder medir los beneficios de trabajar con Groovy; resulta vacío sino no lo podemos cuantificar. Como parte de la charla "Introducción a Groovy", este post muestra los cambios del código para tener un webservice a partir de una clase Java.

1. El operador de acceso public es por defecto. El return es opcional.

2. Los tipos son inferidos al emplear def. Los paréntesis son opcionales. Listas y arreglos se tratan de la misma forma.


3. Uso del operador in. Empleo de cadenas interpoladas.  
4. Constructores dinámicos.

5. Adiós a los getters y setters. 


6. Triple comillas (dobles).
Código Fuente:
https://github.com/edgargs/power-groovy.git
 
Bibliografía: 
http://groovy-lang.org/documentation.html 
 
Configuración: 
SpringBoot 1.5.9
Groovy  2.4