Quelle est la différence entre affirmer, attendre et devrait en 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');

InformationsquelleAutor Manu | 2014-01-28

269

Les différences sont documenté, il y.

Les trois interfaces les différents styles de l'exécution des assertions. En fin de compte, ils effectuent la même tâche. Certains utilisateurs préfèrent un style au-dessus des autres. Ceci étant dit, il y a aussi quelques considérations techniques qui méritent d':
1. L'affirmer et de s'attendre à des interfaces de ne pas modifier Object.prototype, alors que devrait ne. Ils sont donc un meilleur choix dans un environnement où vous ne pouvez pas ou ne souhaitez pas modifier Object.prototype.
2. L'affirmer et de s'attendre à des interfaces de soutien personnalisé des messages un peu partout. Par exemple:
```
assert.isTrue(foo, "foo should be true");
expect(foo, "foo should be true").to.be.true;
```
  Le message "foo doit être vrai" sera de sortie avec l'échec de l'assertion si l'assertion échoue. Vous n'obtenez pas la possibilité de mettre un message personnalisé avec le doit interface.
(Note historique: pendant longtemps, cette réponse a déclaré que, pour obtenir un message personnalisé avec expect, vous auriez à utiliser une solution de contournement. Aurélien Ribon m'a informé que le passage d'un message à expect comme deuxième paramètre fonctionne. Par conséquent, il n'est pas nécessaire pour une solution de contournement. Je n'ai pas été en mesure de trouver la version de Moka a commencé à fournir un soutien pour ce message, je n'ai pas été en mesure de trouver la version de la documentation documenté pour la première fois.)

Noter que assert.isTrue(foo), expect(foo).to.be.true et foo.should.be.true toutes les sorties suivantes si vous ne l'utilisez pas un message personnalisé, et foo === 1:
```
    AssertionError: expected 1 to be true
```
Ainsi, alors que le fait de s'attendre et doit interface sont plus agréables à lire, ce n'est pas comme une interface est naturellement plus riches en informations que les autres quand une assertion échoue. Ce message, qui est identique pour toutes les trois interfaces, ne dites pas que vous ce exactement que vous testiez, seulement que la valeur que vous avez obtenu était 1 mais vous avez voulu true. Si vous voulez savoir ce que vous étiez le test, vous devez ajouter un message.
- Notez que vous pouvez également faire expect(foo).to.equal(true, "foo should be true");
- Je ne peux pas obtenir tout message personnalisé à apparaître avec expect, à l'aide de la dernière version de moka
- La version de Moka n'est pas ce qui est essentiel ici. Êtes-vous à l'aide de la dernière Chai?
- De même pour moi, sur la vanille, express (4.16.3), moka (5.1.1), chai (4.1.2), chai-http (4.0.0) du projet. Le message personnalisé n'apparaissent pas n'importe où quand même couru avec la commande mocha et l'obtention d'un échec du test.
InformationsquelleAutor Louis
9

J'espère que ce n'exemples simple fait de leurs différences claires

Affirmer
```
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, l'assertion de style vous permet d'inclure une option de message comme le dernier paramètre dans l'instruction assert. Ceux-ci seront inclus dans les messages d'erreur de votre affirmation passe pas.

Note
attendre et doit chainable langue pour construire des assertions, mais ils diffèrent dans la façon dont l'affirmation est d'abord construit. Dans le cas de devrait, il y a aussi quelques mises en garde et des outils supplémentaires pour surmonter les mises en garde.

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);
```
Attendez vous permet d'inclure arbitraire des messages à ajouter tout a échoué affirmations qui pourraient se produire.
```
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);
```
C'est pratique quand utilisé avec des non-descript des sujets tels que des booléens ou des chiffres.

Devrait

Le devrait pour le même chainable affirmations comme le fait de s'attendre interface, mais il s'étend chaque objet avec un doit bien commencer votre chaîne. Ce style a des problèmes lorsqu'il est utilisé avec Internet Explorer, donc être 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 doit

Tout d'abord, notez que le fait de s'attendre besoin est juste une référence à la fonction d'attente, alors qu'avec l'exige, la fonction est exécutée.
```
var chai = require('chai')
, expect = chai.expect
, should = chai.should();
```
La attendre interface fournit une fonction en tant que point de départ pour le chaînage de votre langage d'assertions. Il fonctionne sur node.js et dans tous les navigateurs.

La devrait interface étend de l'Objet.prototype pour fournir un seul getter comme le point de départ de votre langage d'assertions. Il fonctionne sur node.js et dans tous les navigateurs, sauf Internet Explorer.

InformationsquelleAutor Adepoju Oluwasegun

Vous devez vous connecter pour publier un commentaire.