Mokka / Chai erwarten, dass sie keine geworfenen Fehler abfangen

Ich habe Probleme damit, dass Chai's expect.to.throwin einem Test für meine node.js-App funktioniert. Der Test schlägt bei dem ausgelösten Fehler immer wieder fehl, aber wenn ich den Testfall mit dem Versuch abfange, den abgefangenen Fehler abzufangen und zu bestätigen, funktioniert er.

Funktioniert expect.to.thrownicht so wie ich es mir vorstelle oder so?

it('should throw an error if you try to get an undefined property', function (done) {
  var params = { a: 'test', b: 'test', c: 'test' };
  var model = new TestModel(MOCK_REQUEST, params);

  // neither of these work
  expect(model.get('z')).to.throw('Property does not exist in model schema.');
  expect(model.get('z')).to.throw(new Error('Property does not exist in model schema.'));

  // this works
  try { 
    model.get('z'); 
  }
  catch(err) {
    expect(err).to.eql(new Error('Property does not exist in model schema.'));
  }

  done();
});

Der Fehlschlag:

19 passing (25ms)
  1 failing

  1) Model Base should throw an error if you try to get an undefined property:
     Error: Property does not exist in model schema.

Sie müssen eine Funktion an übergeben expect. So was:

expect(model.get.bind(model, 'z')).to.throw('Property does not exist in model schema.');
expect(model.get.bind(model, 'z')).to.throw(new Error('Property does not exist in model schema.'));

Die Art und Weise Sie es tun, sind vorbei Sie expectdas Ergebnis des Aufrufs model.get('z'). Aber um zu testen, ob etwas geworfen wird, müssen Sie eine Funktion übergeben expect, die expectsich selbst aufruft. Die bindoben verwendete Methode erstellt eine neue Funktion, die beim Aufruf model.getmit thisset auf den Wert von modelund dem ersten Argument auf gesetzt wird 'z'.

Eine gute Erklärung binddazu finden Sie hier .

Wie diese Antwort sagt , können Sie Ihren Code auch einfach in eine anonyme Funktion wie diese einschließen:

expect(function(){
    model.get('z');
}).to.throw('Property does not exist in model schema.');

Und wenn Sie bereits ES6 / ES2015 verwenden, können Sie auch eine Pfeilfunktion verwenden. Dies entspricht im Wesentlichen der Verwendung einer normalen anonymen Funktion, ist jedoch kürzer.

expect(() => model.get('z')).to.throw('Property does not exist in model schema.');

Diese Frage enthält viele, viele Duplikate, einschließlich Fragen, in denen die Chai-Assertionsbibliothek nicht erwähnt wird. Hier sind die Grundlagen zusammengefasst:

Die Assertion muss die Funktion aufrufen, anstatt sie sofort auszuwerten.

assert.throws(x.y.z);      
   // FAIL.  x.y.z throws an exception, which immediately exits the
   // enclosing block, so assert.throw() not called.
assert.throws(()=>x.y.z);  
   // assert.throw() is called with a function, which only throws
   // when assert.throw executes the function.
assert.throws(function () { x.y.z });   
   // if you cannot use ES6 at work
function badReference() { x.y.z }; assert.throws(badReference);  
   // for the verbose
assert.throws(()=>model.get(z));  
   // the specific example given.
homegrownAssertThrows(model.get, z);
   //  a style common in Python, but not in JavaScript

Sie können mit einer beliebigen Assertionsbibliothek nach bestimmten Fehlern suchen:

Knoten

  assert.throws(() => x.y.z);
  assert.throws(() => x.y.z, ReferenceError);
  assert.throws(() => x.y.z, ReferenceError, /is not defined/);
  assert.throws(() => x.y.z, /is not defined/);
  assert.doesNotThrow(() => 42);
  assert.throws(() => x.y.z, Error);
  assert.throws(() => model.get.z, /Property does not exist in model schema./)

Sollte

  should.throws(() => x.y.z);
  should.throws(() => x.y.z, ReferenceError);
  should.throws(() => x.y.z, ReferenceError, /is not defined/);
  should.throws(() => x.y.z, /is not defined/);
  should.doesNotThrow(() => 42);
  should.throws(() => x.y.z, Error);
  should.throws(() => model.get.z, /Property does not exist in model schema./)

Chai erwarten

  expect(() => x.y.z).to.throw();
  expect(() => x.y.z).to.throw(ReferenceError);
  expect(() => x.y.z).to.throw(ReferenceError, /is not defined/);
  expect(() => x.y.z).to.throw(/is not defined/);
  expect(() => 42).not.to.throw();
  expect(() => x.y.z).to.throw(Error);
  expect(() => model.get.z).to.throw(/Property does not exist in model schema./);

Sie müssen Ausnahmen behandeln, die dem Test entkommen

it('should handle escaped errors', function () {
  try {
    expect(() => x.y.z).not.to.throw(RangeError);
  } catch (err) {
    expect(err).to.be.a(ReferenceError);
  }
});

Dies kann zunächst verwirrend aussehen. Wie beim Fahrradfahren "klickt" es für immer, sobald es klickt.

Beispiele aus doc ...;)

weil Sie sich auf den thisKontext verlassen:

• Dies geht verloren, wenn die Funktion von .throw aufgerufen wird
• Es gibt keine Möglichkeit zu wissen, was das sein soll

Sie müssen eine der folgenden Optionen verwenden:

• Wickeln Sie den Methoden- oder Funktionsaufruf in eine andere Funktion ein

• binde den Kontext

  // wrap the method or function call inside of another function
  expect(function () { cat.meow(); }).to.throw();  // Function expression
  expect(() => cat.meow()).to.throw();             // ES6 arrow function
  
  // bind the context
  expect(cat.meow.bind(cat)).to.throw();           // Bind

Eine andere mögliche Implementierung, die umständlicher ist als die .bind () -Lösung, aber eine, die dabei hilft, den erwarteten Punkt () zu verdeutlichen, erfordert eine Funktion, die einen thisKontext für die abgedeckte Funktion bereitstellt. Sie können call()z.

expect(function() {model.get.call(model, 'z');}).to.throw('...');

Ich habe einen schönen Weg gefunden, um es zu umgehen:

// The test, BDD style
it ("unsupported site", () => {
    The.function(myFunc)
    .with.arguments({url:"https://www.ebay.com/"})
    .should.throw(/unsupported/);
});


// The function that does the magic: (lang:TypeScript)
export const The = {
    'function': (func:Function) => ({
        'with': ({
            'arguments': function (...args:any) {
                return () => func(...args);
            }
        })
    })
};

Es ist viel besser lesbar als meine alte Version:

it ("unsupported site", () => {
    const args = {url:"https://www.ebay.com/"}; //Arrange
    function check_unsupported_site() { myFunc(args) } //Act
    check_unsupported_site.should.throw(/unsupported/) //Assert
});