¿Cuál es la diferencia entre afirmar, esperar y debería en Chai?

¿Qué es la diferencia entre assert, expecty should, y cuándo usar qué?

assert.equal(3, '3', '== coerces values to strings');

var foo = 'bar';

expect(foo).to.equal('bar');

foo.should.equal('bar');

Las diferencias están documentadas allí .

Las tres interfaces presentan diferentes estilos de realización de aserciones. En última instancia, realizan la misma tarea. Algunos usuarios prefieren un estilo sobre el otro. Dicho esto, también hay un par de consideraciones técnicas que vale la pena destacar:

1. Las interfaces de afirmar y esperar no se modifican Object.prototype, mientras que debería hacerlo. Por lo tanto, son una mejor opción en un entorno en el que no puede o no desea cambiar Object.prototype.

2. Las interfaces de afirmar y esperar admiten mensajes personalizados en casi todas partes. Por ejemplo:

   assert.isTrue(foo, "foo should be true");
   expect(foo, "foo should be true").to.be.true;

   El mensaje "foo debería ser verdadero" se emitirá junto con la afirmación fallida si la afirmación falla. No tiene la oportunidad de configurar un mensaje personalizado con la interfaz debería.

(Nota histórica: durante mucho tiempo, esta respuesta indicó que para obtener un mensaje personalizado expect, tendría que usar una solución alternativa. Aurélien Ribon me informó que pasar un mensaje expectcomo un segundo parámetro funciona. En consecuencia, no hay necesidad de una solución alternativa. No pude encontrar qué versión de Mocha comenzó a proporcionar soporte para este mensaje, ni pude encontrar qué versión de la documentación lo documentó por primera vez).

Tenga en cuenta que assert.isTrue(foo), expect(foo).to.be.truey foo.should.be.truetodos generan lo siguiente si no utiliza un mensaje personalizado, y foo === 1:

    AssertionError: expected 1 to be true

Entonces, aunque la interfaz de esperar y debería ser más agradable de leer , no es como si una interfaz fuera más informativa que la otra cuando falla una aserción. Este mensaje, que es idéntico para las tres interfaces, no le dice qué estaba probando exactamente, solo que el valor que obtuvo fue el 1que deseaba true. Si desea saber qué estaba probando, debe agregar un mensaje.

Espero que estos simples ejemplos aclaren sus diferencias.

Afirmar

var assert = require('chai').assert
, foo = 'bar'
, beverages = { tea: [ 'chai', 'matcha', 'oolong' ] };

assert.typeOf(foo, 'string'); // without optional message
assert.typeOf(foo, 'string', 'foo is a string'); // with optional message
assert.equal(foo, 'bar', 'foo equal `bar`');
assert.lengthOf(foo, 3, 'foo`s value has a length of 3');
assert.lengthOf(beverages.tea, 3, 'beverages has 3 types of tea');

En todos los casos, el estilo de aserción le permite incluir un mensaje opcional como el último parámetro en la declaración de aserción. Estos se incluirán en los mensajes de error si su afirmación no se aprueba.

Tenga en cuenta esperar y debe usar un lenguaje encadenable para construir aserciones, pero difieren en la forma en que se construye inicialmente una aserción. En el caso de debería, también hay algunas advertencias y herramientas adicionales para superar las advertencias.

Esperar

var expect = require('chai').expect
, foo = 'bar'
, beverages = { tea: [ 'chai', 'matcha', 'oolong' ] };
expect(foo).to.be.a('string');
expect(foo).to.equal('bar');
expect(foo).to.have.lengthOf(3);
expect(beverages).to.have.property('tea').with.lengthOf(3);

Expect le permite incluir mensajes arbitrarios para anteponer cualquier afirmación fallida que pueda ocurrir.

var answer = 43;

// AssertionError: expected 43 to equal 42.
expect(answer).to.equal(42);

// AssertionError: topic [answer]: expected 43 to equal 42.
expect(answer, 'topic [answer]').to.equal(42);

Esto es útil cuando se usa con temas no descriptos como booleanos o números.

Debería

El estilo debería permitir las mismas aserciones encadenables que la interfaz esperada, sin embargo, extiende cada objeto con una propiedad debería para iniciar su cadena. Este estilo tiene algunos problemas cuando se usa con Internet Explorer, así que tenga en cuenta la compatibilidad del navegador.

var should = require('chai').should() //actually call the function
, foo = 'bar'
, beverages = { tea: [ 'chai', 'matcha', 'oolong' ] };

foo.should.be.a('string');
foo.should.equal('bar');
foo.should.have.lengthOf(3);
beverages.should.have.property('tea').with.lengthOf(3);

Diferencias entre esperar y debería

En primer lugar, tenga en cuenta que esperar require es solo una referencia a la función esperar, mientras que con require require, la función se está ejecutando.

var chai = require('chai')
, expect = chai.expect
, should = chai.should();

La interfaz de esperar proporciona una función como punto de partida para encadenar sus afirmaciones de idioma. Funciona en node.js y en todos los navegadores.

La interfaz debería extiende Object.prototype para proporcionar un getter único como punto de partida para sus afirmaciones de lenguaje. Funciona en node.js y en todos los navegadores modernos, excepto Internet Explorer.