Prueba con broma

Jest es un marco de prueba de Javascript de Facebook. Se utiliza más comúnmente para pruebas unitarias . La prueba unitaria es cuando proporciona una entrada a una unidad de código (generalmente, una función) y hace coincidir la salida con la salida esperada. 

Características de la broma: 
 

• configuración cero: como veremos más adelante en este artículo, se requiere casi ninguna configuración para comenzar a escribir pruebas e implementarlas. Sin embargo, también se puede proporcionar un archivo de configuración al conjunto de pruebas.
• Instantáneas: Jest también tiene la capacidad de habilitar la prueba de instantáneas. Esencialmente, las instantáneas se comparan con la instantánea guardada y verifican la funcionalidad coincidente.
• pruebas aisladas: las pruebas Jest se ejecutan en paralelo para mejorar el tiempo de ejecución.

Configuración de un proyecto de broma 
 

• Instale Jest usando npm: 
   

• Estructura del proyecto: 
  en el directorio raíz del proyecto, cree una carpeta de pruebas . Esta carpeta almacenará todos los archivos de prueba. 
  Tenga en cuenta que los archivos js (que se van a probar) se asignan por sus nombres. 
  Por ejemplo, index.js se asigna a index.test.js . Este archivo index.test.js se coloca en la carpeta ‘pruebas’. Esta es la estructura de proyecto convencional.

Comience a probar: 
 

• Para comenzar, veamos un flujo de trabajo de prueba básico. 
   

• Para ejecutar la prueba, utilice el script 
   

npm run test

• Esto buscará el script de prueba mencionado en el paquete.json del proyecto. 
   

Usaremos el método ‘esperar’ para probar nuestras funciones. Las funciones también se pueden probar usando ‘describe’ y ‘it’ . 

Una prueba básica: sumar dos números positivos y verificar el resultado. 
 

//index.js
testForAdd: (a, b) => { return (a + b) },

//index.test.js
test('test adding two positive nums', function() {
    expect(testFns.testForAdd(4, 5)).toBe(9);
});

Cuando se ejecuta la ‘prueba de ejecución de npm’ , se procesa el archivo index.test.js . Luego se ejecuta la función testForAdd que se coloca en el objeto ‘testFns’ . El toBe se usa para ‘coincidir’ la respuesta devuelta de la prueba con lo que se esperaba. Esta ‘coincidencia de resultados’ conduce a un ‘fallo’ o un ‘aprobado’ . 

La siguiente prueba fallará debido a ‘toBe(8)’ . 
 

//example of a failing test
 test('test adding two positive nums - failing test', function() {
     expect(testFns.testForAdd(4, 5)).toBe(8);
 });

Opuesto a toBe: not.toBe() 
Lo opuesto al comparador ‘toBe’ se crea simplemente con el prefijo ‘not’. 
Por ejemplo: 
 

//test successful - test for opposite of a matcher.
//The following test will 'Pass' if the returned value is not equal to 8.
test('test adding two positive nums - failing test', function() {
    expect(testFns.testForAdd(4, 5)).not.toBe(8);
});

Uso de ‘toBe’ con objetos JS: 
pensemos en un caso en el que se probarán todos los campos de un objeto JS. Jest nos proporciona una manera de hacer esto usando ‘toEqual’ . El ‘toEqual’ es un comparador profundo (comprueba todos los campos y subcampos posibles). 
 

//expect toEqual example - check every field's value
// testFns.test_toEqual(gfgObj)
test('check gfgObj toEqual', () => {
    let gfgObj = { name: "GFG" };
    gfgObj['type'] = "company";
    expect(gfgObj).toEqual({ name: "GFG", type: "company" });
});

Ejecutar la prueba anterior ‘Pasará’. 
 

Otra variación de hacer esto es emparejar dos objetos usando ‘toEqual’ . 
Esto se hace así: 
 

test('check gfgObj toEqual', () => {
    let gfgObj = {
        name: "GFG",
        type: "company",
        members: {
            employees: 100,
            contributors: 500
        }
    };

    let testObj = {
        name: "GFG",
        type: "company",
        members: {
            employees: 100,
            contributors: 500
        }
    };
    expect(gfgObj).toEqual(testObj);
});

Esta prueba demuestra la función de coincidencia profunda de toEqual. 
La prueba anterior pasa ya que cada par de claves en gfgObj coincide con testObj. 
 

toBeCloseTo: para números de punto flotante y otras coincidencias aproximadas 
 

//see here that a+b != c even though simple addition is taking place.
> var a = 1.32
> undefined
> var b = 2.31
> undefined
> c = a+b;
> 3.63
> var res = false;
> if(c==(a+b)) {c=true;}
> undefined
> c
> false

En tales condiciones, es bueno usar el comparador ‘toBeCloseTo’ de la biblioteca Jest. 
 

test('floating point number - use toBeCloseTo instead', function() {
    // const num1 = 0.3;
    // const num2 = 0.2;
    const result = 9.31 + 9.2;

    expect(result).toBeCloseTo(18.51);
})

La prueba anterior también pasa. 

haciendo coincidir verdadero y falso: 
https://jestjs.io/docs/en/using-matchers#truthiness 
Muchas veces, las pruebas se escriben para verificar los valores verdaderos y falsos devueltos por ‘esperar’. 
Valores falsos en JS. 
Valores veraces en JS. 
 

