Appeler une fonction de module stub dans le même module

Question

Je ne trouve pas de moyen de stubber une fonction appelée depuis le même module où la fonction est définie (le stubbing ne semble pas fonctionner). Voici un exemple :

monModule.js :

'use strict'

function foo () {
  return 'foo'
}

exports.foo = foo

function bar () {
  return foo()
}

exports.bar = bar

monModule.test.js :

'use strict'

const chai = require('chai')
const sinon = require('sinon')

chai.should()

const myModule = require('./myModule')

describe('myModule', () => {
  describe('bar', () => {
    it('should return foo', () => {
      myModule.bar().should.equal('foo') // succeeds
    })

    describe('when stubbed', () => {
      before(() => {
        sinon.stub(myModule, 'foo').returns('foo2') // this stub seems ignored
      })

      it('should return foo2', () => {
        myModule.bar().should.equal('foo2') // fails
      })
    })
  })
})

Cela me rappelle les fonctions statiques Java qui ne sont (presque) pas stubables.

Une idée sur la façon de réaliser ce que je veux faire ? Je sais que c'est déroutant d'extraire foo 会起作用，但这不是我在这里想要做的。我还知道，在 bar 方法中使用关键字 this 调用 foo 也会起作用，我对在这种情况下使用 ̀this dans différents modules (puisque je n'utilise pas la POO).

Answer 1

Je suis un peu prudent quant à l'utilisation de exports car c'est un peu magique (par exemple, quand on code en Typescript, on ne l'utilise jamais directement), j'ai donc voulu proposer une solution alternative, qui nécessite malheureusement quand même de modifier le code source, Enveloppez simplement la fonction que vous souhaitez insérer dans un objet :

export const fooWrapper = {
    foo() {...}
}

function bar () {
    return fooWrapper.foo()
}

et sinon.stub(fooWrapper, 'foo'). C'est un peu dommage que vous deviez l'emballer comme ça juste pour tester, mais au moins c'est explicite et sécurisé dans Typescript (contrairement à sinon.stub(fooWrapper, 'foo')。只为了测试而必须这样包装有点遗憾，但至少它在 Typescript 中是显式的且类型安全的（与输入为 any 的 exports où l'entrée est any ). < /p>

Answer 2

Je viens de tester ça. Il fonctionne comme un charme.

'use strict'

function foo () {
  return 'foo';
}

exports.foo = foo;

function bar () {
  return exports.foo(); // <--- notice
}

exports.bar = bar;

Quand vous exécutez sinon.stub(myModule, 'foo').returns('foo2') 时，sinon 会存根导出对象的foo 并不是 myModule.js 中实际的 foo 函数...正如你必须知道的那样，foo 是可从模块外部访问。因此，当您设置 exports.foo 时，导出的对象 exports.foo 会存储 foo 的 ref。当您调用 sinon.stub(myModule, 'foo').returns('foo2') 时，sinon 将存根 exports.foo 并不是实际的 foo

J'espère que cela a du sens !