Me gustaría verificar que bar() se llama dentro de foo() desde mi prueba unitaria.
Pensé que los espías de Sinon podrían ser adecuados, pero no sé cómo usarlos.
¿Hay alguna forma de comprobar que se llama al método? ¿Quizás incluso extrayendo los argumentos utilizados en la llamada bar() ?
var spy = sinon.spy(foo); function foo(){ bar(1,2,3); } function bar(){ } foo(); // what to do with the spy?En su caso, está tratando de ver si se llamó a bar , por lo que desea espiar bar en lugar de foo .
Como se describe en el documento :
function bar(x,y) { console.debug(x, y); } function foo(z) { bar(z, z+1); } // Spy on the function "bar" of the global object. var spy = sinon.spy(window, "bar"); // Now, the "bar" function has been replaced by a "Spy" object // (so this is not necessarily what you want to do) foo(1); bar.getCall(0).args => should be [1,2]Ahora, espiar las partes internas de la función combina fuertemente su prueba de "foo" con su implementación, por lo que caerá en el debate habitual de "burlón vs clásico" .
Estoy de acuerdo con Adrian al decir que probablemente querías espiar un bar en su lugar.
var barSpy = sinon.spy(bar);Luego para comprobar que se llamó una vez
assert(barSpy.calledOnce);Acabo de llamar en absoluto
assert(barSpy.called)Llamado x cantidad de veces
assert.equal(barSpy.callCount, x);Si quieres extraer los argumentos de la primera llamada del espía:
var args = barSpy.getCalls()[0].argsEntonces puedes hacer lo que quieras con esos argumentos.
¿No deberías estar espiando en el bar, en lugar de foo?
var spy = sinon.spy(bar)Llamar a Foo:
foo()La barra de verificación se llamó:
console.log(spy.calledOnce)