Desarrollo de Apps 27 enero, 2022

Al desarrollar aplicaciones móviles y soluciones web, debemos tener en cuenta que no podemos prever todos y cada uno de los casos de error que pueden suceder en su uso. No obstante, podemos minimizar el impacto de estos errores mediante el uso de tests que comprueben la solidez de nuestro código.

¿Qué es Unit Testing?

Unit Testing (o test unitario) es una tipología de testing dónde, mediante métodos y funciones, comprobamos fragmentos de la lógica de negocio para evitar sorpresas y errores de excepción. Los test unitarios siempre se usan para comprobar la parte más pequeña de una aplicación, por lo que son excelentes para comprobar la validez y solidez de nuestro código durante el desarrollo.

¿Cómo funciona un Test Unitario?

Un Test Unitario funciona mediante el uso de funciones y métodos que llaman al fragmento que queremos comprobar (normalmente otra función o método) y comprueban diversos parámetros. Veamos un ejemplo:

Tenemos el siguiente fragmento de código en JavaScript que suma dos valores. Como vemos, es una función sencilla, tiene dos inputs (a, b) y devuelve un output (la suma). Vamos a ponerla a prueba:

function sum (a, b){
    return a + b
}

sum(2,5) // 7

Al sumar dos valores, vemos que devuelve la suma sin ningún problema. Ahora bien, imaginemos que esta función depende de los datos que viene de una API de la cuál no tenemos control. Por ejemplo, necesitamos realizar la suma de dos valores y en función del resultado, hay una cláusula if que controla el flow del usuario:

var a = 8
var b = 7

result = sum(a,b)

if(result < 5){
	console.log("its lower than 5") //false
}else if(result > 5){
	console.log("it's greater than 5") //true
}

La lógica del código indica que saldrá correctamente en la segunda cláusula del if-else, por lo que hara un print de “it’s greater than 5”. Ahora bien, ¿qué pasa si modificamos el valor de a por “8”?

var a = "8"
var b = 7

result = sum(a,b)

if(result < 5){
	console.log("its lower than 5") //false
}else if(result > 5){
	console.log("it's greater than 5") //true
}

Nos continua entrando en la segunda cláusula y no hay ningún problema, pero deténgamonos un momento con un console log de “result”:

console.log(result) // 87

Como vemos, si bien es cierto que es más grande que 5, no es el resultado que queremos, puesto que 8, al ser un parámetro que va de número a string, el compilador entiende que al hacer sum() lo que queremos es unirlos, por lo que tendriamos un bug horrible y nos costaria días y recursos en encontrarlo.

Herramientas para realizar tests unitarios

Aunque sum() en este caso tiene una funcionalidad clara y no debería modificar su comportamiento, en algunos casos algunos métodos pueden tener diferentes funciones en diferentes partes del código, por lo que nos ayudaría mucho que, en vez de tipar todos los parámetros que puedan existir o pueda aceptar, comprobemos que la función funciona correctamente en cualquier entorno.

Es por eso que existen varias herramientas que nos pueden ayudar tales como:

  • Jest.
  • Pupeteer.
  • NUnit.
  • JUnit.

Cada lenguaje tiene su propia herramienta de testing, y es tarea del developer seleccionar la que más se adecue a sus necesidades. Es común utilizar estas librerías junto a otras como Mocha y Chai, que nos devuelven true o false en función del resultado, por los que nos permiten determinar las partes más frágiles del código y corregirlas antes de que el proyecto siga adelante

Ventajas de los test unitarios

Volvamos al ejemplo para hacer una prueba de concepto. Para comprobar que sum() siempre devolverá el resultado deseado, vamos a probar el fragmento en una prueba unitaria, para ello, usaremos Jest y Mocha:

import {describe, test} from '@jest/globals'

describe('sum() test'),function (){
  test('if a, b are numbers, it will return the sum',() => {
    chai.expect(sum(2,5)).to.equal(5) //true
  });
  test('if a, b are strings, it will return the join string' () => {
    chai.expect(sum("a","b")).to.equal("ab") //true
  })
})

Como vemos, estos dos tests no son mas de 2 líneas de código cada uno, pero comprueban comportamientos básicos de nuestra lógica de negocio. La palabra clave “chai.expect()” es la biblioteca que nos permite comprobar la afirmación; en caso de que fuera falso nos indicaría un error de comprobación.

Los tests unitarios son herramientas muy potentes que nos permite:

  • Garantizar la calidad del código a medida que escala el proyecto.
  • Rápidos de ejecutar.
  • Fácil comprensión y aplicación dentro de los proyectos.
  • Gran cantidad de librerías permite a equipos grandes y pequeños aplicarlas en cualquier proyecto.
  • Tiempo de desarrollo malgastado en bugs se acorta.

En Doonamis aplicamos estas técnicas para asegurar la calidad de las aplicaciones móviles y webs que desarrollamos, lo que nos permite evitar problemas en su publicación y puesta en producción. Si estás interesado en crear una App o Web, no dudes en contactarnos y haremos realidad tu producto digital con los mejores estándares de calidad.

¿Interesado en nuestros servicios?
¡Pídenos un presupuesto!

Pedir presupuesto