Qual'è la differenza tra assert, aspetta e dovrebbe in Chai?

Qual è la differenza tra assert, expecte shoulde quando usare cosa?

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

var foo = 'bar';

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

foo.should.equal('bar');

Le differenze sono documentate lì .

Le tre interfacce presentano diversi stili di affermazione performante. Alla fine, svolgono lo stesso compito. Alcuni utenti preferiscono uno stile rispetto all'altro. Detto questo, ci sono anche un paio di considerazioni tecniche da sottolineare:

1. Le interfacce asserire e aspettarsi non cambiano Object.prototype, mentre dovrebbe farlo . Quindi sono una scelta migliore in un ambiente in cui non è possibile o non si desidera cambiare Object.prototype.

2. Le interfacce asserire e prevedere supportano messaggi personalizzati praticamente ovunque. Per esempio:

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

   Il messaggio "pippo dovrebbe essere vero" verrà emesso insieme all'asserzione fallita se l'asserzione fallisce. Non hai l'opportunità di impostare un messaggio personalizzato con l'interfaccia should.

(Nota storica: per molto tempo questa risposta ha affermato che per ottenere un messaggio personalizzato con expect, dovresti usare una soluzione alternativa. Aurélien Ribon mi ha informato che passare un messaggio expectcome secondo parametro funziona. Di conseguenza, non è necessario una soluzione alternativa. Non sono stato in grado di trovare quale versione di Mocha ha iniziato a fornire supporto per questo messaggio, né sono stato in grado di trovare quale versione della documentazione lo ha documentato per la prima volta.)

Si noti che assert.isTrue(foo), expect(foo).to.be.truee foo.should.be.truetutto genera quanto segue se non si utilizza un messaggio personalizzato e foo === 1:

    AssertionError: expected 1 to be true

Quindi, mentre l'interfaccia attesa e dovrebbe essere più piacevole da leggere , non è come se un'interfaccia fosse più naturalmente informativa dell'altra quando un'asserzione fallisce. Questo messaggio, identico per tutte e tre le interfacce, non ti dice esattamente cosa stavi testando, solo che il valore che hai ottenuto era 1ma che volevi true. Se vuoi sapere cosa stavi testando, devi aggiungere un messaggio.

Spero che questi semplici esempi chiariscano le loro differenze

Asserire

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

In tutti i casi, lo stile assert consente di includere un messaggio facoltativo come ultimo parametro nell'istruzione assert. Questi saranno inclusi nei messaggi di errore se la tua affermazione non dovesse passare.

Nota aspettarsi e dovrebbe usare un linguaggio concatenabile per costruire asserzioni, ma differiscono nel modo in cui un'asserzione viene inizialmente costruita. Nel caso di dovrebbero, ci sono anche alcuni avvertimenti e strumenti aggiuntivi per superare le avvertenze.

Aspettarsi

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 ti consente di includere messaggi arbitrari da anteporre a eventuali asserzioni errate che potrebbero verificarsi.

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

Ciò è utile quando viene utilizzato con argomenti non descrittivi come numeri booleani o numeri.

Dovrebbero

Lo stile should consente le stesse asserzioni concatenabili dell'interfaccia prevede, tuttavia estende ogni oggetto con una proprietà should per avviare la catena. Questo stile presenta alcuni problemi quando viene utilizzato con Internet Explorer, quindi fai attenzione alla compatibilità del browser.

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

Le differenze tra aspettano e dovrebbero

Innanzitutto, notare che la richiesta di attesa è solo un riferimento alla funzione di attesa, mentre con la necessità di richiedere, la funzione è in esecuzione.

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

La aspettano interfaccia fornisce una funzione come punto di partenza per il concatenamento vostre affermazioni lingua. Funziona su node.js e in tutti i browser.

L' interfaccia dovrebbe estendere Object.prototype per fornire un singolo getter come punto di partenza per le asserzioni di lingua. Funziona su node.js e in tutti i browser moderni tranne Internet Explorer.