No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Tu primer test

6/27
Recursos

Aportes 14

Preguntas 5

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥楬H:MM:SS鈥 que yo nunca le indique, y el test me hizo darme cuenta de mi error cuando lo corr铆 por primera vez 馃槄.

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

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

no paremos de aprender. 馃槃

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.

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');
});> 
**RETO** Elevar un n煤mero a una potencia `function raiseExponent(base, exponent) {聽 return base ** exponent;}` Test `test("raiseExponent", () => {聽 const rta = raiseExponent(2, 3);聽 expect(rta).toBe(8);聽 const rta2 = raiseExponent(1, 0);聽 expect(rta2).toBe(1);});`

En visual code podemos instalar un plugin para correr la prueba de forma rapida sobre el mismo codigo, se llama 鈥淛est 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.