Jasmine. Matchers (II) - toBeTruthy, toBeFalsy, toContain, toBeLessThan, toBeGreaterThan, toBeCloseTo

Artículos anteriores:
Jasmine. Introducción. Creando el primer test
Jasmine. Matchers (I) - toBe, toEqual, toMatch, toBeDefined, toBeUndefined, toBeNull

En este artículo sigo repasando los diferentes matchers que nos proporciona el framework de Jasmine. Concretamente veremos los matchers toBeTruthy, toBeFalsy, toContain, toBeLessThan, toBeGreaterThan, toBeClose.

toBeTruthy

Comprueba si el valor actual se evalúa como "verdadero". El concepto de "verdadero"(true) en Jasmine es el mismo que en JavaScript. Se considera "verdadero" el valor true pero también un valor numérico diferente de 0, una cadena no vacía, un objeto, etc. Es decir se evalúan como "verdadero" todos los valores excepto los siguientes que se evalúan a "falso":

• false
• 0
• null
• ""
• undefined
• NaN

• Matcher_toBeTruthy.specs.js

describe("toBeTruthy", function () {
    var definedValue = 4;
    var nullValue = null;
    var undefinedValue;
    var emptyObject = {};
    var trueValue = true;
    var falseValue = false;

    it("Una variable inicializada es 'verdadero'", function () {
        expect(definedValue).toBeTruthy();
    });

    it("Una variable con valor null no es 'verdadero'", function () {
        expect(nullValue).not.toBeTruthy();
    });

    it("Una variable no incializada no es 'verdadero'", function () {
        expect(undefinedValue).not.toBeTruthy();
    });

    it("Un objeto, aunque esté vacío, es 'verdadero'", function () {
        expect(emptyObject).toBeTruthy();
    });

    it("El valor true es 'verdadero'", function () {
        expect(trueValue).toBeTruthy();
    });

    it("El valor false no es 'verdadero'", function () {
        expect(falseValue).not.toBeTruthy();
    });

});

toBeFalsy

Comprueba si el valor actual se evalúa como "falso".

Es equivalente a not.toBeTruthy.

• Matcher_toBeFalsy.specs.js

describe("toBeFalsy", function () {
    var definedValue = 4;
    var nullValue = null;
    var undefinedValue;
    var emptyObject = {};
    var trueValue = true;
    var falseValue = false;

    it("Una variable inicializada no es 'falso'", function () {
        expect(definedValue).not.toBeFalsy();
    });

    it("Una variable con valor null es 'falso'", function () {
        expect(nullValue).toBeFalsy();
    });

    it("Una variable no incializada es 'falso'", function () {
        expect(undefinedValue).toBeFalsy();
    });

    it("Un objeto, aunque esté vacío, no es 'falso'", function () {
        expect(emptyObject).not.toBeFalsy();
    });

    it("El valor true no es 'falso'", function () {
        expect(trueValue).not.toBeFalsy();
    });

    it("El valor false es 'falso'", function () {
        expect(falseValue).toBeFalsy();
    });

});

toContain

Comprueba si un array contiene un valor dado. toContain comprueba si alguno de los elementos del array es igual al valor, pero no necesariamente tiene que ser el mismo objeto. Es decir, realiza una comprobación como la que realiza el matcher toEqual.

• Matcher_toContain.specs.js

describe("toContain", function () {
    var numArray = ["uno", "dos", "tres"];
    var numObect = { primero: "uno", segundo: "dos", tercero: "tres" };
    var objectArray = [{ primero: "uno" }, { segundo: "dos" }, { tercero: "tres" }];

    it("El array contiene la cadena 'dos'", function () {
        expect(numArray).toContain("dos");
    });

    it("El array no contiene la cadena 'cuatro'", function () {
        expect(numArray).not.toContain("cuatro");
    });

    it("No busca propiedades en un objeto", function () {
        expect(numObect).not.toContain("segundo");
    });

    it("No busca en los valores de las propiedades de un objeto", function () {
        expect(numObect).not.toContain("dos");
    });

    it("Comprueba que el valor sea igual a un elemento, aunque no sea el mismo", function () {
        expect(objectArray).toContain({ segundo: "dos" });
    });
});

toBeLessThan

Comprueba si el valor actual es menor que un valor dado.

• Matcher_toBeLessThan.specs.js

describe("toBeLessThan", function () {

    var value = 5;

    it("5 es menor que 10", function () {
        expect(value).toBeLessThan(10);
    });

    it("5 no es menor que 5", function () {
        expect(value).not.toBeLessThan(5);
    });

    it("5 no es menor que null", function () {
        expect(value).not.toBeLessThan(null);
    });

    it("a es menor que j", function () {
        expect("a").toBeLessThan("j");
    });

});

toBeGreaterThan

Comprueba si el valor actual es mayor que uno dado.

• Matcher_toBeGreaterThan.specs.js

describe("toBeGreaterThan", function () {

    var value = 5;

    it("5 no es mayor que 10", function () {
        expect(value).not.toBeGreaterThan(10);
    });

    it("5 no es mayor que 5", function () {
        expect(value).not.toBeGreaterThan(5);
    });

    it("5 es mayor que null", function () {
        expect(value).toBeGreaterThan(null);
    });

    it("a no es mayor que j", function () {
        expect("a").not.toBeGreaterThan("j");
    });

});

toBeCloseTo

Comprueba si un número decimal es cercano a otro indicando el número de decimales que deben coincidir para cumplirse la condición.

Para hacer la comparación Jasmine no ignora el resto de decimales si no que realiza un redondeo al número de decimales indicado antes de comparar los valores.

• Matcher_toBeCloseTo.specs.js

describe("toBeCloseTo", function () {

    var value = 4.3546731;

    it("4.3546731 coincide con 4.3547 hasta el cuarto decimal", function () {
        expect(value).toBeCloseTo(4.3547, 0);
        expect(value).toBeCloseTo(4.3547, 1);
        expect(value).toBeCloseTo(4.3547, 2);
        expect(value).toBeCloseTo(4.3547, 3);
        expect(value).toBeCloseTo(4.3547, 4);
        expect(value).not.toBeCloseTo(4.3547, 5);
    });

    it("4.3546731 coincide con 4.3546 hasta el tercer decimal", function () {
        expect(value).toBeCloseTo(4.3546, 0);
        expect(value).toBeCloseTo(4.3546, 1);
        expect(value).toBeCloseTo(4.3546, 2);
        expect(value).toBeCloseTo(4.3546, 3);
        expect(value).not.toBeCloseTo(4.3546, 4);
        expect(value).not.toBeCloseTo(4.3546, 5);
    });

    it("4.8 coincide con 5 pero no con 4", function () {
        var value = 4.8;
        expect(value).toBeCloseTo(5, 0);
        expect(value).not.toBeCloseTo(4, 0);
    })

});

Artículo siguiente:
Jasmine. Matchers (III) - toThrow, toThrowError