javascript - test - toBe(verdadero) vs toBeTruthy() vs toBeTrue()

protractor tutorial

Question

¿Cuál es la diferencia entre expect(something).toBe(true) , expect(something).toBeTruthy() y expect(something).toBeTrue() ?

Tenga en cuenta que toBeTrue() es un marcador personalizado introducido en jasmine-matchers entre otros jasmine-matchers útiles y útiles como toHaveMethod() o toBeArrayOfStrings() .

La pregunta está destinada a ser genérica, pero, como un ejemplo del mundo real, estoy probando que un elemento se muestra en protractor . ¿Qué marcador debería usar en este caso?

expect(elm.isDisplayed()).toBe(true);
expect(elm.isDisplayed()).toBeTruthy();
expect(elm.isDisplayed()).toBeTrue();

Answer 1

Descargo de responsabilidad : esto es solo una suposición salvaje

Sé que todos adoran una lista fácil de leer:

• toBe(<value>) - El valor devuelto es igual que <value>
• toBeTrue() - Comprueba si el valor devuelto es true

• toBeTruthy() - Verifica si el valor, cuando se lanza a un booleano, será un valor verdadero

  Los valores de Truthy son todos los valores que no son 0 , '''' (cadena vacía), false , null , NaN , undefined o [] (matriz vacía) *.

  _{* Tenga en cuenta que cuando ejecuta !![] , devuelve true , pero cuando ejecuta [] == false también devuelve true . Depende de cómo se implemente. En otras palabras: (!![]) === ([] == false)}

En su ejemplo, toBe(true) y toBeTrue() arrojarán los mismos resultados.

Answer 2

En javascript hay trues y truthys. Cuando algo es verdadero, es obviamente cierto o falso. Cuando algo es verdad, puede o no ser un booleano, pero el valor "emitido" de es un booleano.

Ejemplos.

true == true; // (true) true
1 == true; // (true) truthy
"hello" == true;  // (true) truthy
[1, 2, 3] == true; // (true) truthy
[] == false; // (true) truthy
false == false; // (true) true
0 == false; // (true) truthy
"" == false; // (true) truthy
undefined == false; // (true) truthy
null == false; // (true) truthy

Esto puede simplificar las cosas si desea verificar si una cadena está configurada o si una matriz tiene algún valor.

var users = [];

if(users) {
  // this array is populated. do something with the array
}

var name = "";

if(!name) {
  // you forgot to enter your name!
}

Y como se dijo. expect(something).toBe(true) y expect(something).toBeTrue() es lo mismo. Pero expect(something).toBeTruthy() no es lo mismo que cualquiera de esos.

Answer 3

Hay muchas respuestas buenas, solo quería agregar un escenario donde el uso de estas expectativas podría ser útil. Usando element.all(xxx) , si necesito verificar si todos los elementos se muestran en una sola ejecución, puedo realizar -

expect(element.all(xxx).isDisplayed()).toBeTruthy(); //Expectation passes
expect(element.all(xxx).isDisplayed()).toBe(true); //Expectation fails
expect(element.all(xxx).isDisplayed()).toBeTrue(); //Expectation fails

La razón es que .all() devuelve una matriz de valores, por lo que se pueden realizar todo tipo de expectativas ( getText , isPresent , etc ...) con toBeTruthy() cuando .all() entra en escena. Espero que esto ayude.

Answer 4

Lo que hago cuando me pregunto algo así como la pregunta que se hace aquí es ir a la fuente.

ser()

expect().toBe() se define como:

function toBe() {
  return {
    compare: function(actual, expected) {
      return {
        pass: actual === expected
      };
    }
  };
}

Realiza su prueba con === que significa que cuando se usa como expect(foo).toBe(true) , pasará solo si foo realmente tiene el valor true . Los valores de Truthy no harán que pase la prueba.

toBeTruthy ()

expect().toBeTruthy() se define como:

function toBeTruthy() {
  return {
    compare: function(actual) {
      return {
        pass: !!actual
      };
    }
  };
}

Tipo de coacción

Un valor es verdad si la coacción de este valor a un valor booleano da el valor true . La operación !! prueba la veracidad al obligar al valor pasado a expect a un valor booleano. Tenga en cuenta que, contrariamente a lo que implies respuesta actualmente aceptada, == true no es una prueba correcta de la veracidad. Obtendrás cosas graciosas como

> "hello" == true
false
> "" == true
false
> [] == true
false
> [1, 2, 3] == true
false

Considerando que usando !! rendimientos:

> !!"hello"
true
> !!""
false
> !![1, 2, 3]
true
> !![] 
true

(Sí, vacío o no, una matriz es verdad).

a decir verdad()

expect().toBeTrue() es parte de jasmine-matchers (que está registrada en npm como jasmine-expect luego de que un proyecto posterior registrara primero jasmine-matchers ).

expect().toBeTrue() se define como:

function toBeTrue(actual) {
  return actual === true ||
    is(actual, ''Boolean'') &&
    actual.valueOf();
}

La diferencia con expect().toBeTrue() y expect().toBe(true) es que expect().toBeTrue() prueba si se trata de un objeto Boolean . expect(new Boolean(true)).toBe(true) fallaría mientras que expect(new Boolean(true)).toBeTrue() pasaría. Esto es por esta cosa graciosa:

> new Boolean(true) === true
false
> new Boolean(true) === false
false

Al menos es verdad

> !!new Boolean(true)
true

¿Cuál es el más adecuado para usar con elem.isDisplayed() ?

En última instancia, Transportador entrega esta solicitud al Selenio. La documentation indica que el valor producido por .isDisplayed() es una promesa que se resuelve en boolean . Lo tomaría al valor nominal y .toBeTrue() o .toBe(true) . Si encuentro un caso en el que la implementación devuelva los valores de truthy / falsy, presentaría un informe de error.