@rabbitio/ui-kit 1.0.0-beta.41 → 1.0.0-beta.43

package/src/robustExteranlApiCallerService/tests/robustExternalAPICallerService/robustExternalAPICallerService/callExternalAPI/_performCallAttempt.test.js

@@ -0,0 +1,787 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+import { v4 } from "uuid";
+import { ExternalApiProvider } from "../../../../externalApiProvider.js";
+import { ApiGroup } from "../../../../../common/external-apis/apiGroups.js";
+import { AxiosAdapter } from "../../../../../common/adapters/axiosAdapter.js";
+import { RobustExternalAPICallerService } from "../../../../robustExternalAPICallerService.js";
+
+/**
+ * _performCallAttempt what aspects to test:
+ * + 1. Should reorder providers according to nice factor
+ * + 2. Should not touch the instance's providers list during the reordering
+ * + 3. Should call only first provider if it returns data
+ * + 4. Should call several providers until the data retrieved
+ * + 5. Should return null data if all providers returns null
+ * + 6.1 Should return shouldBeForceRetried=true if all providers declined by RPS (isRPSExceeded returns true)
+ * + 6.2 Should return shouldBeForceRetried=true if some providers fail and the rest ones declined by RPS (isRPSExceeded returns true) and count of requests declined by RPS is more than ceil of half of providers count
+ * + 7.1. Should return rpsFactor multiplied by rpsMultiplier if all providers declined by RPS (isRPSExceeded returns true)
+ * + 7.2. Should return rpsFactor multiplied by rpsMultiplier if some providers fail and the rest ones declined by RPS (isRPSExceeded returns true) and count of requests declined by RPS is more than ceil of half of providers count
+ * + 8. Should return the errors list caught when calling the providers and one of them fails
+ * + 9. Should return the errors list caught when calling the providers and all them fail
+ * + 9.1 Should return null data when all the providers fail
+ * + 10. Should not call the provider if it has RPS and rpsEnsurer says that this domain's RPS is exceeded
+ * + 11. Should correctly count the number of requests declined by RPS exceeding
+ * + 12. Should add cancelToken to axios params if it is not null
+ * + 13. Should add timeout to axios params if a provider has it
+ * + 14. Should do all sub-request if all of them except one don't fail
+ * + 15. Should call proper sub-request's query composer if there are composers for each sub-request
+ * + 16. Should pass correct endpoint with query returned by query composer as the first axios param
+ * 17. Should call composeBody if the http method is post/put/patch
+ * 18. Should pass body as the second axios parameter if httpMethod is post/put/patch and it is present
+ * 18. Should pass null as the second axios parameter if httpMethod is post/put/patch and the provider has no bodyComposer
+ * 19. Should make requests for each page if requests for previous pages succeed
+ * 20. Should make requests for all pages till not failing
+ * 21. Should actualize last called timestamp by calling rpsEnsuring method
+ * 22. Should pass axios config as the third parameter if http method is post/put/patch
+ * 23. Should pass axios config as the second parameter if the http method is not post/put/patch
+ * 24. Should notify stats collector that the service is called without an error
+ * 25. Should call query parameters changer for second and more pages
+ * 26. Should call dedicated query parameters changer for second and more pages if the request has sub-requests
+ * 27. Should pass proper params to query parameters changer for second and more page number
+ * 28. Should delay the request for second and more page number for the time corresponding to the RPS and rpsFactor if the provider has RPS
+ * 29. Should use corrected query string for second and more page as a first parameter for axios call
+ * 30. Should call axios with the http method of current provider
+ * 31. Should call axios with the http method of current provider's current sub-request
+ * 32. Should actualize the last called timestamp in rpsEnsurer when postponing the request for second and more page number
+ * 33. Should call checkWhetherResponseIsForLastPage if provider has this function
+ * 34. Should call checkWhetherResponseIsForLastPage with the correct params
+ * 35. Should call checkWhetherResponseIsForLastPage corresponding to sub-request if provider has sub-requests
+ * 36. Should return the paginated data as a single array if the request per page returns an array
+ * 37. Should return the joined sub-requests data as a single array if the request per sub-request returns an array
+ * 38. Should return the joined paginated sub-requests data as a single array if the request per sub-request returns an array and some sub-requests return an array per page
+ * 39. Should return the result of the request if the request has no sub-requests
+ * 40. Should punish the provider failed to retrieve data
+ * 41. Should punish the provider returned no data
+ * 42. Should call stats collector when the provider fails to retrieve data
+ * 43. Should call stats collector when the provider returns no data
+ * + 44. Should bind each query composer to provider
+ */
+describe("RobustExternalAPICallerService", function () {
+    describe("#callExternalAPI>_performCallAttempt", function () {
+        const anyAxiosResponse = (method) => `${method}-result`;
+
+        const generateProviders = (
+            count,
+            endpoints = "any",
+            httpMethods = "any",
+            getDataByResponseFunctions = "any",
+            RPSes = null,
+            timeouts = null
+        ) => {
+            const providers = [];
+            const composeQueryStringStubs = [];
+            for (let i = 0; i < count; ++i) {
+                class TempProvider extends ExternalApiProvider {
+                    constructor() {
+                        super(
+                            endpoints === "any" ? "any" : endpoints[i],
+                            httpMethods === "any" ? "get" : httpMethods[i],
+                            timeouts ? timeouts[i] : null,
+                            RPSes === null
+                                ? new ApiGroup(v4(), 10)
+                                : new ApiGroup(v4(), RPSes[i])
+                        );
+                    }
+                    getDataByResponse(
+                        response,
+                        params = [],
+                        subRequestIndex = 0,
+                        iterationsData = []
+                    ) {
+                        const func =
+                            getDataByResponseFunctions === "any"
+                                ? "any"
+                                : Array.isArray(getDataByResponseFunctions[i])
+                                  ? getDataByResponseFunctions[i][
+                                        subRequestIndex
+                                    ]
+                                  : getDataByResponseFunctions[i];
+                        return func();
+                    }
+                }
+                const provider = new TempProvider();
+                providers.push(provider);
+                const composeQueryStringStub = sinon.stub(
+                    provider,
+                    "composeQueryString"
+                );
+                composeQueryStringStubs.push(composeQueryStringStub);
+            }
+            const isRpsExceededStubs = [];
+            providers.forEach((provider) => {
+                if (
+                    provider.httpMethod === "post" ||
+                    provider.httpMethod === "put" ||
+                    provider.httpMethod === "patch"
+                ) {
+                    provider.composeBody = () => {};
+                    sinon.stub(provider, "composeBody");
+                }
+                const isRPSExceededStub = sinon.stub(provider, "isRpsExceeded");
+                isRPSExceededStub.returns(false);
+                isRpsExceededStubs.push(isRPSExceededStub);
+            });
+
+            return { providers, isRpsExceededStubs, composeQueryStringStubs };
+        };
+
+        const anyRPSes = (count) => new Array(count).fill(10);
+
+        let anyParameters = [];
+        let anyTimeout = 10000;
+        let anyCancelToken = "null";
+        let anyRPSFactor = 1;
+        let callStub;
+        beforeEach(function () {
+            callStub = sinon.stub(AxiosAdapter, "call");
+            callStub
+                .withArgs(
+                    "get",
+                    sinon.match.any,
+                    sinon.match.any,
+                    sinon.match.any
+                )
+                .resolves(anyAxiosResponse("get"));
+            callStub
+                .withArgs(
+                    "post",
+                    sinon.match.any,
+                    sinon.match.any,
+                    sinon.match.any
+                )
+                .resolves(anyAxiosResponse("post"));
+            callStub
+                .withArgs(
+                    "patch",
+                    sinon.match.any,
+                    sinon.match.any,
+                    sinon.match.any
+                )
+                .resolves(anyAxiosResponse("patch"));
+            callStub
+                .withArgs(
+                    "delete",
+                    sinon.match.any,
+                    sinon.match.any,
+                    sinon.match.any
+                )
+                .resolves(anyAxiosResponse("delete"));
+            callStub
+                .withArgs(
+                    "put",
+                    sinon.match.any,
+                    sinon.match.any,
+                    sinon.match.any
+                )
+                .resolves(anyAxiosResponse("put"));
+        });
+
+        afterEach(function () {
+            callStub.restore();
+        });
+
+        it("Should reorder providers according to nice factor", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["###1", "###2", "###3"],
+                ["get", "get", "get"],
+                [() => "any", () => null, () => null]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+            [1, 5, 3].forEach(
+                (niceFactor, i) =>
+                    (retriever.providers[i].niceFactor = niceFactor)
+            );
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            callStub.args[0][0].should.be.equal("get");
+            callStub.args[0][1].should.startWith(
+                retriever.providers[1].endpoint
+            );
+            callStub.args[1][1].should.startWith(
+                retriever.providers[2].endpoint
+            );
+            callStub.args[2][1].should.startWith(
+                retriever.providers[0].endpoint
+            );
+        });
+
+        it("Should not touch the instance's providers list during the reordering", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["###1", "###2", "###3"],
+                ["get", "get", "get"],
+                [() => "any", () => null, () => null]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+            [1, 5, 3].forEach(
+                (niceFactor, i) =>
+                    (retriever.providers[i].niceFactor = niceFactor)
+            );
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            retriever.providers[0].endpoint.should.be.equal(
+                providers[0].endpoint
+            );
+            retriever.providers[1].endpoint.should.be.equal(
+                providers[1].endpoint
+            );
+            retriever.providers[2].endpoint.should.be.equal(
+                providers[2].endpoint
+            );
+        });
+
+        it("Should call only first provider if it returns data", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["###1", "###2", "###3"],
+                ["get", "get", "get"],
+                [() => "any", () => "any", () => "any"]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            callStub.callCount.should.be.equal(1);
+            callStub.args[0][0].should.be.equal("get");
+            callStub.args[0][1].should.startWith(
+                retriever.providers[0].endpoint
+            );
+        });
+
+        it("Should call several providers until the data retrieved", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["###1", "###2", "###3"],
+                ["get", "get", "get"],
+                [() => null, () => null, () => "any"]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            callStub.callCount.should.be.equal(3);
+            callStub.args[0][0].should.be.equal("get");
+            callStub.args[1][0].should.be.equal("get");
+            callStub.args[2][0].should.be.equal("get");
+            callStub.args[0][1].should.startWith(
+                retriever.providers[0].endpoint
+            );
+            callStub.args[1][1].should.startWith(
+                retriever.providers[1].endpoint
+            );
+            callStub.args[2][1].should.startWith(
+                retriever.providers[2].endpoint
+            );
+        });
+
+        it("Should return null data if all providers returns null", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["###1", "###2", "###3"],
+                ["get", "get", "get"],
+                [() => null, () => null, () => null]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            (result.data === null).should.be.true();
+        });
+
+        it("Should return shouldBeForceRetried=true if providers have RPS and all providers declined by RPS (isRPSExceeded returns true)", async function () {
+            const { providers, isRpsExceededStubs } = generateProviders(
+                3,
+                ["1", "2", "3"],
+                "any",
+                "any",
+                anyRPSes(3)
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            isRpsExceededStubs.forEach((stub) => {
+                stub.resetBehavior();
+                stub.returns(true);
+            });
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            result.shouldBeForceRetried.should.be.true();
+        });
+
+        it("Should return shouldBeForceRetried=true if some providers fail and the rest ones declined by RPS (isRPSExceeded returns true) and count of requests declined by RPS is more than ceil of half of providers count", async function () {
+            const { providers, isRpsExceededStubs } = generateProviders(
+                5,
+                ["1", "2", "3", "4", "5"],
+                "any",
+                [() => null, () => "any", () => null, () => "any", () => "any"],
+                anyRPSes(5)
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            isRpsExceededStubs.forEach((stub, index) => {
+                if (index === 1 || index === 3 || index === 4) {
+                    stub.resetBehavior();
+                    stub.returns(true);
+                }
+            });
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            result.shouldBeForceRetried.should.be.true();
+        });
+
+        it("Should return rpsFactor multiplied by rpsMultiplier if providers have RPS and all providers declined by RPS (isRPSExceeded returns true)", async function () {
+            const { providers, isRpsExceededStubs } = generateProviders(
+                3,
+                ["1", "2", "3"],
+                "any",
+                "any",
+                anyRPSes(3)
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            isRpsExceededStubs.forEach((stub) => {
+                stub.resetBehavior();
+                stub.returns(true);
+            });
+
+            const rpsFactor = 1;
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            result.rpsFactor.should.be.equal(
+                rpsFactor * RobustExternalAPICallerService.rpsMultiplier
+            );
+        });
+
+        it("Should return rpsFactor multiplied by rpsMultiplier if some providers fail and the rest ones declined by RPS (isRPSExceeded returns true) and count of requests declined by RPS is more than ceil of half of providers count", async function () {
+            const { providers, isRpsExceededStubs } = generateProviders(
+                5,
+                ["1", "2", "3", "4", "5"],
+                "any",
+                ["any", () => null, "any", () => null, () => null],
+                anyRPSes(5)
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            isRpsExceededStubs.forEach((stub, index) => {
+                if (index === 1 || index === 3 || index === 4) {
+                    stub.resetBehavior();
+                    stub.returns(true);
+                }
+            });
+
+            const rpsFactor = 1;
+
+            const result = await retriever._performCallAttempt(
+                [],
+                anyTimeout,
+                null,
+                rpsFactor
+            );
+
+            result.rpsFactor.should.be.equal(
+                rpsFactor * RobustExternalAPICallerService.rpsMultiplier
+            );
+        });
+
+        it("Should return the errors list caught when calling the providers and one of them fails", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["1", "2", "3"],
+                ["get", "get", "get"],
+                [() => null, () => "any", () => "any"]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            const someError = new Error("E1");
+            callStub.resetBehavior();
+            callStub.onCall(0).resolves("any");
+            callStub.onCall(1).rejects(someError);
+            callStub.onCall(2).resolves("any");
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            result.errors.should.be.deepEqual([someError]);
+        });
+
+        it("Should return the errors list caught when calling the providers and all of them fail", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["1", "2", "3"],
+                ["get", "get", "get"],
+                [() => null, () => null, () => null]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            const someError1 = new Error("E1");
+            const someError2 = new Error("E2");
+            const someError3 = new Error("E3");
+            callStub.resetBehavior();
+            callStub.onCall(0).rejects(someError1);
+            callStub.onCall(1).rejects(someError2);
+            callStub.onCall(2).rejects(someError3);
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            result.errors.should.be.deepEqual([
+                someError1,
+                someError2,
+                someError3,
+            ]);
+        });
+
+        it("Should return null data when all the providers fail", async function () {
+            const { providers } = generateProviders(
+                3,
+                ["1", "2", "3"],
+                ["get", "get", "get"],
+                [() => "any", () => "any", () => "any"]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            const someError = new Error("E1");
+            callStub.resetBehavior();
+            callStub.rejects(someError);
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            (result.data === null).should.be.true();
+        });
+
+        it("Should not call the provider if it has RPS and rpsEnsurer says that this domain's RPS is exceeded", async function () {
+            const { providers, isRpsExceededStubs } = generateProviders(
+                3,
+                ["1", "2", "3"],
+                ["get", "get", "get"],
+                [() => null, () => null, () => null],
+                anyRPSes(3)
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            isRpsExceededStubs.forEach((stub, index) => {
+                if (index === 0 || index === 2) {
+                    stub.resetBehavior();
+                    stub.returns(false);
+                } else if (index === 1) {
+                    stub.resetBehavior();
+                    stub.returns(true);
+                }
+            });
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            (
+                callStub.args.find((params) =>
+                    params[1].startsWith(providers[1].endpoint)
+                ) == null
+            ).should.be.true();
+        });
+
+        it("Should correctly count the number of requests declined by RPS exceeding", async function () {
+            const { providers, isRpsExceededStubs } = generateProviders(
+                5,
+                ["1", "2", "3", "4", "5"],
+                ["get", "get", "get", "get", "get"],
+                [() => null, () => "any", () => "any", () => null, () => null],
+                anyRPSes(5)
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            isRpsExceededStubs.forEach((stub, index) => {
+                if (index === 0 || index === 3 || index === 4) {
+                    stub.resetBehavior();
+                    stub.returns(false);
+                } else if (index === 1 || index === 2) {
+                    stub.resetBehavior();
+                    stub.returns(true);
+                }
+            });
+
+            const result = await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            result.shouldBeForceRetried.should.be.false();
+        });
+
+        it("Should add cancelToken to axios params if it is not null", async function () {
+            const { providers } = generateProviders(
+                2,
+                ["1", "2"],
+                ["get", "get"],
+                [() => null, () => "any"]
+            );
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            const someCancelToken = "someCC";
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                someCancelToken,
+                anyRPSFactor
+            );
+
+            for (let i = 0; i < callStub.args.length; ++i) {
+                callStub.args[i][2]?.cancelToken.should.be.equal(
+                    someCancelToken
+                );
+            }
+        });
+
+        it("Should add timeout to axios params if a provider has it", async function () {
+            const { providers } = generateProviders(
+                2,
+                ["1", "2"],
+                ["get", "get"],
+                [() => null, () => "any"],
+                null,
+                [1001, 1002]
+            );
+
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            for (let i = 0; i < callStub.args.length; ++i) {
+                callStub.args[i][2]?.timeout.should.be.equal(
+                    providers[i].timeout
+                );
+            }
+        });
+
+        it("Should do all sub-request if all of them except the last one don't throw error", async function () {
+            const { providers } = generateProviders(
+                2,
+                ["1", "2"],
+                [["get", "get", "get"], "get"],
+                [() => "any", () => "any"]
+            );
+
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            const someError = new Error("E1");
+            callStub.resetBehavior();
+            callStub.onFirstCall().resolves("any");
+            callStub.onSecondCall().resolves("any");
+            callStub.onThirdCall().rejects(someError);
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            for (let i = 0; i < 3; ++i) {
+                callStub.args[i][1].should.startWith(providers[0].endpoint);
+            }
+        });
+
+        it("Should call query composer proper number of times if there are sub-request", async function () {
+            // const queryComposers = [[sinon.spy(), sinon.spy()], sinon.spy()];
+            const { providers, composeQueryStringStubs } = generateProviders(
+                2,
+                ["1", "2"],
+                [["get", "get"], "get"],
+                [
+                    [
+                        () => "any",
+                        function () {
+                            throw new Error("any");
+                        },
+                    ],
+                    () => "any",
+                ]
+            );
+
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            composeQueryStringStubs[0].callCount.should.be.equal(2);
+            composeQueryStringStubs[1].callCount.should.be.equal(1);
+        });
+
+        it("Should pass correct endpoint with query returned by query composer as the first axios param", async function () {
+            const { providers, composeQueryStringStubs } = generateProviders(
+                2,
+                ["1", "2"],
+                [["get", "get"], "get"],
+                [
+                    [
+                        () => "any",
+                        function () {
+                            throw new Error("any");
+                        },
+                    ],
+                    () => "any",
+                ]
+            );
+
+            const query1 = "?a=4&fgrh=4l4ao4";
+            const query2 = "a/s?j3jk=lkk0-3&h=oool230";
+            const query3 = "?jijiji2332=09o3i4r3&p1=-121120&hfwowfif=wqoi23";
+            composeQueryStringStubs[0].resetBehavior();
+            composeQueryStringStubs[0]
+                .withArgs(anyParameters, 0)
+                .returns(query1);
+            composeQueryStringStubs[0]
+                .withArgs(anyParameters, 1)
+                .returns(query2);
+            composeQueryStringStubs[1].resetBehavior();
+            composeQueryStringStubs[1]
+                .withArgs(anyParameters, 0)
+                .returns(query3);
+
+            const retriever = new RobustExternalAPICallerService(
+                "any",
+                providers
+            );
+
+            await retriever._performCallAttempt(
+                anyParameters,
+                anyTimeout,
+                anyCancelToken,
+                anyRPSFactor
+            );
+
+            callStub.args[0][1].should.be.equal(providers[0].endpoint + query1);
+            callStub.args[1][1].should.be.equal(providers[0].endpoint + query2);
+            callStub.args[2][1].should.be.equal(providers[1].endpoint + query3);
+        });
+    });
+});