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

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

@@ -0,0 +1,745 @@
+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 { RobustExternalAPICallerService } from "../../../../robustExternalAPICallerService.js";
+
+describe("RobustExternalAPICallerService", function () {
+    describe("#callExternalAPI", function () {
+        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 anyTimeout = 1000;
+        const anyData = "any data";
+
+        let setTimeoutBackup = null;
+        beforeEach(function () {
+            setTimeoutBackup = global.setTimeout;
+        });
+
+        afterEach(function () {
+            global.setTimeout = setTimeoutBackup;
+        });
+
+        it("Should perform n+1 attempts when first n requests return null and n+1's returns not-null data and n is less than max_attempts_count", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+            const attemptsCount = 6;
+            const failingAttemptsCount = Math.floor(attemptsCount * 0.6);
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i < failingAttemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+            _performCallAttemptStub.onCall(failingAttemptsCount).resolves({
+                data: "some data",
+                shouldBeForceRetried: false,
+                errors: [],
+                rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+            });
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount
+            );
+
+            _performCallAttemptStub.callCount.should.be.equal(
+                failingAttemptsCount + 1
+            );
+        });
+
+        it("Should perform max_attempts_count due to null data and shouldBeForceRetried is false for the last call", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+            const attemptsCount = 5;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i < attemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            try {
+                await retrieverService.callExternalAPI(
+                    [],
+                    anyTimeout,
+                    null,
+                    attemptsCount
+                );
+            } catch (e) {
+                // We expect an error here
+            }
+
+            _performCallAttemptStub.callCount.should.be.equal(attemptsCount);
+        });
+
+        it("Should perform max_attempts_count + n requests when all attempts return null data and shouldBeForceRetried is true for max_attempts_count-1 request and for n more requests", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+            const attemptsCount = 5;
+            const countOfAdditionalRequestsDueToForceRetryNeed = 3;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (
+                let i = 0;
+                i <
+                attemptsCount + countOfAdditionalRequestsDueToForceRetryNeed;
+                ++i
+            ) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried:
+                        i >= attemptsCount - 1 &&
+                        i !==
+                            attemptsCount +
+                                countOfAdditionalRequestsDueToForceRetryNeed -
+                                1,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            try {
+                await retrieverService.callExternalAPI(
+                    [],
+                    anyTimeout,
+                    null,
+                    attemptsCount
+                );
+            } catch (e) {
+                // We expect an error here
+            }
+
+            _performCallAttemptStub.callCount.should.be.equal(
+                attemptsCount + countOfAdditionalRequestsDueToForceRetryNeed
+            );
+        });
+
+        it("Should return null if all requests return null if doNotFailForNowData is true", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+            const attemptsCount = 5;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i < attemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            const result = await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount,
+                true
+            );
+
+            (result == null).should.be.true();
+        });
+
+        it("Should throw an error if all requests return null if doNotFailForNowData is false", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+            const attemptsCount = 5;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i < attemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            try {
+                await retrieverService.callExternalAPI(
+                    [],
+                    anyTimeout,
+                    null,
+                    attemptsCount
+                );
+            } catch (e) {
+                e.message.should.match(
+                    /.*Failed to retrieve data. It means all attempts have been failed.*/
+                );
+            }
+        });
+
+        it("Should use rpsFactor = 1 by default (as a parameter of the first call to _performCallAttempt)", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+            const attemptsCount = 1;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            _performCallAttemptStub.onCall(0).resolves({
+                data: anyData,
+                shouldBeForceRetried: false,
+                errors: [],
+                rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+            });
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount
+            );
+
+            _performCallAttemptStub.args[0][3].should.be.equal(1);
+        });
+
+        it("Should call _performCallAttempt without the delay when there is a first attempt", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+
+            global.setTimeout = sinon.stub();
+
+            const attemptsCount = 1;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            _performCallAttemptStub.onCall(0).resolves({
+                data: anyData,
+                shouldBeForceRetried: false,
+                errors: [],
+                rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+            });
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount
+            );
+
+            setTimeout.callCount.should.be.equal(0);
+        });
+
+        it("Should call _performCallAttempt with delay n-1 times when there are n attempts performed", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+
+            sinon.spy(global, "setTimeout");
+
+            const attemptsCount = 4;
+            const failingAttemptsCount = 2;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i <= failingAttemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: i === failingAttemptsCount ? anyData : null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount
+            );
+
+            setTimeout.callCount.should.be.equal(failingAttemptsCount);
+        });
+
+        it("Should call _performCallAttempt with delay corresponding to the max rps and default rpsFactor", async function () {
+            const RPSes = [10, 20, 4, 15];
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4, "any", "any", "any", RPSes).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+
+            sinon.spy(global, "setTimeout");
+
+            const attemptsCount = 5;
+            const failingAttemptsCount = 3;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i <= failingAttemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: i === failingAttemptsCount ? anyData : null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount
+            );
+
+            for (let j = 0; j < failingAttemptsCount; ++j) {
+                setTimeout.args[j][1].should.be.equal(
+                    1000 /
+                        (Math.max(...RPSes) /
+                            RobustExternalAPICallerService.defaultRPSFactor)
+                );
+            }
+        });
+
+        it("Should call _performCallAttempt with delay corresponding to the max rps and increasing rpsFactor", async function () {
+            const RPSes = [1, 11, 39, 0.1];
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4, "any", "any", "any", RPSes).providers,
+                // eslint-disable-next-line no-console
+                console.log
+            );
+
+            sinon.spy(global, "setTimeout");
+
+            const attemptsCount = 5;
+            const failingAttemptsCount = 3;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            const rpsFactors = new Array(4)
+                .fill(RobustExternalAPICallerService.defaultRPSFactor)
+                .map(
+                    (factor, index) =>
+                        factor *
+                        Math.pow(
+                            RobustExternalAPICallerService.rpsMultiplier,
+                            index
+                        )
+                );
+
+            for (let i = 0; i <= failingAttemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: i === failingAttemptsCount ? anyData : null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: rpsFactors[i],
+                });
+            }
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount
+            );
+
+            for (let j = 0; j < failingAttemptsCount; ++j) {
+                setTimeout.args[j][1].should.be.equal(
+                    1000 / (Math.max(...RPSes) / rpsFactors[j]),
+                    `Attempt ${j} failed`
+                );
+            }
+        });
+
+        it("Should log the errors array returned by _performCallAttempt", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers
+            );
+
+            const spy = sinon.spy(retrieverService, "_logger");
+
+            const attemptsCount = 3;
+            const failingAttemptsCount = 2;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i <= failingAttemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: i === failingAttemptsCount ? anyData : null,
+                    shouldBeForceRetried: false,
+                    errors:
+                        i !== failingAttemptsCount
+                            ? [`aaa${i}${i}${i}`, `bbb${i}${i}${i}`]
+                            : [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount,
+                true
+            );
+
+            for (let j = 0; j < failingAttemptsCount; ++j) {
+                spy.args[j][0].message
+                    .includes(`aaa${j}${j}${j}`)
+                    .should.be.true();
+                spy.args[j][0].message
+                    .includes(`bbb${j}${j}${j}`)
+                    .should.be.true();
+            }
+        });
+
+        it("Should log an unexpected error occurred during the _performCallAttempt call", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers
+            );
+
+            const spy = sinon.spy(retrieverService, "_logger");
+
+            const someError = new Error("Failed ### in tests");
+            const attemptsCount = 1;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            _performCallAttemptStub.onCall(0).rejects(someError);
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount,
+                true
+            );
+            spy.args[0][0].should.be.equal(someError);
+        });
+
+        it("Should pass correct parameters to _performCallAttempt - case default rpsFactor", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers
+            );
+
+            const attemptsCount = 2;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i < attemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            const someParamsValues = [1, "aaa", { c: "1w2" }];
+            const someCancelToken = "some token";
+            await retrieverService.callExternalAPI(
+                someParamsValues,
+                anyTimeout,
+                someCancelToken,
+                attemptsCount,
+                true
+            );
+
+            for (let i = 0; i < attemptsCount; ++i) {
+                _performCallAttemptStub.args[i].should.be.deepEqual([
+                    someParamsValues,
+                    anyTimeout,
+                    someCancelToken,
+                    RobustExternalAPICallerService.defaultRPSFactor,
+                    true,
+                ]);
+            }
+        });
+
+        it("Should pass correct parameters to _performCallAttempt - case increasing rpsFactor", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers
+            );
+
+            const attemptsCount = 5;
+            const failingAttemptsCount = 3;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            const rpsFactors = new Array(failingAttemptsCount + 1)
+                .fill(RobustExternalAPICallerService.defaultRPSFactor)
+                .map(
+                    (factor, index) =>
+                        factor *
+                        Math.pow(
+                            RobustExternalAPICallerService.rpsMultiplier,
+                            index
+                        )
+                );
+
+            for (let i = 0; i <= failingAttemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: i === failingAttemptsCount ? anyData : null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: rpsFactors[i],
+                });
+            }
+            const someParamsValues = [1, "aaa", { c: "1w2" }];
+            const someCancelToken = "some token";
+            await retrieverService.callExternalAPI(
+                someParamsValues,
+                anyTimeout,
+                someCancelToken,
+                attemptsCount,
+                true
+            );
+
+            for (let i = 0; i < failingAttemptsCount + 1; ++i) {
+                _performCallAttemptStub.args[i].should.be.deepEqual(
+                    [
+                        someParamsValues,
+                        anyTimeout,
+                        someCancelToken,
+                        i === 0
+                            ? RobustExternalAPICallerService.defaultRPSFactor
+                            : rpsFactors[i - 1],
+                        true,
+                    ],
+                    `Attempt ${i} check`
+                );
+            }
+        });
+
+        it("Should log the 'not enough attempts' error when after all attempts data is null and doNotFailForNowData is true", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers
+            );
+
+            const spy = sinon.spy(retrieverService, "_logger");
+
+            const attemptsCount = 3;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i < attemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount,
+                true
+            );
+
+            spy.args[0][0].message.should.be.equal(
+                "Failed to retrieve data. It means all attempts have been failed. DEV: add more attempts to this data retrieval"
+            );
+        });
+
+        it("Should throw the 'not enough attempts' error when after all attempts data is null and doNotFailForNowData is false", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers
+            );
+
+            const spy = sinon.spy(retrieverService, "_logger");
+
+            const attemptsCount = 3;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i < attemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            let error = null;
+            try {
+                await retrieverService.callExternalAPI(
+                    [],
+                    anyTimeout,
+                    null,
+                    attemptsCount
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            (error == null).should.be.false();
+            error.message.should.be.match(
+                /.*Failed to retrieve data. It means all attempts have been failed. DEV: add more attempts to this data retrieval/
+            );
+        });
+
+        it("Should return the not null data returned by the _performCallAttempt", async function () {
+            const retrieverService = new RobustExternalAPICallerService(
+                "testService",
+                generateProviders(4).providers
+            );
+
+            const attemptsCount = 4;
+            const failingAttemptsCount = 2;
+            const _performCallAttemptStub = sinon.stub(
+                retrieverService,
+                "_performCallAttempt"
+            );
+            for (let i = 0; i <= failingAttemptsCount; ++i) {
+                _performCallAttemptStub.onCall(i).resolves({
+                    data: i === failingAttemptsCount ? anyData : null,
+                    shouldBeForceRetried: false,
+                    errors: [],
+                    rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
+                });
+            }
+
+            const result = await retrieverService.callExternalAPI(
+                [],
+                anyTimeout,
+                null,
+                attemptsCount,
+                true
+            );
+
+            result.should.be.deepEqual(anyData);
+        });
+    });
+});