Mocha / Chai expect.to.throw não capturando erros lançados

Estou tendo problemas para conseguir o Chai expect.to.throw funcione em um teste para meu aplicativo node.js. O teste continua falhando com o erro gerado, mas se eu envolver o caso de teste na tentativa de capturar e afirmar o erro detectado, ele funcionará.

Não expect.to.throwfunciona como eu acho que deveria ou algo assim?

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

A falha:

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.

Você precisa passar uma função para expect. Como isso:

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

Do jeito que você está fazendo isso, você está passando para expecto resultado da chamada model.get('z'). Mas, para testar se algo é lançado, você precisa passar uma função para expect, que expectse chamará. O bindmétodo usado acima cria uma nova função que, quando chamada, chamará model.getcom thiso valor de modele o primeiro argumento definido como 'z'.

Uma boa explicação bindpode ser encontrada aqui .

Como esta resposta diz , você também pode simplesmente agrupar seu código em uma função anônima como esta:

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

E se você já estiver usando o ES6 / ES2015, também poderá usar a função de seta. É basicamente o mesmo que usar uma função anônima normal, mas mais curta.

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

Essa pergunta possui muitas, muitas duplicatas, incluindo perguntas que não mencionam a biblioteca de asserções Chai. Aqui estão os conceitos básicos reunidos:

A asserção deve chamar a função, em vez de avaliar imediatamente.

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

Você pode verificar se há erros específicos usando qualquer biblioteca de asserções:

Nó

  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./)

Devemos

  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 Expect

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

Você deve lidar com exceções que 'escapam' do teste

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

Isso pode parecer confuso no começo. Como andar de bicicleta, apenas 'clica' para sempre quando clica.

exemplos de doc ...;)

porque você confia no thiscontexto:

• que é perdido quando a função é invocada por .throw
• não há como saber o que isso deveria ser

você precisa usar uma destas opções:

• agrupar a chamada de método ou função dentro de outra função

• vincular o contexto

  // 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

Outra implementação possível, mais complicada do que a solução .bind (), mas que ajuda a enfatizar que expect () requer uma função que fornece um thiscontexto para a função coberta, você pode usar um call(), por exemplo,

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

Eu encontrei uma boa maneira de contornar isso:

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

É muito mais legível que minha versão antiga:

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