Tu primer test

Respecto de la salida de pantalla:

Test Suites: 2 passed, 2 total
Tests: 4 passed, 4 total

Cada archivo sería un test suite. En este caso 02-math.test y 01-sum.test.

Probando un conversor de segundos

☕ Actualmente, en la universidad estoy llevando Java básico, y uno de los primeros ejercicios consistía en hacer un conversor de segundos a horas, minutos y segundos.

Me hubiera venido muy bien saber de test en ese momento, porque era muy tedioso tener que revisarlo manualmente para saber si estaba correcto.

En fin, lo que hice fue replicar el ejercicio, ahora en JavaScript e implementar un test sencillito.

function secondsConverter(seconds) {
  const hours = Math.floor(seconds/3600);
  const minutes = Math.floor((seconds%3600)/60);
  const residue = (seconds%3600)%60

  return (`${hours}:${minutes}:${residue}`);
}

Y en el test simplemente le paso los ejemplos que ya sé que respuesta deben devolver.

test('Converts seconds to hours, minutes and seconds', ()=>{
  const rta = secondsConverter(3600);
  expect(rta).toBe('1:0:0');

  const rta2 = secondsConverter(3700);
  expect(rta2).toBe('1:1:40');

  const rta3 = secondsConverter(0);
  expect(rta3).toBe('0:0:0');
})

Es curioso porque incluso en este desarrollo de 5 minutos me ayudó, pues yo erróneamente asumí que el la respuesta tendría un formato ‘HH:MM:SS’ que yo nunca le indique, y el test me hizo darme cuenta de mi error cuando lo corrí por primera vez 😅.

Tu primer test

Vamos a experimentar un poco con Jest, vamos a crear varias funciones matemáticas y vamos a hacer sus respectivos test.

Creemos entonces un archivo math.js

// Función para sumar
function sum(a, b) {
  return a + b;
}

// Función para multiplicar
function multiply(a, b) {
  return a * b;
}

// Función para dividir
function divide(a, b) {
  return a / b;
}

// Exportamos nuestras funciones como paquetes
module.exports = {
  sum,
  multiply,
  divide
}

Ya que tenemos nuestro archivo preparado, vamos entonces a crear nuestro archivo de test para empezar a familiarizarnos con la herramienta.

Vamos a crear nuestro archivo math.test.js:

// Exportar funciiones creadas
const {sum, multiply, divide} = require('./math');

/* Para empezar a testear nuestras funciones debemos usar la palabra
reservada test como función */

/* Dentro de esta función vamos a escribir como string que es lo que
esperamos que haga esta función, ósea es una pequeña descripción de
lo que se supone debe hacer la función */

/* Luego de esto vamos a tener una fución que será el manejador del 
test, en esta estableceremos la lógica de nuestro test */

test("añadir 1 + 3 debe dar 4", ()=> {
  // Ejecutamos nuestra función y le pasamos sus respectivos valores
  const rta = sum(1,3);

  /* Expect tendrá la ejecución de la función y toBe tendrá el
  resultado que esperamos de la función */
  expect(rta).toBe(4);
});

Ahora si ejecutamos nuestro comando de test veremos que tenemos un resultado correcto:

npm run test # Output = test passed

Vamos a crear los test de las siguientes funciones:

const {sum, multiply, divide} = require('./math');

test("añadir 1 + 3 debe dar 4", ()=> {
  const rta = sum(1,3);
  expect(rta).toBe(4);
});

test("añadir 9 x 2 debe dar 18", ()=> {
  const rta = multiply(9,2);
  expect(rta).toBe(18);
});

test("añadir 12 / 3 debe dar 4", ()=> {
  const rta = divide(12,3);
  expect(rta).toBe(4);

	// Podemos tener varios escenarios de prueba en nuestros test
	const rta2 = divide(5,2);
	expect(rta2).toBe(2.5);
});

Podemos también aumetar la complejidad de nuestros test:

...
test(
  'dividir entre 0 nos debe retornar un string que diga "no se puede dividir entre 0"',
  ()=> {
    const rta = divide(0,0);
    expect(rta).toBe("no se puede dividir entre 0");
  }
);

Vamos a crear una validación para solucionar este problema:

...
function divide(a, b) {
  if(a === 0 || b === 0) {
    return "no se puede dividir entre 0"
  }

  return a / b;
}

Así es como podemos crear nuestras pruebas para nuestros proyectos.

Hola , me salté para ser el primer comentario, ya que es el primer test :

