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?

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(“a”)
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 “Hola” == true ( es true ) en ese caso toBeTruthy funciona…
Pero Si usamos toBe(true)
Es comparacion estricta es decir

“Hola” === 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 “undefined, 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 ❤️