web-dev-qa-db-fra.com

Classe ES2016, constructeur de tronçon Sinon

J'essaie de bloquer un super appel avec sinon, et es2016 mais je n'ai pas beaucoup de chance. Des idées pourquoi cela ne fonctionne pas?

En exécutant Node 6.2.2, cela pourrait être un problème avec son implémentation de classes/constructeurs.

Fichier .babelrc:

{
  "presets": [
    "es2016"
  ],
  "plugins": [
    "transform-es2015-modules-commonjs",
    "transform-async-to-generator"
  ]
}

Tester:

import sinon from 'sinon';

class Foo {
  constructor(message) {
    console.log(message)
  }
}

class Bar extends Foo {
  constructor() {
    super('test');
  }
}

describe('Example', () => {
  it('should stub super.constructor call', () => {
    sinon.stub(Foo.prototype, 'constructor');

    new Bar();

    sinon.assert.calledOnce(Foo.prototype.constructor);
  });
});

Résultat:

test
AssertError: expected constructor to be called once but was called 0 times
    at Object.fail (node_modules\sinon\lib\sinon\assert.js:110:29)
    at failAssertion (node_modules\sinon\lib\sinon\assert.js:69:24)
    at Object.assert.(anonymous function) [as calledOnce] (node_modules\sinon\lib\sinon\assert.js:94:21)
    at Context.it (/test/classtest.spec.js:21:18)

Note: ce problème ne semble se produire que pour les constructeurs. Je peux espionner les méthodes héritées de la classe parente sans aucun problème.

javascriptnode.jsmochasinonbabel
15
klyd

Vous devrez définirPrototypeOf des sous-classes en raison de la façon dont JavaScript implémente l'héritage.

const sinon = require("sinon");

class Foo {
  constructor(message) {
    console.log(message);
  }
}

class Bar extends Foo {
  constructor() {
    super('test');
  }
}

describe('Example', () => {
  it('should stub super.constructor call', () => {
    const stub = sinon.stub().callsFake();
    Object.setPrototypeOf(Bar, stub);

    new Bar();

    sinon.assert.calledOnce(stub);
  });
});
10
Wenshan

Ça ne marche pas non plus pour moi. J'ai géré une solution de contournement qui fonctionne pour moi, j'utilise également Spy:

class FakeSchema {
  constructor(newCar) {
    this.constructorCallTest();
    this.name = newCar.name;
  }

  constructorCallTest() {
    mochaloggger.log('constructor was called');
  }

}

// spy that tracks the contsructor call
var fakeSchemaConstrSpy = sinon.spy(FakeCarSchema.prototype,'constructorCallTest');

J'espère que cela a été utile

0
Martin Kuzdowicz

Vous devez spy au lieu de stub,

sinon.spy(Foo.prototype, 'constructor');

describe('Example', () => {
  it('should stub super.constructor call', () => {
    const costructorSpy = sinon.spy(Foo.prototype, 'constructor');
    new Bar();
    expect(costructorSpy.callCount).to.equal(1);
  });
});

***** Mise à jour ****** Ci-dessus ne fonctionnait pas comme prévu, j'ai ajouté de cette façon et fonctionne maintenant.

 describe('Example', () => {
    it('should stub super.constructor call', () => {
      const FooStub = spy(() => sinon.createStubInstance(Foo));
      expect(FooStub).to.have.been.calledWithNew;
    });
 });
0
anoop

Si vous êtes dans un environnement de navigateur, les opérations suivantes fonctionnent également:

let constructorSpy = sinon.spy(window, 'ClassName');

Par exemple, cela fonctionnerait avec Jasmine.

Mocha s'exécute à la place dans l'environnement Node, il n'y a pas de window. La variable que vous recherchez est global

0
Fabio Lolli