Comment tester si une fonction appelle une méthode/fonction?

Est-il un moyen de Moka pour tester si une fonction appelle une méthode spécifique ou une fonction externe?

Je suis à l'aide de Moka avec Chai, mais je suis ouvert à toute autre affirmation des bibliothèques.

Ok, donc à tester si une méthode au est appelée est assez facile à utiliser sinon. Je ne suis pas sûr au sujet des tests pour voir si une fonction externe est appelé. J'ai donc mis à jour les exemples de représenter quelque chose d'un peu plus de "monde réel". Je suis en train de travailler sur un nœud de l'application, de sorte foo.js et bar.js sont les deux modules.

Exemple:

foo.js

var bar = require('bar');
var xyz = function () {};

var Foo = module.exports = function () {
  this.bar();
  bar();
  xyz();
};
Foo.prototype.bar = function () {};

bar.js

var bar = module.exports = function () {};

fooSpec.js

var chai      = require('chai');
var sinon     = require('sinon');
var sinonChai = require('sinonChai');
var expect    = chai.expect;
var Foo       = require('../lib/foo');

chai.use('sinonChai');

describe('Foo', function () {

  var method;

  beforeEach(function (done) {
    method = sinon.spy(Foo.prototype, 'bar');
    done();
  });
  afterEach(function (done) {
    method.restore();
    done();
  });

  it('should call Foo.prototype.bar() immediately', function () {

    new Foo();
    expect(method).to.have.been.called;

  });

  it('should call the module bar immediately', function () {
    //????????????
  });

  it('should call xyz() immediately', function () {
    //????????????
  });
});

Donc, comme vous pouvez le voir, j'ai compris comment le test pour Foo.prototype.bar, mais je ne peux pas trouver un moyen de mettre en œuvre les deuxième et troisième essais.

Si vos extraits sont destinés à être des modules qu'il serait utile de montrer ce que c'est vous dire à exporter à partir de vos modules, parce que c'est important pour le genre de réponses que vous allez obtenir.
J'ai mis à jour l'exemple avec plus de détails. Les fichiers d'exemple sont des modules dans un nœud de l'application.

OriginalL'auteur Hal Carleton | 2014-11-02

  1. 4

    Si cette question était vraiment deux en un.

    Tout d'abord, "comment tester si une méthode est appelée":
    J'ai mis le code dans l'exemple, mais, fondamentalement, à l'aide de sinon.js vous venez d'envelopper la méthode dans un "espion" qui vous permet d'écrire un test qui s'attend à ce que l'espion a été appelé.

    Deuxièmement, "comment tester si une fonction privée(qui n'a pas été exporté dans le cadre du module) a été appelé":

    Fondamentalement, vous n'avez pas. Il est possible d'exporter ces fonctions dans un environnement de test et non pas dans la production, mais cela semble un peu trop hacky pour moi.

    Je suis venu à la conclusion que lors de l'appel d'un autre module, vous venez de rompre le TDD cycle et pas de test pour cela, car il va probablement y avoir une petite quantité de code et le module a déjà été testé sur son propre.

    Si vous appelez une fonction privée qui est déclarée à l'intérieur vous êtes le module et souhaitez le tester, vous devez écrire un plus large d'essai pour vérifier que le résultat de cette fonction appelée plutôt que de tester si la fonction est appelée, ou ce qui se passe réellement à l'intérieur de la fonction.

    Voici un exemple simple:

    foo.js

    var _ = require('lodash');

var Foo = module.exports = function (config) {

  this.config = _.merge({
      role: 'user',
      x: '123',
      y: '321'
    },
    config);

  this.config.role = validateRole(this.config.role);
};

var validateRole = function (role) {
  var roles = [
    'user', 'editor', 'admin'
  ];

  if (_.contains(roles, role)) {
    return role;
  } else {
    return 'user'
  }
};

    fooSpec.js

    var chai = require('chai');
var expect = chai.expect;
var Foo = require('../lib/foo');

describe('Foo', function () {

  it('should set role to \'user\' if role is not valid', function () {

    var foo = new Foo({role: 'invalid'});
    expect(foo.config.role).to.equal('user');

  });

};

    OriginalL'auteur Hal Carleton

  2. 3

    Je suis en utilisant expect affirmation de la bibliothèque avec Mocha, mais Chai pourrait avoir analogues méthodes de

    Première

    Vous pouvez tester si une fonction appelle une méthode/fonction à l'aide d'Espions. Vous l'avez fait en vous code ci-dessus.

    Deuxième

    Le problème avec le code de test est le Contexte. Donc, je vais aborder dans cette réponse. Vous pouvez tester si une fonction externe est appelé, mais il a besoin d'un contexte, alors vous pourriez avoir à changer votre code.

    Je suis en utilisant bar (module) comme exemple. Pour xyz (fonction) aller à la Deuxième méthode. L'explication est la même pour les deux.

    1. L'exportation bar l'intérieur d'un objet

    bar.js

    var bar = module.exports = { 
  bar: function () {}; 
}

    foo.js

    var Foo = module.exports = function () {
  bar.bar();
  ....
};

    De cette façon, vous pouvez espionner sur elle:

    fooSpec.js

    it('should call the module bar immediately', function () {

  //note I'm getting the bar method from the exported object (bar module)
  var bar = expect.spyOn(bar, 'bar'); 

  new Foo();

  expect(bar).toHaveBeenCalled();

    2. Ensemble bar module Foo prototype de la méthode

    Si vous ne souhaitez pas changer de bar.js, vous pouvez configurer le module en tant que prototype de la méthode de Foo. Ensuite, vous avez un contexte d'espionner.

    foo.js

    var bar = require('./bar');

var Foo = module.exports = function () {
  this.bar();
  this.barModule();
};
Foo.prototype.bar = function () {};
Foo.prototype.barModule = bar; //setting here as barModule

    fooSpec.js

    it('should call the module bar immediately', function () {
  var barSpy = expect.spyOn(Foo.prototype, 'barModule');

  new Foo();

  expect(barSpy).toHaveBeenCalled();    
});

    Explication

    Les changements que vous devez faire sont pour changer le contexte de vos variables.

    De préciser:

    var bar = require('bar');

var Foo = module.exports = function () {
  this.bar();
  bar();
};
Foo.prototype.bar = function () {};

    Dans cet extrait de code, vous avez besoin bar et plus tard réglage this.bar à l'aide de Foo.prototype. Alors, comment pouvez-vous définir 2 variables avec le même nom et la référence de chaque autre bien?

    La réponse est le Contexte et la Portée. Votre this.bar référence à la bar variable définie dans this contexte (qui pointe vers Foo). D'autre part, votre bar - remarque il n'est pas this - fait référence à la bar ensemble de variable dans la fonction (module).

    Ainsi, vous pouvez tester votre Foo.prototype.bar, puisque c'est une méthode de module, a un contexte et vous pouvez espionner. Acheter vous ne pouvez pas espionner sur le bar parce qu'elle est étendue (privé).

    Bonne lecture: http://ryanmorr.com/understanding-scope-and-context-in-javascript/

    OriginalL'auteur jpenna