Bienvenido a Marklogic

Introducción

En este post tratare de explicarte que es Marklogic, que ofrece para el desarrollo de aplicaciones que tienen que manejar grandes cantidades de información o Big Data y un resumen de todas las herramientas que tiene para la elaboración de sistemas eficientes en el manejo, control, transformación, búsqueda y presentación de datos. 

Este post tiene la intención de crear una guía que sirva para iniciar en el mundo de Marklogic y el desarrollo de aplicaciones Big Data, pero no esta de más aclarar que lo que aquí se encuentra no es más que la interpretación y el conocimiento que el autor posee sobre esta tecnología, la cual ha sido adquirida mediante la experiencia de estar realizando aplicaciones de Big Data para empresas con grandes cantidades de información, soluciones que ha sido desarrolladas por un equipo excepcional de trabajo de la compañía Yuxi Pacific de la cual hago parte. 

Si deseas tener información mas detallada puedes visitar la pagina oficial de Marklogic y encontraras toda la documentación necesaria.

Que es Marklogic?

Algunos pueden decir que Marklogic es una Base de Datos NoSQL, pero yo diría que están equivocados, Marklogic es mucho mas que eso, es una plataforma para el desarrollo de aplicaciones Big Data con herramientas de ultima generación que brinda grandes facilidades y utilidades para el control, transformación y presentación de grandes volúmenes de información. Pero creo que esto nos deja en el mismo punto. Por eso vamos a explicar que son Bases de Datos SQL y que es Marklogic.

Todos en algún momento de nuestra travesía por el mundo del desarrollo de aplicaciones tuvimos que habernos topado con una base de datos relacional, esas bases de datos que tienen estructuras fijas como tablas, llaves foráneas, principales, JOINS, etc. Estas bases de datos son fijas dado que debemos diseñar la estructura de cada tabla, definir cuales son las llaves y se les conoce como relacionales por que permiten JOINS (relaciones) entre las tablas para referenciar valores de padre/hijo. 

Pero porque explicamos que son bases de datos SQL? Que tiene que ver Marklogic con esto?, bueno, la respuesta es que Marklogic tiene una base de datos NoSQL, esto es un nuevo paradigma que difiere del modelo de bases de datos relacionales, en las bases de datos NoSQL no hay estructuras fijas, no soportan relaciones y algunas no soportan ACID( atomicidad, coherencia, aislamiento y durabilidad). La buena noticia de esto es que Marklogic tiene una base de datos NoSQL basada en XML que además soporta ACID, es horizontalmente escalable, indexación en tiempo real y muchas otras cualidades que hacen de Marklogic una muy poderosa y confiable base de datos.

Pero con esto que vimos aun hay preguntas, por ejemplo, Porque Marklogic es una plataforma si lo único que se ha explicado dice que Marklogic es una base de datos?, pues bien, aquí esta la explicación de porque Marklogic es una plataforma. Cuando se decide iniciar a desarrollar aplicaciones con Marklogic nos encontramos con una plataforma que además de ofrecernos todas estas herramientas de bases de datos, nos ofrece las siguientes herramientas:

• Servidor de Aplicaciones(App Servers): Marklogic nos permite crear servidores HTTP, WebDav, XDBC y ODBC que ofrecen una amplia lista de posibilidades de colaboración y de desarrollo. Porque Marklogic nos permite crear aplicaciones directamente en su sistema o podemos dejar las funcionalidades de la aplicación en entornos como Java, .NET, C++ y conectarnos con Marklogic para usarlo como Base de datos.

• Generador de Aplicaciones(Application Builder): Interfaz ofrecida por Marklogic para gestionar la creación de aplicaciones, bases de datos y todo lo referente a las tareas que se deben realizar cuando queremos desarrollar una aplicación en Marklogic.

• Administrador de Configuración(Configuration Manager): Interfaz ofrecida por Marklogic para realizar configuraciones de las bases de datos de manera muy fácil y amigable. Esta herramienta nos permite importar y exportar las configuraciones de la base de datos.

• Tablero de Monitoreo(Monitoring Dashboard): Interfaz ofrecida por Marklogic para realizar seguimiento de las operaciones (querys) que se están realizando en el sistema, espacio en disco, estadísticas de carga y mucho mas para el control de cargas en la base de datos.

