Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Implementando pruebas para Boolean y Array

4/16
Recursos

Aportes 22

Preguntas 3

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Probar String

const text = "Hola Mundo";
test('Debe contener Mundo', ()=>{
    expect(text).toMach(/Mundo/);
})

Probar Array

test('¿Tenemos mango?', ()=>{
    expect(fruits).toContain('mango')
})

Probar números

test('Mayor que', ()=>{
    expect(10).toBeGreaterThan(9)
})

Probar booleano

test('Verdadero', ()=>{
    expect(true).toBeTruthy()
})

Probar callback

const reverseString = (str, callback) => {
    callback(str.slipt("").reverse().join(""))
}
test('Probar un callback', ()=>{
    reverseString('hola', (str)=>{
        expect(str).toBe('aloh')
    })
})

Código de la clase

const frameworks = ["React", "Vue", "Angular", "Svelte"];

// Test arrays
test("It should has React", () => {
  expect(frameworks).toContain("React");
});

// Test numbers
test("It should be greater than", () => {
  expect(10).toBeGreaterThan(9);
});

// Test Booleans
test("It should be true", () => {
  expect(true).toBeTruthy();
});

// Reverse strings function
const reverseString = (str, cb) => {
  cb(str.split("").reverse().join(""));
};

// Test callbacks
test("The callback should return a reversed word", () => {
  reverseString("Platzi", str => {
    expect(str).toBe("iztalP");
  });
});

Viendo la clase, me entró la curiosidad de ¿Cómo haría si quiero evaluar cada uno de los elementos de un array en un solo test?

Así que me puse a probar con evaluar si todos los elementos de un array eran mayores a 10

const arr = [15, 11, 12, 20, 50];

test("Check if the numbers of an array are grater than 10", () => {
  arr.map((item) => {
    expect(item).toBeGreaterThan(10);
  });
});

De los aprendizajes más curiosos que me llevo es que

  1. La función anónima puede tener mucha más lógica que solamente los expect() y cómo queremos testear. El ejemplo es el .map() que recorre todo el array.
  2. Se puede tener más de un solo expect() dentro de un test, y que si falla al menos uno, falla todo el test

Los invito a probar el código que está arriba, y que jueguen libremente con los test y resuelvan sus dudas probando y rompiendo 😉

Estoy tratando de entender el porque de las pruebas ?
Porque es necesario ?
Si usamos typescript seria mejor y no nos equivocamos con los tipos de datos?
Perdon mi ignorancia pero necesito entender el porque

Funciones para probar números, strings, arrays, objetos y booleanos

Estructura general para ejecutar un test

test('Título que va a describir el test a realizar', () => {
    expect().<-- METODO A EJECUTAR -->
})

Números

test('Dos mas dos', () => {
    const value = 2 + 2;
    expect(value).toBeGreaterThan(3);
    expect(value).toBeGreaterThanOrEqual(3.5);
    expect(value).toBeLessThan(5);
    expect(value).toBeLessThanOrEqual(4.5);
  
    // Para testear que el valor de prueba retorne siempre un valor definido
    expect(value).toBe(4);
    expect(value).toEqual(4);
});
  • Números flotantes
test('Testeo de números flotantes', () => {
    const value = 0.1 + 0.2;
    // Para testear un flotante se debe usar la siguiente línea, ya que si se implementa
		// la función <-- toBe --> retortana una prueba fallida ya que JavaScript redondea
	  // con un pequeño margen de error.
    expect(value).toBeCloseTo(0.3);
});

Strings

  • Los strings pueden evaluarse mediante expresiones regulares o simplemente entre comillas (" ")
test('Para testear que algo no se encuentre en un string', () => {
    expect('platzi').not.toMatch(/n/);
});
  
test('A la grande le puse cuca', () => {
    expect('grande').toMatch("rande");
});

Arrays y iterables

  • Array
const frutas= ['Manzana', 'Pera', 'Banana']