< console.log( Hola Mundo del Testing); > 

no paremos de aprender. 😄

No es mucho, pero es trabajo honesto:

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

function multiply(a, b) {
  return a * b;
}

function divide(a, b) {
  if (b === 0) {
    return null;
  }
  return a / b;
}

function substract(a, b) {
  return a - b;
}

function power(a, b) {
  return Math.pow(a, b);
}

module.exports = {
  sum,
  multiply,
  divide,
  substract,
  power
};

const { sum, divide, multiply, substract, power } = require('./02-math')

test('sum of 1 + 3 should be 4', () => {
  const rta = sum(1, 3);
  expect(rta).toBe(4);
});

test('substract 0 - 0 should be 0', () => {
  const rta = substract(0, 0);
  expect(rta).toBe(0);
})

test('mutiply 3 * 5 should be 15', () => {
  const rta = multiply(3, 5);
  expect(rta).toBe(15);
});

test('should divide', () => {
  const rta = divide(6, 3);
  expect(rta).toBe(2);

  const rta2 = divide(5, 2);
  expect(rta2).toBe(2.5);
})

test('should divide by 0', () => {
  const rta = divide(6, 0);
  expect(rta).toBe(null);

  const rta2 = divide(5, 0);
  expect(rta2).toBe(null);
})

test('should return the power of the base number', () => {
  const rta = power(2, 3);
  expect(rta).toBe(8);
});

//imput.js

<function input(content){

  if(typeof(content)!==String ||content.includes('@') || content.includes('#') || content.includes('/') || content.includes('-')){

    return 'Error'
  }
  return 'Exito'


}
module.exports =input> 

//input.test.js

<const input=require('./input');
test('this input must be wrong, it is not a string',()=>{
  expect(input(1)).toBe('Error');
});


test('this input must be wrong, it contains special caracters',()=>{
  expect(input('j@iro')).toBe('Error');
});> 

En visual code podemos instalar un plugin para correr la prueba de forma rapida sobre el mismo codigo, se llama “Jest Runner”

> [email protected] test2
> jest

 PASS  src/01-sum.test.js 
 PASS  src/02-math.test.js

Test Suites: 2 passed, 2 total
Tests:       8 passed, 8 total
Snapshots:   0 total
Time:        1.98 s, estimated 2 s
Ran all test suites.

Mi ejemplo de test con una función que retorna el promedio de un array:

Función

function average(numbers) {
  if (numbers.length === 0) {
    return 'Array can not be empty';
  }
  const sum = numbers.reduce((previous, current) => {
    return previous + current
  })
  return sum/numbers.length;
}

Test

test('Average', async () => {
  const res = average([1,2,3,4,5]);
  expect(res).toBe(3);
});

test('Average error', async () => {
  const res = average([]);
  expect(res).toBe('Array can not be empty');
});

🤓Tu primer test

1. Crear el archivo JS que contenga el código a evaluar

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

function multiply(a, b) {
  return a * b;
}

function divide(a, b) {
  if (b === 0) {
    return null;
  }
  return a / b;
}

module.exports = {
  sum,
  multiply,
  divide,
};

2)Crear el archivo de pruebas para el código a evaluar

const { sum, multiply, divide } = require('./02-math'); // Importar el archivo JS a evaluar

//test = Define la pueba a hacer 
test ("Descripción de la prueba", ()=>{

	//Ejecución de la prueba en el código

	/*expect= Define y compara que el resultado esperado a partir de la pueba realizada
	sea igual al obtenido espues de la ejecución*/

	expect(/*Resultado de la ejecución*/).toBe(/*Resultado de la prueba*/);
	
});

test("add 1 + 3 should be 4", () => { 
  const rta = sum(1, 3);
  expect(rta).toBe(4);
});

test("add 1 * 4 should be 4", () => {
  const rta = multiply(1, 4);
  expect(rta).toBe(4);
});

test("add 1 / 4 should be 4", () => {
  const rta = divide(6, 3);
  expect(rta).toBe(2);
  const rta2 = divide(5, 2);
  expect(rta2).toBe(2.5);
});

test("should divide for zero", () => {
  const rta = divide(6, 0);
  expect(rta).toBeNull();
  const rta2 = divide(5, 0);
  expect(rta2).toBeNull();
});

1. Ejecutar las pruebas con npm run test

Reto: Función para sacar promedio de un array

02-math.js

<function promedio(array) {
  let sum = 0;
  array.forEach((element) => {
    sum = sum + element;
  });
  return sum / array.length;
}>

