javascript - ejemplos - i html

¿Cómo probar múltiples llamadas a la misma función con diferentes parámetros?

Question

Supongo que tengo una función como esta:

function foo () {
obj.method(1);
obj.method(2);
obj.method(3);
}

Para probarlo quiero hacer 3 pruebas (usando Mocha TDD y Sinon):

test(''medthod is called with 1'', function () {
var expectation = sinon.mock(obj).expects(''method'').once().withExactArgs(1);
foo();
expectation.verify();
});
test(''medthod is called with 2'', function () {
var expectation = sinon.mock(obj).expects(''method'').once().withExactArgs(2);
foo();
expectation.verify();
});
test(''medthod is called with 3'', function () {
var expectation = sinon.mock(obj).expects(''method'').once().withExactArgs(3);
foo();
expectation.verify();
});

El uso de este sistema sinon falla con el mensaje de "llamada inesperada" en cada prueba.

Lo he resuelto uniendo las pruebas de árbol en una:

test(''medthod is called with 1, 2 and 3'', function () {
var mock = sinon.mock(obj);
mock.expects(''method'').once().withExactArgs(1);
mock.expects(''method'').once().withExactArgs(2);
mock.expects(''method'').once().withExactArgs(3);
foo();
mock.verify();
});

Pero quiero tener tres pruebas y no una con tres afirmaciones / expectativas.

¿Cómo se puede lograr esto?

Answer 1

Como siempre, cuando hay algo extraño en una prueba, el problema está en el código que se está probando .

En este caso sufrimos de acoplamiento. Actualmente la función tiene dos responsabilidades:

• Decidir los datos a utilizar.
• Llama al método con los datos.

Para resolver esto, debemos dividir las responsabilidades en dos funciones / objetos / clases y luego probar cada una por separado. Por ejemplo, una posibilidad podría ser:

• La primera función (una que genera y devuelve los datos) se probaría verificando que los datos devueltos coincidan con nuestras expectativas.

• La segunda función (la nuestra original) tendría una prueba de verificación de que llama al generador de datos, luego una prueba de que envía los datos correctamente a la función esperada y una tercera que comprueba que llama a las funciones tantas veces como sea necesario. los datos.

El código sería algo como esto:

function foo() {
dataGenerator.generate().forEach(function (item) {
obj.method(item);
})
}
dataGenerator.generate = function () {
return [1,2,3];
};

Y las pruebas:

test(''generateData is called'', function () {
var expectation = sinon.mock(dataGenerator).expects(''generate'').once();
foo();
expectation.verify();
});
test(''method is called with the correct args'', function () {
var expectedArgs = 1;
sinon.stub(dataGenerator, "generate").returns([expectedArgs]);
var expectation = sinon.mock(obj).expects(''method'').once().withExactArgs(expectedArgs);
foo();
expectation.verify();
});
test(''method is called as many times as the amount of data'', function () {
sinon.stub(dataGenerator, "generate").returns([1,2]);
var expectation = sinon.mock(obj).expects(''method'').twice();
foo();
expectation.verify();
});
test(''dataGenerator.generate returns [1,2,3]'', function () {
var expected = [1,2,3];
var result = dataGenerator.generate();
assert.equal(result, expected)
});

Tenga en cuenta que la tercera prueba solo verifica la cantidad de veces que se llama al método. La segunda prueba ya ha verificado que los datos se pasan correctamente y la cuarta prueba los datos en sí.

Answer 2

Esta es una versión hinchada, pero esta solución podría funcionar. No estoy seguro de si todavía lo necesitas, pero lo estoy agregando aquí. http://jsfiddle.net/reyuto/jhkL7j34/

 obj = {
method: function (param) {}
};
function foo() {
obj.method(1);
obj.method(2);
obj.method(3);
}
mock = sinon.mock(obj);
QUnit.test(''method is called with 1'', function () {
var expectation1 = mock.expects(''method'').once().withExactArgs(1);
var expectation2 = mock.expects(''method'').atLeast(2);
foo();
expectation1.verify();
expectation2.verify();
});
QUnit.test(''method is called with 2'', function () {
var expectation1 = mock.expects(''method'').atLeast(1);
var expectation2 = mock.expects(''method'').once().withExactArgs(2);
var expectation3 = mock.expects(''method'').atLeast(1);
foo();
expectation1.verify();
expectation2.verify();
expectation3.verify();
});
QUnit.test(''method is called with 3'', function () {
var expectation1 = mock.expects(''method'').once().withExactArgs(3);
var expectation2 = mock.expects(''method'').atLeast(2);
foo();
expectation1.verify();
expectation2.verify();
});