Javascript单元同步测试Promise.all

Question

I have a node.js application in which I have an object that maintains state and an update loop that updates this state every 30 seconds. Basically it is a build monitor that queries a build machine while serving the latest state of each pipeline to the frontend.

In the update loop I need to make several calls, for which I need all the data to make anything useful from it. Currently I wrap all these call in a Promise and use Promise.all to wait for them all to finish.

In the test I resolve each promise synchronously with the sinon-stub-promise package. This works perfectly for single promises. The problem however is that it does not work for Promise.all - at least synchronously. If I put a small timeout in my test then it passes fine.

Here are some snippets:

var pipelineRequests = pipelineNames.map(function(pipelineName) {
    return gocdClient.getPipelineStatus(pipelineName);
});

Promise.all(pipelineRequests)
    .then(function(values) {
        values.forEach(function(value) {
            // Do something now all data is available
        });
    });

So here I get a list of pipelinesNames and then create a request which returns a promise for each one of these pipelines. This works when I manually test it.

Now for the test code:

it("should wait for all to return before processing", function() {
        allPipelinesStub
            .returnsPromise().resolves({"NFT-Suite": ["Hour", "Overnight", "Weekend"]});

        pipelineStatusStub
            .withArgs("Hour")
            .returnsPromise().resolves({"status": "Passed", "build-number": 1, "upstream": ["GIT"]});

        pipelineStatusStub
            .withArgs("Overnight")
            .returnsPromise().resolves({"status": "Passed", "build-number": 1, "upstream": ["GIT"]});

        pipelineStatusStub
            .withArgs("Weekend")
            .returnsPromise().resolves({"status": "Passed", "build-number": 1, "upstream": ["GIT"]});

        var pipelinesService = require('../../src/services/pipelinesService');

        var pipelines = pipelinesService.getPipelines();
        should.exist(pipelines);
        pipelines.should.deep.equal({
            "NFT-Suite": {
                "Hour": {
                    "status": "Passed",
                    "build-number": 1,
                    "order": 0
                },
                "Overnight": {
                    "status": "Passed",
                    "build-number": 1,
                    "order": 0
                },
                "Weekend": {
                    "status": "Passed",
                    "build-number": 1,
                    "order": 0
                }
            }
        });
    });

The problem is pipelines is {} . If a call pipelinesService.getPipelines(); after a slight delay it works fine.

Testing these individually is fine because the stub resolves synchronously, I just can't find a way to force Promise.all to resolve after they all complete.

Is there a way to force this ? Or can I use sinon (or something else) to stub that out too ?

Appreciate any help

Answer 1

You need to decide what you are testing. If you want to test the code using Promise.all you need to return the promise - or at least some promise to indicate that the operation has completed. It doesn't mean you have to return the promise from your existing code: you can wrap the logic in another, private, function "_foo" and let your existing code use that, and then test "foo" from the outside instead of your original code.

If this is inside getPipelines() the test would simply work if you just did:

return pipelinesService.getPipelines().then(() => {
    should.exist(pipelines);
    pipelines.should.deep.equal({ 
    // more code ....
});