• Query Console: Consola ofrecida por Marklogic en la cual se pueden ejecutar todo tipo de comandos para realizar consultas, actualizaciones, cargas de archivos, eliminación de archivos, etc. Es una gran herramienta para el desarrollo de aplicaciones ya que Marklogic no tiene uno de los mejores sistemas de depuración, por lo tanto realizar las funciones y probarlas directamente en la consola es una muy buena opción.

• CPF(Content Processing Framework): Como sus siglas lo indican es un framework para el procesamiento de contenido, el cual nos permite realizar casi cualquier tipo de proceso en una maquina de estados que cuenta con prioridades, múltiples decisiones en un mismo estado y diferentes medios para inicializar los procesos. El CPF es una gran herramienta para el desarrollo de aplicaciones que necesitan enriquecer su contenido y realizar transformaciones.

• REST API: Marklogic cuenta con una API muy robusta la cual puede ser consumida con gran facilidad y puede ser desarrollada de manera guiada. Esto nos permite enfocarnos en el desarrollo de la aplicación y dejarle el trabajo de exponer nuestros datos a la API de Marklogic.

Estas son solo unas de las herramientas que posee Marklogic para el desarrollo de aplicaciones de Big Data, si quieren descubrir que mas ofrece Marklogic pueden visitar su página web y encontrar mas detalles. Sin embargo no quiero dejar de contarles cuanto se aumentan las posibilidades de concurrencia y manejo de datos cuando se combinan dos tecnologías como Hadoop y Marklogic. El poder de procesamiento y respuesta que ofrece esta combinación es el escenario ideal para realizar aplicaciones de tiempo real reduciendo costos de procesamiento y aprovechando al máximo las características ofrecidas por ambas, para mas información no dejes de revisar este enlace Hadoop y Marklogic.

Conclusiones

Marklogic es una gran plataforma que tiene ya mas de 12 años de experiencia haciendo lo que en estos momentos esta de moda que es Big Data. Con la virtud que esta basada en XML, lo que nos ofrece un nivel muy alto de colaboración y manejo de nuestra información. Obviamente, no es la solución a todos los problemas que se pueden presentar cuando se esta desarrollando una aplicación que debe responder a grandes requerimientos de procesamiento, respuesta y concurrencia. Pero es una muy buena opción que por el momento esta dando grandes resultados para las personas que estamos trabajando con esta herramienta y las cosas que vienen en camino como el soporte de búsquedas semánticas con SPARQL va abrir el abanico de posibilidades.

Espero este post sirva para que se animen a conocer Marklogic y para que se den la oportunidad de conocer nuevas herramientas y paradigmas. Esperen los siguientes post acerca de como comenzar a desarrollar aplicaciones con Marklogic y como diseñar soluciones con este nuevo paradigma. 

Saludos y recuerden dejar su comentario.

Read More

Chat sencillo con Node.js, Socket.io y HTML

Pre-requisitos

Para poder realizar esta guía debes tener instalado Node.js y npm previamente (luego realizare un post sobre esto). Además de tener un explorador con el cual podamos soportar javascript y html5.

Introducción

La idea de este post es tratar de explicar como se puede realizar un Chat simple utilizando Node.js, HTML, Javascript y Web Sockets. Se debe aclarar que esto es totalmente académico y por motivos de explicar las posibilidades que brinda Node.js para realizar aplicaciones en tiempo real. 

Quiero darle gracias especiales a Julian Duque (@julian_duque) por la conferencia en MedellinJS (@medellinjs) del uso de Web Sockets de la forma correcta. Aquí pueden ver la conferencia original de Julian Duque con la que me base para realizar este post. 

Que es WebSocket?

WebSocket según wikipedia "WebSocket es una tecnología que proporciona un canal de comunicación bidireccional y full-duplex sobre un único socket TCP". Y según el RFC-6455 "The WebSocket Protocol enables two-way communication between a client running untrusted code in a controlled environment to a remote host that has opted-in to communications from that code". 

