Rango en pruebas unitarias en JavaScript (Creación de una librería JavaScript 4ª parte)

En esta cuarta entrega de la serie se va a explicar cómo comprobar que los valores se encuentran en un rango en pruebas unitarias en JavaScript. Comprobar rangos es importante cuando se trabaja con números reales. Las operaciones que involucran números reales tienen una precisión que depende de la máquina en la que correo. Esto hace que al cambiar de motor JavaScript una función puede obtener valore ligeramente diferentes debido al cambio de precisión. Por lo tanto, comparar el resultado de una función con un número real no es una buena práctica. Es aconsejable comprobar que el valor se encuentra en un rango del valor esperado.

Además, también se mostrará cómo comparar vectores y objetos en una única prueba.

Esta entrada pertenece a la serie “Creación de una librería JavaScript” cuyo código se puede encontrar en la cuenta de GitHub de Analytics Lane. Serie compuesta por las siguientes entradas:

• Creación de una librería JavaScript
• Estructurar las funciones JavaScript
• Pruebas unitarias en JavaScript
• Rango en pruebas unitarias en JavaScript
• Cobertura de las pruebas unitarias en JavaScript
• Medir la calidad del código JavaScript
• Compresión del código JavaScript
• Ejecutar múltiples scripts npm

Nuevas funciones en la librería

En primer lugar, es necesario crear nuevas funciones para crear las pruebas. Concretamente se van a implementar las siguientes:

En Analytics Lane

Los récords con asterisco, o la épica del titular sin contexto – El bestiario de los indicadores económicos absurdos (parte 8 y final)

• mean: obtiene la media de un vector
• summary: devuelve un objeto con la suma y la media de un vector
• multiply: devuelve un vector con el vector original multiplicado por un escalar

Al implementar estas funciones el archivo array.js queda de la siguiente manera.

(function () {
  'use strict';

  const array = exports;

  // Sum of an array
  array.sum = function (arr) {
    let result = 0;

    for (let i = 0; i < arr.length; ++i) {
      result += arr[i];
    }

    return result;
  };

  // Mean of an array
  array.mean = function (arr) {
    return array.sum(arr) / arr.length;
  };

  // Summary of an array
  array.summary = function (arr) {
    return {
      sum: array.sum(arr),
      mean: array.mean(arr)
    };
  };

  // Multiply all values by a scalar
  array.multiply = function (arr, value) {
    const result = arr.slice();

    if (value === undefined) {
      return result;
    }

    for (let i = 0; i < arr.length; ++i) {
      result[i] = arr[i] * value;
    }

    return result;
  };
}());

Comprobación de rangos en pruebas unitarias

Hasta ahora si nos fijamos en las pruebas unitarias siempre se ha utilizado .to.be.equal() para comprobar que el resultado de la función es igual al esperado. Lo que no permite ningún margen de error. Cuando el resultado de la función es real es necesario tener en cuenta los errores debido a la precisión. Por lo que es necesario compara que los resultados se encuentran en un rango. Esto se puede comparar utilizando closeTo() en lugar de equal(). A closeTo() es necesario indicarle además del valor esperado el rango de error máximo permitido. Por ejemplo, la siguiente prueba es valida

expect(1.0001).to.be.closeTo(1, 1e-4);

Ya que la diferencia entre los dos valores es justamente rango indicado. La prueba fallará si el rango se aumenta a 1e-5.

Comprobación de vectores y objetos en pruebas unitarias

Una forma más compacta de comparar resultados es comparar directamente vectores u objetos. Pero si se hace como hasta ahora se puede ver que las pruebas fallan. Esto es lo que se vería si se ejecutan las siguientes pruebas.

expect([1, 2]).to.be.equal([1, 2]);<br>
expect({A: 1, B: 2}).to.be.equal({A: 1, B: 2});

La solución para esto es reemplazar be por deep, con lo que se consigue que las pruebas anteriores pasen. Esto es, escribir:

expect([1, 2]).to.deep.equal([1, 2]);<br>
expect({A: 1, B: 2}).to.deep.equal({A: 1, B: 2});

Por defecto en Chai deep no funciona con closeTo. Para solucionar este problema es necesario instalar la librería chai-deep-closeto. Lo que se consigue el siguiente comando en la carpeta del proyecto.

npm install chai-deep-closeto --save-dev

Posteriormente es necesario importar la librería e inyectarla en Chai para que se pueda utilizar. Para lo que es necesario escribir la siguiente línea de código después de importar Chai y antes de la suite.

chai.use(require('chai-deep-closeto'));

Desafortunadamente, en el momento de escribir esta entrada, chai-deep-closeto solo función con vectores, no con objetos. Por lo que si se desea closeTo en un objeto es necesario comprobar las propiedades una a una.

Suite de ejemplo

Con todo lo visto en esta entrada se puede crear una suite para evaluar el funcionamiento de las nuevas funciones creadas. En el archivo array.test.js se pueden incluir ahora pruebas para mean, summary y multiply.

En este ejemplo, en las pruebas de la función mean se puede observa la utilización de closeTo() para comprobar que el resultado es similar a lo esperado. Por otro lado, en las de mean se puede apreciar la utilización de deep. Finalmente, en las pruebas de multiply se utiliza la opción deep.closeTo().

const chai = require('chai');
const chaiDeepCloseTo = require('chai-deep-closeto');
const expect = chai.expect;
const jslane = require('../index.js');

// Provides deep.closeTo for the Chai assertion
chai.use(chaiDeepCloseTo);

suite('Array test', function () {
  test('Array sum test', function (done) {
    expect(jslane.array.sum([1, 1, 1])).to.be.equal(3);
    expect(jslane.array.sum([1, 2, 3])).to.be.equal(6);

    expect(jslane.array.sum([1, 2, 4])).to.be.equal(7);

    done();
  });

  test('Array mean test', function (done) {
    expect(jslane.array.mean([1, 1, 1])).to.be.equal(1);
    expect(jslane.array.mean([1, 2, 3])).to.be.equal(2);

    expect(jslane.array.mean([1, 2, 4])).to.be.closeTo(2.3333333333, 1e-6);

    done();
  });

  test('Array mean test', function (done) {
    expect(jslane.array.summary([1, 1, 1])).to.deep.equal({
      sum: 3,
      mean: 1
    });
    expect(jslane.array.summary([1, 2, 3])).to.deep.equal({
      sum: 6,
      mean: 2
    });

    done();
  });

  test('Array multiply test', function (done) {
    expect(jslane.array.multiply([1, 1, 1], 2.50001)).to.deep.closeTo([2.5, 2.5, 2.5], 1e-4);

    expect(jslane.array.multiply([1, 1, 1])).to.deep.equal([1, 1, 1]);

    done();
  });
});

Conclusiones

Al finalizar la cuarta entrega de la serie se puede comprobar que los valores de una función se encuentran en un rango en pruebas unitarias en JavaScript. Esto permite mejorar las pruebas y aumentar los casos de uso. En la próxima entrada se verá cómo medir la cobertura de las pruebas unitarias.

Imágenes: Pixabay (skylarvision)