02-math.test.js

<test("saca el promedio de un array", () => {
  array = [1,5,6]
  const rta = promedio(array);
  expect(rta).toBe(4)
});> 

Out

<➜  src git:(master) ✗ npm run test
Debugger attached.

> [email protected] test /Users/jhonospina/Documents/Desarrollo/Platzi/Platzi-testingJS/demos
> jest

Debugger attached.
Debugger attached.
Debugger attached.
Debugger attached.
 PASS  src/01-sum.test.js
 PASS  src/02-math.test.js
Waiting for the debugger to disconnect...
Waiting for the debugger to disconnect...
Waiting for the debugger to disconnect...

Test Suites: 2 passed, 2 total
Tests:       2 passed, 2 total
Snapshots:   0 total
Time:        5.404 s
Ran all test suites.
Waiting for the debugger to disconnect...
Waiting for the debugger to disconnect...> 

RETO

• Función Volumen de un cilindro:

function cylinderVol(r, a) {
  return Math.PI * r * r * a;
}

• Test

test("should be 38", () => {
  const rta = cylinderVol(2,3);
  expect(rta).toBe(38);
});

• Out Terminal

 ~/.../testing-js/demos   master ●  npm run test

> [email protected] test
> jest

 FAIL  src/02-math.test.js
  ● should be 4

    expect(received).toBe(expected) // Object.is equality

    Expected: 38
    Received: 37.69911184307752

      31 | test("should be 4", () => {
      32 |   const rta = cylinderVol(2,3);
    > 33 |   expect(rta).toBe(37.699111843);
         |               ^  
      34 | });   //Será que pongo el numero más largo en el test o lo redondeo en la función? sigue leyendo...
      35 |
      36 | /* OUT

      at Object.toBe (src/02-math.test.js:33:15)

 PASS  src/01-sum.test.js

Test Suites: 1 failed, 1 passed, 2 total
Tests:       1 failed, 5 passed, 6 total
Snapshots:   0 total
Time:        0.523 s, estimated 1 s
Ran all test suites.

• Refactor

function cylinderVol(r, a) {
  // refactor...
  return Math.ceil(Math.PI * r * r * a);
  // ... refactor
}

• Out Terminal

 ~/.../testing-js/demos   master ●  npm run test

> [email protected] test
> jest

 PASS  src/01-sum.test.js
 PASS  src/02-math.test.js

Test Suites: 2 passed, 2 total
Tests:       6 passed, 6 total
Snapshots:   0 total
Time:        0.833 s
Ran all test suites.

😃 💚 😄

Mi código comentado/resumen

const { sum, multiply, divide } = require('./02-math');

test("adds 1 + 3 should be 4", () => { // escenario de bruebas.
  const rta = sum(1,3); // resolver la prueba.
  expect(rta).toBe(4); // resolver la hipotesis.
});

/* OUT

 ~/.../testing-js/demos   master ●  npm run test

> [email protected] test
> jest

 PASS  src/01-sum.test.js
 PASS  src/02-math.test.js  // Pasé o encontré 2 archivos con la extensión ".test.js".

Test Suites: 2 passed, 2 total  // Allí encontré 2 pruebas.
Tests:       2 passed, 2 total  // Todas pasaron.
Snapshots:   0 total
Time:        0.504 s, estimated 1 s
Ran all test suites.

 ~/.../testing-js/demos   master ●  npm run test

> [email protected] test
> jest

 FAIL  src/02-math.test.js
  ● should divide for zero

    expect(received).toBeNull()  // Cuando en tu metodo lo pones a dividir entre 0 o devuelve un Nulo.

    Received: Infinity   // Devuelve algo que tiende a infinito.

      23 |
      24 |   const rta = divide(6,0);
    > 25 |   expect(rta).toBeNull();
         |               ^
      26 |
      27 |   const rta2 = divide(7,0);
      28 |   expect(rta2).toBeNull();

      at Object.toBeNull (src/02-math.test.js:25:15)

 PASS  src/01-sum.test.js

Test Suites: 1 failed, 1 passed, 2 total
Tests:       1 failed, 4 passed, 5 total  // Falló una prueba, en este caso hay que hacer refactor.
Snapshots:   0 total
Time:        0.492 s, estimated 1 s
Ran all test suites.

 OUT */

function divide(a, b) {
  // refactor...
  if (b === 0){
    return null;
  }
  // ... refactor
  return a / b;
}

*Solo puse lo que me pareció importante con su comentario resumido.