So testen Sie mehrere Aufrufe der gleichen Funktion mit verschiedenen params?

Nehme ich eine Funktion wie diese:

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

Um es zu testen möchte ich es in 3 tests (mit Mokka TDD und 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();
});

Mit diesem system sinon schlägt mit "Anruf" - Nachricht auf jedem test.

Habe ich es gelöst Beitritt der Baum-tests in einem:

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();
});

Aber ich möchte drei tests und auch nicht mit drei Behauptungen/Erwartungen.

Wie kann das erreicht werden?

InformationsquelleAutor der Frage Kaizo | 2014-01-16

Wie immer, wenn es etwas seltsam über einen test, das problem ist im code getestet.

In diesem Fall leiden wir unter Kopplung. Derzeit wird die Funktion hat zwei Aufgaben:

Entscheiden, die Daten zu verwenden.
Aufruf der Methode mit den Daten.

Um dieses Problem zu lösen, müssen wir teilen die Aufgaben in zwei Funktionen/Objekte/Klassen und testen Sie diese einzeln. Zum Beispiel eine Möglichkeit sein könnte:

Die erste Funktion (die man erzeugt und die Daten zurück) würde getestet werden, überprüfen Sie, dass die zurückgegebenen Daten entspricht unseren Erwartungen.
Die zweite Funktion (unser original) würde die test-Prüfung, ruft es die Daten-generator, dann einen test zu prüfen, dass es sendet die Daten korrekt auf die zu erwartende Funktion und eine Dritte Prüfung, die es ruft die Funktionen so oft wie nötig, indem Sie die Daten.

Würde der code so etwas wie dieses:

function foo() {
    dataGenerator.generate().forEach(function (item) {
        obj.method(item);
    })
}

dataGenerator.generate = function () {
    return [1,2,3];
};

Tests:

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)
});

Beachten Sie, dass der Dritte test überprüft nur die Menge, wie oft die Methode aufgerufen wird. Der zweite test bereits überprüft, dass die Daten richtig übergeben und vierten tests die Daten selbst.

InformationsquelleAutor der Antwort Kaizo

Dies ist eine aufgeblähte version, aber diese Lösung könnte funktionieren. Nicht sicher, ob Sie es noch brauchen, aber ich bin nur, indem es hier. 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();
    });

InformationsquelleAutor der Antwort reyuto

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.