Javascript 如何使用jasmine对promise.all进行单元测试？

我有一个方法

core

，可以通过http调用获得响应。我尝试模拟

HttpRequest

响应，这样我就可以编写单元测试，在下面的代码中，所有测试用例都通过了，但它没有达到实际代码，并伪造响应，这样我的覆盖率就可以提高。 你知道什么是错误的吗

梅因酒店

export class OrderStatusApi <OrderStatusParam, OrderStatusResult> {
    function core(requestMethod) {
      let request = [requestMethod.http.makeRequest({
                url: {
                    name: "orderStatusApi",
                },
                body: {"request": {
                        "header": {
                            "CustomParams": {}
                        },
                        "memberInfo": {}
                    }},
                processResponse: async (_response: any): Promise<Interface.Core.ProcessResponse> => {
                    if (_response.response.header.statusList && Array.isArray(_response.response.header.statusList.status)) {
                        const emptyResponse = _response.response.header.statusList.status.filter((item: any) => {
                            return item.source === "LINKS" && item.statusDesc === "Orders Not Found";
                        });
                        if (emptyResponse.length > 0) {
                            throw {
                                statusCode: "0000",
                                statusDesc: emptyResponse[0].statusDesc,
                                refId: args.refId
                            };
                        } else {
                            return _response.response;
                        }
                    } else if (_response.response.header.statusCode === "0000") {
                        return _response.response;
                    } else {
                        throw _response.response.header;
                    }
                }

            })];
            return Promise.all(request);
        }
    }
}

导出类OrderStatusApi{
功能核心（请求方法）{
let request=[requestMethod.http.makeRequest({
网址：{
名称：“orderStatusApi”，
},
正文：{“请求”：{
“标题”：{
“CustomParams”：{}
},
“memberInfo”：{}
}},
processResponse:async（\u response:any）：Promise=>{
if（_response.response.header.statusList&&Array.isArray（_response.response.header.statusList.status））{
const emptyResponse=\u response.response.header.statusList.status.filter（（项：any）=>{
return item.source==“LINKS”&&item.statusDesc==“找不到订单”；
});
如果（emptyResponse.length>0）{
扔{
状态代码：“0000”，
statusDesc:emptyResponse[0]。statusDesc，
refId:args.refId
};
}否则{
返回_response.response；
}
}else if（_response.response.header.statusCode==“0000”）{
返回_response.response；
}否则{
抛出_response.response.header；
}
}
})];
返回承诺。全部（请求）；
}
}
}

main.spec.ts

 import { HttpRequest} from "./common-utils";
    import {OrderStatusApi} from "./main"
    it("it should get success response and call processResponse promise", async (done) => {
            const response = {
                "response": {
                    "header": {
                        "statusList": {
                            "status": [{source: "LINKS", statusDesc: "Orders Not Found"}]
                        }
                    }
                }
            };
            const HttpResponse = spyOn<any>(HttpRequest.http, "makeRequest").and.returnValue(Promise.resolve(response));
            const myPrivateSpy = spyOn<any>(Service, 'core').and.callThrough();
            let _Response:any;
             myPrivateSpy.call(Service, HttpResponse)
             .then(function(result: any){
             const request = [HttpResponse.makeRequest({
                 url: {name: "123", params: {}}, 
                 "body": {}, 
                 processResponse: jasmine.createSpy().and.returnValue(Promise.resolve(response))})
                ]
             _Response = Promise.all(request);
             console.log(result);
            //  _Response = result
            expect(HttpResponse).toHaveBeenCalled(); 
            expect(_Response[0].response.header.statusList.status).toEqual([{source: "LINKS", statusDesc: "Orders Not Found"}]);   
            expect(Service.core).toHaveBeenCalled();    
            });   
             done();        
        });

从“/common-utils”导入{HttpRequest}；
从“/main”导入{OrderStatusApi}
它（“它应该获得成功响应并调用processResponse promise”，异步（完成）=>{
常数响应={
“答复”：{
“标题”：{
“状态列表”：{
“状态”：[{来源：“链接”，状态描述：“未找到订单”}]
}
}
}
};
const HttpResponse=spyOn（HttpRequest.http，“makeRequest”）.and.returnValue（Promise.resolve（response））；
const myPrivateSpy=spyOn（服务，'core'）。和.callThrough（）；
让我们回答：任何；
myPrivateSpy.call（服务，HttpResponse）
.then（函数（结果：任意）{
const request=[HttpResponse.makeRequest({
url:{name:“123”，参数：{}，
“机构”：{}，
processResponse:jasmine.createSpy（）和.returnValue（Promise.resolve（response））}
]
_响应=承诺。全部（请求）；
控制台日志（结果）；
//_响应=结果
expect（HttpResponse）.tohavebeincall（）；
expect（_Response[0].Response.header.statusList.status）.toEqual（[{source:“LINKS”，statusDesc:“找不到订单”}]）；
expect（Service.core）.tohavebeencall（）；
});   
完成（）；
 });

为什么要使用

Promise.all

？阵列中只有一个承诺。也不清楚这其中的哪一部分应该被测试，你有这么多的嘲弄。还有另一个在承诺中的调用。所有这些我都将其删除为简化的代码understanding@jonrsharpe核心函数应该返回http模拟响应，因此基本上尝试测试

processResponse

，这是

makeRequest

的一部分，到目前为止，您的测试没有多大意义。您似乎正在重新实现测试中的方法并测试您的新版本。请从三个部分来考虑这一点：1。

makeRequest

是否使用正确的配置调用（您可以轻松创建并注入一个test double作为

core

的参数，您不需要监视任何东西）；2.如果您使用存根响应调用这些参数中的

processResponse

函数，它是否做了正确的事情；三,。

core

是否返回了最终的承诺？@jornsharpe今天浪费了我一整天的时间来研究如何组合测试，以便让这个测试正常工作，jasmine的新手你能帮我举个单元测试的例子吗。测试中为

response

的存根响应与

processResponse

预期的相同