Kann ich mock-Funktionen mit spezifischen Argumenten mit Scherz?

Ich möchte mock eine Funktion, mit Scherz, aber nur, wenn es aufgerufen wird, mit bestimmten Argumenten, zum Beispiel:

function sum(x, y) {
  return x + y;
}

//mock sum(1, 1) to return 4
sum(1, 1) //returns 4 (mocked)
sum(1, 2) //returns 3 (not mocked)

Gibt es eine ähnliche Funktion implementiert, in der Ruby ' s RSpec-Bibliothek:

class Math
  def self.sum(x, y)
    return x + y
  end
end

allow(Math).to receive(:sum).with(1, 1).and_return(4)
Math.sum(1, 1) # returns 4 (mocked)
Math.sum(1, 2) # returns 3 (not mocked)

Was ich versuche zu erreichen, in meinen tests wird eine bessere Entkopplung von, sagen wir, ich will zum testen eine Funktion, die sich auf sum:

function sum2(x) {
  return sum(x, 2);
}

//I don't want to depend on the sum implementation in my tests, 
//so I would like to mock sum(1, 2) to be "anything I want", 
//and so be able to test:

expect(sum2(1)).toBe("anything I want");

//If this test passes, I've the guarantee that sum2(x) is returning
//sum(x, 2), but I don't have to know what sum(x, 2) should return

Ich weiß, dass es eine Möglichkeit dies umzusetzen, indem er etwas wie:

sum = jest.fn(function (x, y) {
  if (x === 1 && y === 2) {
    return "anything I want";
  } else {
    return sum(x, y);
  }
});

expect(sum2(1)).toBe("anything I want");

Aber es wäre schön, wenn wir hatten einige Zucker-Funktion, um es zu vereinfachen.

Tut, es klingt vernünftig? Wir haben bereits diese Funktion im Scherz?

Danke für dein feedback.

InformationsquelleAutor Nícolas Iensen | 2017-01-17
  1. 15

    Fand ich diese Bibliothek, dass ein Kollege von mir schrieb vor kurzem: jest-when

    import { when } from 'jest-when';

const fn = jest.fn();
when(fn).calledWith(1).mockReturnValue('yay!');

const result = fn(1);
expect(result).toEqual('yay!');

    Hier ist die Bibliothek: https://github.com/timkindberg/jest-when

    InformationsquelleAutor STeve Shary
  2. 7

    Nein, es gibt keine Möglichkeit, dies zu tun im Scherz noch. Könnten Sie sinons stubs für diese. aus den docs:

    stub.withArgs(arg1[, arg2, ...]);

    Stubs die Methode nur für die
    sofern Argumente. Dies ist nützlich, zu mehr Ausdruckskraft in Ihrer
    Behauptungen, wo Sie zugreifen können, der Spion mit den gleichen Anruf. Es ist
    auch nützlich, um einen stub, der sich anders Verhalten in Reaktion auf
    verschiedene Argumente.

    "test should stub method differently based on arguments": function () {
    var callback = sinon.stub();
    callback.withArgs(42).returns(1);
    callback.withArgs(1).throws("TypeError");

    callback(); //No return value, no exception
    callback(42); //Returns 1
    callback(1); //Throws TypeError
}
    InformationsquelleAutor Andreas Köberle
  3. 2

    Dies kann helfen...

    Ich hatte so etwas ähnliches, wobei ich hatten die gleiche Methode namens mit verschiedenen Parametern, die unterschiedliche zurückgegebene Ergebnis der gekürzte/verspottet nennen. Ich habe eine variable mit einer Liste der Funktionen, wenn ich noch einen Aufruf an die verspottet service nehme ich die Funktion aus der Spitze der Warteschlange und der execute-Funktion. Es erfordert die Kenntnis der Reihenfolge der Ausführung, die Sie testen, und nicht wirklich im Griff Variation der Reaktion von argument, aber hat mir erlaubt, zu arbeiten, um die Beschränkung im Scherz.

    var mockedQueue = [];
mockedQueue.push(() => {return 'A';})
mockedQueue.push(() => {return 'B';})

service.invoke = jest.fn(()=>{
    serviceFunctionToCall = mockedQueue.shift();
    return serviceFunctionToCall();
})
    InformationsquelleAutor Adam
  4. 0

    Können Sie verwenden:

    const mockSum = jest.fn();

mockSum.mockImplementation((x, y) => {
  //Return whatever you want based on x and y...
});
    InformationsquelleAutor Daniel Muñoz
Schreibe einen Kommentar