Una de los principios de DevOps es automatizar todo. Las pruebas son muy importantes pero también deben ser eficaces y rápidas. En esta entrada vamos a mostrar cómo realizar pruebas automatizadas en PHP y NodeJS de manera rápida para agilizar nuestro desarrollo.

PHP

Framework Lumen

Para crear un micro servicio en PHP lo mejor es utilizar un microframework, que produce de manera rápida y limpia generar un servicio. Utilizaremos el framework Lumen porque emcabeza en la mayoría de las listas de los mejores microframework de PHP.

Instalamos con la línea de comando:

composer global require "laravel/lumen-installer"

Asegúrarse de que la ruta de instalación se encuentre en el PATH de su sistema operativo, si no ejecute el siguiente comando:

export PATH="$PATH:$HOME/.composer/vendor/bin"

Y listo. Una vez instalado procedemos a crear nuestro proyecto:

composer create-project laravel/lumen microservice "5.4.*"

Para comprobar que está corriendo, puede abrir el enlace que se encuentra en tu servidor en la carpeta /public.

Ahora editamos el archivo /routes/web.php para incluir nuestro microservicio:

<?php

$app->get('/', function (){
    return response()->json([
        'notas' => [
            'laboratorio_1' => 5.0,
            'laboratorio_2' => 5.0,
            'laboratorio_3' => 5.0,
            'blog' => 5.0,
        ]
    ]);
});

$app->post('/', function (){
    return response()->json([
        'notas' => [
            'laboratorio_1' => 5.0,
            'laboratorio_2' => 5.0,
            'laboratorio_3' => 5.0,
            'blog' => 5.0,
        ]
    ]);
});

Y listo. Si probamos nuestro microservicio en POST o por medio del navegador podemos ver nuestro resultado.

PHPUnit

El framework Lumen viene con PHPUnit de fabrica. Así que solo necesitamos crear nuestro archivo con las pruebas. en la carpeta /test crear un archivo MicroserviceTest.php con lo siguiente:

<?php

/**
 * Description of MicroserviceTest
 *
 * @author arturo
 */
class MicroserviceTest extends TestCase{
    
    /**
     * Service is running
     *
     * @return void
     */
    public function testService()
    {
        $responseGET = $this->call('GET', '/');
        $responsePOST = $this->call('GET', '/');
        
        $this->assertEquals(200, $responseGET->status());
        $this->assertEquals(200, $responsePOST->status());
    }
    
    /**
     * Response is ok
     *
     * @return void
     */
    public function testJson()
    {
        $responseGET = $this->call('GET', '/');
        $responsePOST = $this->call('GET', '/');
        
        
        $this->assertArrayHasKey('notas', $responseGET->original);
        $this->assertArrayHasKey('notas', $responsePOST->original);
        
        
    }
    
}

Con este script podemos evaluar si el servicio responde un estado 200 y que el JSON resultante tiene el atributo notas. Si pasamos el comando de PHPUnit en nuestro proyecto:

./vendor/bin/phpunit --bootstrap vendor/autoload.php tests/MicroserviceTest

Tendremos como resultado en la consola:

PHPUnit 5.7.27 by Sebastian Bergmann and contributors.

..                                                                  2 / 2 (100%)

Time: 52 ms, Memory: 6.00MB

OK (2 tests, 4 assertions)

Con esto podemos decir que tenemos un microservicio en PHP. El resultado del código puede encontrarse en mi repositorio público: https://github.com/arturoverbel/microservice_php_lumen.

NodeJS

En una de nustras entradas describomossobre NodeJS y cómo construir un proyecto esqueleto. http://micaminomaster.com.co/herramientas-desarrollo/nodejs-projecto-esqueleto-mvc-crud/.

Después de la instalación creamos nuestro proyecto con:

express --view=twig microservice

Y procedemos a editar el archivo /routes/index.js para agregar nuestros servicios:

var express = require('express');
var router = express.Router();

/* GET home page. */
router.get('/', function(req, res, next) {
    res.json({ 
        notas: {
            "laboratorio_1": 5,
            "laboratorio_2": 5,
            "laboratorio_3": 5,
            "blog": 5
        }
        
    });
});

/* GET home page. */
router.post('/', function(req, res, next) {
    res.json({ 
        notas: {
            "laboratorio_1": 5,
            "laboratorio_2": 5,
            "laboratorio_3": 5,
            "blog": 5
        }
        
    });
});

module.exports = router;

Y listo. De esta manera al correr el servidor con el comando:

DEBUG=microservice:* npm start

Podemos ver el mismo resultado en el navegador como usando Postman con el método POST.

Mocha

Para realizar las pruebas unitarias en NodeJS utilizamos Mocha,

Procedemos a instalar Mocha en nuestro proyecto:

npm install --save-dev mocha

También instalamos Chai el cual es una biblioteca de afirmaciones que le permite elegir la interfaz de afirmación que más le guste, incluyendo “afirmar”, “esperar” y “debería”. Es un complemento para Mocha.

npm install --save-dev chai

Importante agregar en package.json la dirección del módulo de mocha para correrlo más fácil

"scripts": {
    "start": "node ./bin/www",
    "test": "mocha"
},

Y creamos el archivo /test/test.js para incluir nuestras pruebas:

var expect  = require('chai').expect;
var request = require('request');

it('API status', function(done) {
    request('http://127.0.0.1:3000' , function(error, response, body) {
        expect(response.statusCode).to.equal(200);
        done();
    });
});

it('API body', function(done) {
    request('http://127.0.0.1:3000' , function(error, response, body) {
        var result = JSON.parse(body);
        expect(result).to.have.property('notas');
        done();
    });
});

Al correr nuestras pruebas (después de iniciar el proyecto de NodeJS) tenemos el siguiente resultado

Comando:

npm test

El resultado:

> microservice@0.0.0 test /home/arturo/Projects/nodejs/microservice
> mocha



  ✓ API status
  ✓ API body

  2 passing (28ms)

De esta manera pudimos crear dos servicios de manera rápida en PHP y NodeJS con pruebas incluidas. El código resultante puede encontrarse en https://github.com/arturoverbel/microservice_nodejs

Fuentes