//checking for truthy values - All the tests will return truthy.
test('check for truthy', function() {
    const gfgObj = {
        first: null,
        second: undefined,
        third: false
    }
    expect(gfgObj.first).not.toBeTruthy(); // True - Pass
    expect(gfgObj.second).toBeUndefined(); // True - Pass
    expect(gfgObj.third).toBeFalsy();      // True - Pass
})

La prueba anterior pasa. 
 

Sin embargo, si alguno de los ‘ esperar’ anteriores falla, Jest devuelve mensajes de error significativos como los siguientes. 

Tenga en cuenta que en el caso anterior, si alguno de los ‘esperar’ falla, la prueba también falla por completo. 
 

Números coincidentes: 
 

//tests for Number matches
test('test for numbers', function() {
    const result = 3 + 9;
    // expect(result).toBe(12); //the plain old matcher
    expect(result).not.toBeLessThan(10); // result > 10
    expect(result).toBeLessThan(15);  // result < 15
    expect(result).not.toBeGreaterThan(15); // result  10
    expect(result).toBeGreaterThanOrEqual(12);  //result >= 12
    // expect(result).not.toBeGreaterThanOrEqual(12); // result == 12, this Fails
    // expect(result).toBeLessThanOrEqual(10); // result >= 10, this Fails
})

Probar valores contenidos en arreglos: 
También podemos probar si valores particulares están contenidos en un arreglo. Tenga en cuenta que esta prueba fallará si al menos un valor no está presente en la array. Por ejemplo, 
 

//testing arrays
const gfgUsers = [
    'user1',
    'user2',
    'user3'
];
test('test for a value in gfgUsers', function() {
    // expect(gfgUsers).toContain('user2');
    // expect(gfgUsers).not.toContain('user2');
    //expect array containing
     expect(gfgUsers).toEqual(expect.arrayContaining(['user1', 'user3']));
})

La prueba anterior pasa como usuario1 y usuario3 están presentes en gfgUsers. 
 

Sin embargo, la siguiente prueba fallará porque ‘user4’ no está presente en gfgUsers. 
 

//testing arrays
const gfgUsers = [
    'user1',
    'user2',
    'user3'
];
test('test for a value in gfgUsers', function() {
    //expect array containing
     expect(gfgUsers).toEqual(expect.arrayContaining(['user1', 'user4']));
})

Prueba usando Regex: 
 

test('string match tests - toMatch - used for regex-es', function() {
    const str = 'GeeksforGeeks';
    // expect(str).toMatch(/f/);
    // expect(str).toMatch(/Z/);
    //you can create more complex Regexes
    const str1 = 'This is a test paragraph. I wrote it.'
    expect(str1).toMatch(/[pP][hH][\.]/);  //matches 'ph.' in the word 'paragraph'
})

Ampliación de Matchers 
Jest también incluye la posibilidad de ampliar su funcionalidad de ‘Matchers’ , que se logra mediante la palabra clave ‘expect.extend()’ . La función .extend() se pasa a los emparejadores como objetos. 
Sintaxis: expect.extend({matcher1, matcher2}) ; 
Por ejemplo, si queremos construir un comparador que verifique la presencia de una frase en una string: 
 

expect.extend({
stringPresent(receivedString, phraseString) {
bool phrasePresent = true;
var re = new RegExp(phraseString);
if (re.test(receivedString)) {
    phrasePresent = true;
} else {
    phrasePresent = false;
}
if (phrasePresent === true) {
      return {
        message: () =>
          `string present`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `string absent`,
        pass: false,
      };
    }
},
});

Tratar con excepciones 
También podemos comprobar los tipos de errores que arroja una unidad de código. Podemos comprobar el error arrojado por nombre, mensaje, objeto, etc. 

Sintaxis :expect( fnName() ).toThrow( error ); 
El parámetro/argumento de error es opcional aquí. 

Supongamos que queremos probar una función por el mensaje de error arrojado. 
 

function testGFGMessage() {
  throw new Error('this is testGFGMessage function error');
}
test('testing testGFGMessage', function(){
  expect(testGFGMessage).toThrow('this is testGFGMessage function error');
})

Hay muchas otras formas de arrojar errores y verificarlos. Una referencia detallada se puede encontrar aquí . 

Omitir/ejecutar un subconjunto de pruebas 
https://jestjs.io/docs/en/api#testskipname-fn 
Jest también tiene una disposición para omitir pruebas específicas mientras se ejecuta el conjunto de pruebas. 
Para implementarlo, simplemente use la palabra clave ‘skip’ . Por ejemplo, 
 

function addFn(num1, num2){
  return num1 + num2;
}

test.skip('skip test example - skipping the addition test', () => {
  expect(addFn(2, 3)).toBe(5);
});

Lo contrario de esto es implementar solo un subconjunto de pruebas, lo que se logra mediante el uso de la palabra clave ‘solo’ . Por ejemplo, 
 

function addFn(num1, num2){
  return num1 + num2;
}

test.only('skip test example - skipping the addition test', () => {
  expect(addFn(2, 3)).toBe(5);
});