El significado que yo interpreto es "WebSocket es un protocolo de comunicación que nos permite enviar y recibir información hacia y desde el servidor en un solo canal". Básicamente nos da la posibilidad de mantener una comunicación con el servidor y que este nos avise de algún cambio que haya ocurrido en nuestro back-end. Está herramienta nos permite realizar paginas mucho mas eficientes en el consumo de trafico de red, ya que antiguamente para estar consultando que estaba pasando en nuestro back-end debíamos realizar llamados periódicos a nuestro servidor usando Ajax y cuando encontráramos un cambio presentarlo en pantalla.

Por tanto el uso de WebSockets para la creación de paginas web de real time es una gran herramienta y abre el espectro para aplicaciones que tengan que estar revisando cambios en la Base de datos o en sistemas de archivo. 

Node.js , WebSockets, Socket.io y más..

En este momento para nadie debe ser un secreto que Node.js esta tomando mucha fuerza y esta permitiendo realizar aplicaciones realmente asombrosas. En este caso voy a explicar que posibilidades tenemos para usar WebSockets en nuestras aplicaciones Node.js.

WebSockets

En Node.js tenemos una librería que podemos usar para WebSocket que se llama "ws" (https://npmjs.org/package/ws) el cual dicen en su página de npm es posiblemente la mas rápida de todas las librerías realizadas para Node.js en el uso de WebSockets.

Ejemplo

Servidor

var WebSocketServer = require('ws').Server
  , wss = new WebSocketServer({port: 8080});
wss.on('connection', function(ws) {
    ws.on('message', function(message) {
        console.log('received: %s', message);
    });
    ws.send('something');
});

Cliente

var WebSocket = require('ws');
var ws = new WebSocket('ws://www.host.com/path');
ws.on('open', function() {
    ws.send('something');
});
ws.on('message', function(data, flags) {
    // flags.binary will be set if a binary data is received
    // flags.masked will be set if the data was masked
});

Socket.io

Aunque ws es probablemente el mecanismo mas eficiente para el uso de WebSockets, tiene limitaciones en cuanto el uso de los puertos, el envío de variables y el manejo de eventos personalizados. Por tanto hay librerías mucho mas completas y con herramientas que nos facilitan muchas operaciones. Es aquí donde entra Socket.io (https://npmjs.org/package/socket.io), que es probablemente la librería para el uso de WebSockets mas popular en Node.js.

Ejemplo

Servidor

var socketio = require('socket.io');

var http = require('http');

var fs = require('fs');

var server = http.createServer(function (req, res) {

  res.writeHead(200, { 'Content-type': 'text/html' });

  fs.createReadStream('./index.html').pipe(res);

});

server.listen(80);

var io = socketio.listen(server);

io.on('connection', function (socket) {

  socket.emit('Event', 'from server!');

  socket.on('Event', function (msg) {    console.log('Received: %s', msg);

    socket.emit('world');

  });

}); 

Cliente

<script src="/socket.io/socket.io.js"></script>
<script>
  var socket = io.connect('http://localhost');
  socket.on('Event', function (data) {
    console.log(data);
    socket.emit('otro evento', { my: 'data' });
  });
</script>

Engine.io

Todo indica que Socket.io es lo mejor para usar WebSockets en Node.js, pero se han presentado problemas en aplicaciones con mas de 100 usuarios concurrentes, es por esto que la comunidad ha intentado crear soluciones a estos problemas de concurrencia para la librería de Socket.io, por esto surge Engine.io.

Servidor

var engine = require('engine.io')
  , server = engine.listen(80)

server.on('connection', function (socket) {
  socket.send('utf 8 string');
});

Cliente

var engine = require('engine.io')
  , http = require('http').createServer().listen(3000)
  , server = engine.attach(http)

server.on('connection', function (socket) {
  socket.on('message', function () { });
  socket.on('close', function () { });
});

Manos a la obra

Lo primero que vamos hacer es instalar las dependencias que necesitamos para el chat, en este caso vamos a utilizar Socket.io. Entonces empecemos, creamos una carpeta y descargamos con npm las dependencias, para esto ingresamos a la consola de comandos y ejecutamos lo siguiente:

mkdir Chat
cd Chat
npm install socket.io

Una vez ejecutemos estos comandos vamos a tener un ambiente listo para desarrollar nuestra aplicación con socket.io en Node.js. Ahora nos dedicamos a crear el servidor del node.js que va manejar nuestro chat, para esto creamos un archivo llamado "chat.js" dentro de nuestra carpeta Chat con el siguiente código:

var socketio = require('socket.io');
var http = require('http');
var fs = require('fs');
var server = http.createServer(function (req, res) {
  res.writeHead(200, { 'Content-type': 'text/html' });
  fs.createReadStream('./index.html').pipe(res);
});
server.listen(8080);

Como pueden ver estamos creando las variables socketio, http y fs. La variable de socketio nos va permitir usar la librería socketio, la variable http nos va permitir iniciar un servidor http donde vamos a exponer nuestra pagina web y la variable fs nos permite leer archivos del sistema. Para esto iniciamos nuestro servidor el cual va soportar html y leemos un archivo html "index.html" el cual vamos a usar como nuestra vista. Finalmente lo que le decimos a nuestro servidor es que se va ejecutar en el puerto 8080. Este es el código del archivo html que debemos guardar al mismo nivel del archivo "chat.js":

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>WebSockets Chat Example</title>
        <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"> </script>
        <script src="/socket.io/socket.io.js"></script>
        <style>
            .leftSide{ float:left; min-width:25%; min-height:400px; margin:10px; padding:15px; border:1px solid #333;}

            .rightSide{ float:right; min-width:65%;min-height:400px; margin:10px; padding:15px;border:1px solid #333; }
        </style>
    </head>
    <body>
        <h2>Welcome to the WebSockets Chat</h2>
        <section class="user">
            <label>User Name </label> <input type="text" id="user"/>
            <input type="button" value="Join" id="btnJoin"/>
        </section>
        <section id="chat">
            <section class="leftSide"></section>
            <section class="rightSide"></section>
            <section>
                <input type="button" value="Send" id="send" style="margin:10px; padding:10px;" />
                <input type="text" id="textSend" style="margin:10px;"/>
            </section>
        </section>
    </body>
</html>

Con esto ya podemos ver nuestra aplicación corriendo con tan solo correr el siguiente comando:

node chat.js

Como ven ya tenemos nuestra pagina web, solicitando un usuario para iniciar el chat, por el momento nuestra pagina no va hacer nada, para agregar la funcionalidad de nuestro chat vamos agregar el siguiente código al archivo "chat.js":

var users = [];//Con esto manejamos el listado de nuestros usuarios
var io = socketio.listen(server);//Iniciamos la libreria con nuestro servidor


//Controlamos el evento cuando se conecte e imprimimos en consola el mensaje recibido

//emitiendo el evento hello hacia el cliente con un mensaje inicial.
io.on('connection', function (socket) {
  socket.on('hello', function (msg) {
    console.log('Received: %s', msg);
    socket.emit('hello', 'Hello from server');
  });

  socket.on('login', function (msg) {
    console.log('Received Login: %s', msg);
    socket.emit('login', {"user": "System","text": "Welcome to the chat"});
    users.push(msg);
  });



  //Por defecto enviamos un mensaje de bienvenida para el evento message

  socket.emit('message', '<p class="message">Welcome from server!</p>');
  

  //Controlamos el evento message y replicamos el mensaje a todos los clientes

  //que se encuentren conectados
  socket.on('message', function (msg) {
    console.log('Received message: %s', msg);
    var text = '<p class="message"><b>'+msg.user+'</b>:'+msg.message+'</p>';
    io.sockets.emit('message', {"user": msg.user,"text": text});
  });
  

  //Controlamos el evento list que nos va servir para ver el listado de usuarios

  //conectados
  socket.on('list', function (msg) {
    console.log('Received list: %s', msg);
     socket.emit('list', users);
  });

}); 

Ahora pasamos al lado del cliente donde vamos a consumir todos los eventos que acabamos de agregar a nuestro chat, además de algunos eventos para iniciar el chat y ocultar algunos controles en la vista. Para esto agregamos un elemento script en nuestro archivo "index.html" con el siguiente código:

//Inicializamos nuestras variables

var socket = null;
var user = null;


$(document).ready(function(){
     $("#chat").hide();//Ocultamos por defecto el layer del chat
     //controlamos el evento del boton de iniciar chat

$("#btnJoin").click(function(){
         socket = io.connect('http://localhost:8080');//iniciamos conexion con el server
         user = $("#user").val();//guardamos el usuario insertado en memoria
         socket.emit('login',user);//llamamos el evento login del server
         //Controlamos el evento cuando el servidor responda

socket.on('login', function (msg) {
             console.log('Received Login: %s', msg);
         });
         //Llamamos el evento de list para obtener los usuarios conectados

        socket.emit('list',"list");
         //Controlamos la respuesta del server 

socket.on('list', function (msg) {
             console.log('Received List: %s', msg);
             $(".leftSide").html(msg);
         });
         //Controlamos el evento message que enviará el servidor

        socket.on('message', function (msg) {
             console.log('Received Message: %s', msg);
             $(".rightSide").append(msg.text);
         });

         $("#chat").show();
         $(".user").hide();

});


$("#send").click(function(){
         socket.emit('message',{"user": user,"message": $("#textSend").val()});
     });

});

Con esto ya tenemos la logica del servidor y la logica del cliente para ejecutar nuestro chat. Por lo que ejecutamos el comando:

node chat.js

Pueden hacer la prueba entrando desde pestañas diferentes al puerto 8080 de su localhost, utilizando diferentes exploradores o si quieren hacerlo exponiendo la dirección en una red. A continuación como quedaron cada nuestros dos archivos:

chat.js

var socketio = require('socket.io');
var http = require('http');
var fs = require('fs');
var server = http.createServer(function (req, res) {
  res.writeHead(200, { 'Content-type': 'text/html' });
  fs.createReadStream('./index.html').pipe(res);
});
server.listen(8080);


var users = [];//Con esto manejamos el listado de nuestros usuarios
var io = socketio.listen(server);//Iniciamos la libreria con nuestro servidor



//Controlamos el evento cuando se conecte e imprimimos en consola el mensaje recibido

//emitiendo el evento hello hacia el cliente con un mensaje inicial.
io.on('connection', function (socket) {
  socket.on('hello', function (msg) {
    console.log('Received: %s', msg);
    socket.emit('hello', 'Hello from server');
  });

  socket.on('login', function (msg) {
    console.log('Received Login: %s', msg);
    socket.emit('login', {"user": "System","text": "Welcome to the chat"});
    users.push(msg);
  });



  //Por defecto enviamos un mensaje de bienvenida para el evento message

  socket.emit('message', '<p class="message">Welcome from server!</p>');
  

  //Controlamos el evento message y replicamos el mensaje a todos los clientes

  //que se encuentren conectados
  socket.on('message', function (msg) {
    console.log('Received message: %s', msg);
    var text = '<p class="message"><b>'+msg.user+'</b>:'+msg.message+'</p>';
    io.sockets.emit('message', {"user": msg.user,"text": text});
  });
  

  //Controlamos el evento list que nos va servir para ver el listado de usuarios

  //conectados
  socket.on('list', function (msg) {
    console.log('Received list: %s', msg);
     socket.emit('list', users);
  });


});

index.html

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>WebSockets Chat Example</title>
        <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"> </script>
        <script src="/socket.io/socket.io.js"></script>

        <script>

            //Inicializamos nuestras variables

var socket = null;
var user = null;


$(document).ready(function(){
     $("#chat").hide();//Ocultamos por defecto el layer del chat
     //controlamos el evento del boton de iniciar chat

$("#btnJoin").click(function(){
         socket = io.connect('http://localhost:8080');//iniciamos conexion con el server
         user = $("#user").val();//guardamos el usuario insertado en memoria
         socket.emit('login',user);//llamamos el evento login del server
         //Controlamos el evento cuando el servidor responda

socket.on('login', function (msg) {
             console.log('Received Login: %s', msg);
         });
         //Llamamos el evento de list para obtener los usuarios conectados

        socket.emit('list',"list");
         //Controlamos la respuesta del server 

socket.on('list', function (msg) {
             console.log('Received List: %s', msg);
             $(".leftSide").html(msg);
         });
         //Controlamos el evento message que enviará el servidor

        socket.on('message', function (msg) {
             console.log('Received Message: %s', msg);
             $(".rightSide").append(msg.text);
         });

         $("#chat").show();
         $(".user").hide();

});


$("#send").click(function(){
         socket.emit('message',{"user": user,"message": $("#textSend").val()});
     });

});
        </script>
        <style>
            .leftSide{ float:left; min-width:25%; min-height:400px; margin:10px; padding:15px; border:1px solid #333;}

            .rightSide{ float:right; min-width:65%;min-height:400px; margin:10px; padding:15px;border:1px solid #333; }
        </style>
    </head>
    <body>
        <h2>Welcome to the WebSockets Chat</h2>
        <section class="user">
            <label>User Name </label> <input type="text" id="user"/>
            <input type="button" value="Join" id="btnJoin"/>
        </section>
        <section id="chat">
            <section class="leftSide"></section>
            <section class="rightSide"></section>
            <section>
                <input type="button" value="Send" id="send" style="margin:10px; padding:10px;" />
                <input type="text" id="textSend" style="margin:10px;"/>
            </section>
        </section>
    </body>
</html>

Conclusiones

Node.js es un lenguaje que esta avanzando muy rápido y nos permite realizar aplicaciones realmente emocionantes para tiempo real y muchos mas escenarios. El ejemplo que realice no tiene en cuenta detalles de estilos, validaciones o rendimiento, solo fue un ejemplo básico de como podemos utilizar las herramientas que nos brinda Node.js para hacer aplicaciones con WebSockets. 

Si te sirvió esta guía por favor deja un comentario y si no te sirvió también. 

Read More

Marklogic - Tests Unitarios con xray

Marklogic -  Tests Unitarios con xray

Descripción

Esta guía pretende explicar de manera detallada como utilizar las herramientas básicas que ofrece la librería de Test Unitarios xray ( https://github.com/robwhitby/xray ). Para esto vamos a realizar el paso a paso de la instalación de esta librería en un entorno Marklogic y vamos a explicar como utilizar esta librería en los diferentes proyectos.

Agenda

1. Pre-requisitos
2. Instalación
3. Marklogic, XQuery y xray
4. Ejemplo
5. Conclusiones

1. Pre-requisitos

Para el correcto entendimiento de esta guía debes tener previos conocimientos en el entorno de Marklogic y su lenguaje de programacion XQuery. Si no tienes idea de lo que estoy hablando, te invito a que visites la pagina de tutoriales y guias que ofrece Marklogic.

Se debe tener el código fuente de xray el cual se puede descargar desde el sitio oficial https://github.com/robwhitby/xray.

Debes tener instalado Marklogic, para esta libreria necesitas la version 6.0 o mayor.

2. Instalación

Para iniciar la instalación de la librería xray necesitamos un HTTP server en Marklogic, para esto nos dirigimos al servidor de administración de Marklogic ( http://localhost:8001 ) en la opción 

Groups->Default->App Servers->Create HTTP

 Cuando hayas dado click a esta opción vas a ver el formulario para crear el HTTP, ingresamos los datos del servidor que mas concuerden con tu gusto y con los puertos libres que poseas (ver Imagen 1). Para este ejemplo yo tengo los siguientes datos (los demás datos no son relevantes):

• Server name : xray-http-server
• root : /Users/fabianjaramillo/XQuery/xray
• port : 9000

Imagen 1

Como se puede ver en la imagen, yo descargue el zip de la pagina oficial de xray y lo descargue en la carpeta xray ubicada en "/Users/fabianjaramillo/XQuery/xray" de mi equipo. Esta carpeta debe contener exactamente como lo muestra la imagen a continuación (ver Imagen 2).

Imagen 2

Esta es la estructura de archivos que al descomprimir el zip de xray deben obtener, para nuestro ejemplo vamos a modificar esta estructura y la carpeta finalmente debe lucir así (ver Imagen 3).

Imagen 3

Con todo esto verificado ya solo resta presionar el botón de "ok" y Marklogic creara el servidor, esto puede fallar si el puerto que se le asigno esta siendo ocupado por otro proceso o aplicación. Con este proceso completado ya tendras instalado un servidor HTTP corriendo en el puerto que hayas designado, en mi caso el puerto 9000 corriendo con la libreria de xray para Tests Unitarios con XQuery.

3. Marklogic, XQuery y xray

Marklogic es el entorno que nos permite correr los servidores HTTP con XQuery y sus multiples funcionalidades de manejo, control y transformacion de documentos XML. En este entorno lo primordial es la estructura de nuestros documentos, por tanto xray se convierte en una herramienta muy util a la hora de realizar Test Unitarios para los proyectos que estemos desarrollando sobre Marklogic. 

xray es una librería que esta bajo la licencia Apache 2.0, que esta escrita en XQuery y de la cual pueden encontrar más información en su pagina oficial https://github.com/robwhitby/xray. Esta librería nos permite construir Tests Unitarios de manera muy fácil y organizada, ya que posee la opción de evaluar una carpeta y realizar todos los tests que en ella se encuentren. Habilidad que nos permite mantener los tests organizados por módulos, paginas, archivos, funcionalidad, etc.

xray nos permite realizar diferentes tipos de evaluaciones por tipo, por valor, por namespace, por tipo de transacción, etc. Con todas las posibilidades que ofrece nos deja un campo muy grande respecto a lo que debemos evaluar en nuestros proyectos. Es por ese motivo que yo recomiendo empezar evaluando las estructuras que esperamos deben retornar nuestros procesos, para ir conociendo la librería y luego proceder con evaluaciones de procesos mas complejos que incluyan lógica de negocio y comandos propios de Marklogic.

4. Ejemplo

Para nuestro ejemplo vamos a usar la creación de un usuario como contexto de nuestras pruebas unitarias y vamos a enfocarnos en evaluar las estructuras resultantes de nuestro proceso. Para aterrizar un poco mas el ejemplo voy a redactar un pequeño requerimiento, del cual luego procederemos a realizar el Test Unit que finalmente ejecutaremos en la consola de Marklogic.

Requerimiento: Permitir crear usuarios en el sistema incluyendo toda la información relevante que a continuación se detalla:

• Nombre
• Apellido
• Edad
• Telefono
• Ciudad
• Contraseña
• Usuario

Codigo

xquery version "1.0-ml";

module namespace test = "http://github.com/robwhitby/xray/test";
import module namespace assert = "http://github.com/robwhitby/xray/assertions" at "/src/assertions.xqy";

declare namespace xray = "http://github.com/robwhitby/xray";
import module namespace utils = "utils" at "utils.xqy";


(: all public functions are evaluated by the test-runner :)
declare %test:case function user-create-tests()
{
  let $nombre        := "Fabián"
  let $apellido        := "Jaramillo"
  let $edad             := 25
  let $telefono        := "300-6554-9854"
  let $ciudad          := "Medellin"
  let $contraseña   :=  xdmp:crypt2("123abc")
  let $user              := "fabjaror"
 
  let $user-model  := user:create-user($nombre,$apellido,$edad,$telefono,$ciudad,$user,$contraseña)
  let $user-exists   := //users/user[username eq $user]
 
  return (
    

    assert:not-empty($user-model/ID, "No se pudo crear el usuario"),
    assert:equal(fn:data($user-model/name), $nombre),
    assert:equal(fn:data($user-model/lastname), $apellido),
    assert:equal(fn:data($user-model/age), $edad),
    assert:equal(fn:data($user-model/phone), $telefono),
    assert:equal(fn:data($user-model/city), $ciudad),
    assert:equal(fn:data($user-model/username), $user),
    assert:equal(fn:data($user-model/pass), $contraseña),
    assert:not-equal(fn:data($user-exists/username), $user, "El usuario ya existia en la base de datos")

  )
};

5. Conclusiones

En proyectos elaborados con Marklogic y XQuery aun falta mucho terreno por recorrer en cuanto a mejores practicas, pero esta herramienta de xray nos acerca un poco al modelo normal de programación y de pruebas unitarias que tienen otros lenguajes mas robustos como .NET, Java, C++, etc. 

Aprovecha el uso de esta herramienta y ten en cuenta que no a todo se le puede generar pruebas unitarias y que para el caso particular de Marklogic yo recomiendo aplicar las pruebas inicialmente a las estructuras y luego ir avanzando para agregar procesos lógicos y funciones de Marklogic.

Si tienes preguntas, dudas o sugerencias por favor crea un comentario y te prometo que le daré respuestas lo mas pronto posible. 

Read More