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 30

Preguntas 3

Ordenar por:

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

o inicia sesi贸n.

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 馃槈

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.

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.

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");
  });
})

Les dejo la funci贸n de una forma m谩s amigable

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

Excelente el orden y yo sufriendo con los QA

describe('Strings', () => {
    test('toBe', () => {
        expect('Test').toBe('Test')
    })

    test('Match', () => {
        const expectedContainsWord = 'Hello';
        expect('Hello World').toMatch(expectedContainsWord)
    })
})

describe('Numbers', () => { 
    test('Greater than', () => {
        // Equal
        expect(2).toEqual(2)

        // Greater
        expect(1).toBeGreaterThan(0)

        // Greater or equal
        expect(2).toBeGreaterThanOrEqual(1)

        // Less than
        expect(1).toBeLessThan(2)

        // Less than or equal
        expect(1).toBeLessThanOrEqual(1)
    })
})

describe('Booleans', () => { 
    test('True', () => { 
        expect(true).toEqual(true)

        expect(false).toBe(false)
        
        /* accept truthy values */
        expect(true).toBeTruthy()
        expect('abc').toBeTruthy()
        expect([]).toBeTruthy()
        expect({}).toBeTruthy()
        expect(1).toBeTruthy()
        // expect(null).toBeTruthy() /* this doesn't work bc null is not a truthy value */

        /* accept falsy values */
        expect(false).toBeFalsy()
        expect('').toBeFalsy()
        expect(null).toBeFalsy()
        expect(undefined).toBeFalsy()
        expect(NaN).toBeFalsy()
        expect(0).toBeFalsy()
        // expect(1).toBeFalsy() /* this doesn't work bc numbers greater than 0 are not falsy values */
     }) 
 })

describe('Arrays', () => {
    test('Countries', () => {
        
        /* with this don't work */
        // const countries = ['Brazil', 'Singapur', 'New Zealand'];

        const countries = ['Brazil', 'Singapur', 'New Zealand', 'Paraguay'];
        expect(countries).toContain('Paraguay');
    })
})

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

tambi茅n podemos validar si existen varios elementos de un arreglo

const fruits = ['melon','manzana','banana']

test('驴Tenemos una banana y una manzana?', ()=> {
    expect(fruits).toContain('banana','manzana')
})

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(鈥渁鈥)
Boolean([])
Boolean({})
Boolean(function(){})

Valores : Truthy y Falsy

tobeTruthy no devuelve si es un booleano, retorna si lo que se le envia es un valor true en coersion de datos es decir 鈥淗ola鈥 == true ( es true ) en ese caso toBeTruthy funciona鈥
Pero Si usamos toBe(true)
Es comparacion estricta es decir

鈥淗ola鈥 === true? // False.

Como probar callbacks

Como lo dije antes, estos errores es correcto que salgan, pero aqui hay un truco, nosotros debemos saber a ciencia cierta que requerimos que salga, pero tambien codificar correctamente nuestros test para que no salgan errores, no de los resultados esperados, sino del bloque de codigo de los test鈥

exelente

*Mis notitas sobre la clase:

const text = " Hola, Mundo";
const fruits = ["Manzana", "Banano", "Pera", "Sandia"];


// Probando strings
test("Debe contener un texto", () => {
  expect(text).toMatch(/Mundo/);
});

// Progrando arrays
test("驴 Tenemos un Sandia ?", () => {
  expect(fruits).toContain("Sandia");
});

//Probando numeros
test("Mayor que", () => {
  expect(10).toBeGreaterThan(9);
});

// Probando booleanos 
test('Verdadero', () => {
    expect(true).toBeTruthy();
});


// Probando callbacks
const reverseSrting = (str , callback) => {
    callback(str.split("").reverse().join(""))
};

test ('Probar un Callback', () => {
    reverseSrting('Hola' , (str) => {
        expect(str).toBe('aloH');
    });
});

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 鈥渦ndefined, null, etc鈥

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 鉂わ笍