test('¿Tenemos una banana en el array?', () => {
    expect(fruits).toContain('Banana')
})
  • Objetos
const personajes = {
    uno: "Homero",
    dos: "Marge",
    tres: "Lisa",
    cuatro: "Bart",
    cinco: "Maggie"
}

test('¿Existe el persona Bart en el objeto?', () => {
    expect(personajes.cuatro).toContain('Bart')
})

Comprobar booleanos, undefined y null

  • toBeNull comprueba que el testeo solo debe ser null.
  • toBeUndefined comprueba que el testeo solo debe undefined.
  • toBeDefined comprueba que el testeo debe ser lo opuesto a undefined. Es estado de lo que se prueba debe estar definido.
  • toBeTruthy comprueba que el testeo solo debe true.
  • toBeFalsy comprueba que el testeo solo debe false.

Extra

Para negar cualquier tipo de testeo y esperar el resultado opuesto se debe usar not antes del método a ejecutar.

La función to Match te permite ver el formato del String que estás pasando lo que lo hace muchísimo más potente. Platzi tiene un curso muy bueno de expresiones regulares dictado por @beco.

Cabe resaltar que toBeTruthy() es solo para true, para false usamos toBeFalsy(), ya que Oscar dijo que servia para True o False es bueno resaltarlo.

Here el código de esta clase 😃
![](

const fruits = ["banana", "melon", "sandia", "naranja", "limon", "pepino"];

export const arrayFruits = () => fruits;
import { arrayFruits, arrayColors } from "../array";

describe("Probando nuestros arreglos", () => {
test("Tiene una banana", () => {
    expect(arrayFruits()).toContain("banana");
  });
  test("¿No tiene una mango?", () => {
    expect(arrayFruits()).not.toContain("mango");
  });
})

Excelente el orden y yo sufriendo con los QA

Puedes hacer CMD + K
Eso lo mismo que el clear y ahorras tiempo 😃

En el método toBeTruthy(), lo que realmente se analiza es que el valor sea Truthy (valga la redundancia).
.
Los valores truthy son:

  • Booleano true
  • Números que no sean el cero
  • Strings que no estén vacíos
  • Cualquier valor que no sea “undefined, null, etc”

toBeTruthy() y su contraparte toBeFalsy() no sirven para verificar valores de tipo booleano si no valores truthy o falsy, por lo que un test de la siguiente forma pasa la prueba

test('Verdadero',() => {
  expect('false').toBeTruthy()
})

Recordemos que los valores Truthy pueden ser:

Boolean(1)
Boolean(“a”)
Boolean([])
Boolean({})
Boolean(function(){})

Valores : Truthy y Falsy

Testing Callback

Testing truthy

Testing GraterThan

Estoy pensando en los posibles casos que podemos emplear para definir nuestras pruebas y que estas dependeran de los requerimientos que estemos desarrollando. Ejemplo si tenemos un formulario donde tenemos que evaluar una edad que tenga ser mayor o menos pudiese ser util esta prueba:

test('Greater than', () => {
  expect(10).toBeGreaterThan(9)
})

Se me ocurren casos de prueba para numeros de telefonos y cedulas de identidad tambien.

Otros casos donde tengamos algun proceso que siempre tenga que retornar un valor booleano pudiesemos contar con estos dos metodos para evaluar:

Verdadero:

test('Booleans true', () => {
  expect(true).toBeTruthy()
})

Falso:

test('Booleans false', () => {
  expect(false).toBeFalsy()
})

Implementar los test con funciones unitarias nos va a garantizar el funcionamiento de algo específico

Código de la clase

test('Debe ser verdadero', () => {
  expect(true).toBeTruthy();
});

const reverseString = (str, callback) => {
  callback(str.split('').reverse().join(''));
};

test('Probar el callback', () => {
  reverseString('Hola', (str) => {
    expect(str).toBe('aloH');
  });
});

Como puedo probar una función que no retorna nada?

muy interesante Oscar Barajas Tavares

muy bueno ❤️