web-dev-qa-db-fra.com

Quelle est la difference entre assert, expect et should in Chai?

Quelle est la différence entre assert, expect et should, et quand utiliser quoi?

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

var foo = 'bar';

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

foo.should.equal('bar');
javascriptmochachai
142
Manu

Les différences sont documentées ici .

Les trois interfaces présentent différents styles d'assertions performantes. En fin de compte, ils effectuent la même tâche. Certains utilisateurs préfèrent un style à l'autre. Ceci étant dit, il convient également de souligner quelques considérations techniques:

  1. Les interfaces assert et expect ne modifient pas Object.prototype, Alors que devrait. Ils constituent donc un meilleur choix dans un environnement où vous ne pouvez ou ne souhaitez pas modifier Object.prototype.

  2. Les interfaces assert et expect prennent en charge des messages personnalisés un peu partout. Par exemple:

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

    Le message "foo devrait être vrai" sera affiché avec l'assertion ayant échoué si l'assertion échoue. Vous n'avez pas la possibilité de définir un message personnalisé avec l'interface should.

(Remarque historique: pendant longtemps, cette réponse indiquait que pour obtenir un message personnalisé avec expect, il fallait utiliser une solution de contournement. Aurélien Ribon m'a informé que la transmission d'un message à expect en tant que deuxième paramètre fonctionne. Par conséquent, aucune solution de contournement n'est nécessaire. Je ne suis pas parvenu à trouver quelle version de Mocha a commencé à fournir un support pour ce message, ni à quelle version de la documentation documentée pour la première fois.)

Notez que assert.isTrue(foo), expect(foo).to.be.true et foo.should.be.true Génèrent tous les éléments suivants si vous n'utilisez pas de message personnalisé et foo === 1:

    AssertionError: expected 1 to be true

Ainsi, alors que les interfaces attendues et devraient être plus agréables à lire , ce n'est pas comme si une interface était plus informative que l'autre lorsqu'une assertion échoue. Ce message, identique pour les trois interfaces, ne vous dit pas ce que vous testiez exactement, seulement que la valeur que vous avez obtenue était 1 mais vous vouliez true. Si vous voulez savoir ce que vous testiez, vous devez ajouter un message.

271
Louis

J'espère que ces exemples simples clarifient leurs différences

Assert

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');

Dans tous les cas, le style d'assertion vous permet d'inclure un message facultatif en tant que dernier paramètre de l'instruction assert. Ceux-ci seront inclus dans les messages d'erreur si votre assertion échoue.

Note expect et devrait utiliser un langage chaînable pour construire des assertions, mais elles diffèrent par la manière dont une assertion est construite. Dans le cas de devrait, il y a aussi des mises en garde et des outils supplémentaires pour les surmonter.

Attendre

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 vous permet d'inclure des messages arbitraires avant les assertions manquées.

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

Cela est pratique lorsqu'il est utilisé avec des sujets non descriptifs tels que des booléens ou des nombres.

devrait

Le style devrait autorise les mêmes assertions chaînables que l'interface attendue, mais il étend chaque objet avec une propriété devrait pour démarrer votre chaîne. Ce style présente certains problèmes lorsqu'il est utilisé avec Internet Explorer. Soyez donc conscient de la compatibilité du navigateur.

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

Différences entre attendre et devrait

Tout d'abord, notez que l'attente attendue est simplement une référence à la fonction attendue, alors qu'avec le devrait exiger, la fonction est en cours d'exécution.

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

L’interface expect fournit une fonction comme point de départ pour enchaîner vos assertions de langue. Cela fonctionne sur node.js et dans tous les navigateurs.

L'interface devrait étend Object.prototype pour fournir un seul getter comme point de départ pour vos assertions de langue. Cela fonctionne sur node.js et dans tous les navigateurs modernes, à l'exception d'Internet Explorer.

10
Adépòjù Olúwáségun