@rabbitio/ui-kit 1.0.0-beta.6 → 1.0.0-beta.61

package/src/swaps-lib/test/external-apis/swapspaceSwapProvider/_fetchSupportedCurrenciesIfNeeded.test.js

@@ -0,0 +1,506 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapspaceSwapProvider } from "../../../external-apis/swapspaceSwapProvider.js";
+import { Coin } from "../../../../common/models/coin.js";
+import { Cache } from "../../../../common/utils/cache.js";
+import { Protocol } from "../../../../common/models/protocol.js";
+
+describe("swapspaceSwapProvider", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        const swapspaceProvider = new SwapspaceSwapProvider("/", new Cache());
+        const anyError = new Error("Any error");
+
+        let axiosGetStub;
+        beforeEach(() => {
+            axiosGetStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => {
+            axiosGetStub.restore();
+            swapspaceProvider._supportedCoins = [];
+        });
+
+        it("Should throw an error if axios throws error", async () => {
+            axiosGetStub.resetBehavior();
+            axiosGetStub.rejects(anyError);
+
+            const swapProvider = new SwapspaceSwapProvider("/", new Cache());
+
+            return swapProvider
+                ._fetchSupportedCurrenciesIfNeeded()
+                .should.be.rejectedWith(anyError);
+        });
+
+        it("Should not call axios if there is _supportedCoins", async () => {
+            swapspaceProvider._supportedCoins = [{ coin: {}, extraId: "" }];
+            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+
+            axiosGetStub.callCount.should.be.equal(0);
+        });
+
+        it("should make a network call if coins are not cached", async () => {
+            swapspaceProvider._supportedCoins = [];
+            const fakeResponse = { data: [] };
+            axiosGetStub.returns(Promise.resolve(fakeResponse));
+
+            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+
+            axiosGetStub.calledOnce.should.be.true();
+        });
+
+        it("Should call _customCoinBuilder number of times equal to returned coins count", async () => {
+            const _customCoinBuilderStub = sinon.stub();
+            const someResp = {
+                data: [
+                    { code: "1", network: "n1" },
+                    { code: "2", network: "n2" },
+                    { code: "3", network: "n3" },
+                    { code: "4", network: "n4" },
+                ],
+            };
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            _customCoinBuilderStub.callCount.should.be.equal(
+                someResp.data.length
+            );
+        });
+
+        it("Should call _customCoinBuilder with proper params", async () => {
+            const _customCoinBuilderStub = sinon.stub();
+            const someResp = {
+                data: [
+                    { code: "1", network: "n1" },
+                    { code: "2", network: "n2" },
+                    { code: "3", network: "n3" },
+                    { code: "4", network: "n4" },
+                ],
+            };
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            _customCoinBuilderStub.args.forEach((args, i) =>
+                args.should.be.deepEqual([
+                    someResp.data[i].code,
+                    someResp.data[i].network,
+                ])
+            );
+        });
+
+        it("Should ignore coins that _customCoinBuilder returned null for if useRestrictedCoinsSet is true", async () => {
+            const someResp = {
+                data: [
+                    { code: "1", network: "n1" },
+                    { code: "2", network: "n2" },
+                    { code: "3", network: "n3" },
+                ],
+            };
+            const _customCoinBuilderStub = sinon.stub();
+            _customCoinBuilderStub.onFirstCall().returns({ ticker: "1" });
+            _customCoinBuilderStub.onSecondCall().returns(null);
+            _customCoinBuilderStub.onThirdCall().returns({ ticker: "3" });
+
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub,
+                true
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            p._supportedCoins.length.should.be.equal(2);
+            (
+                p._supportedCoins.find((i) => i.coin.ticker === "1") != null
+            ).should.be.true();
+            (
+                p._supportedCoins.find((i) => i.coin.ticker === "3") != null
+            ).should.be.true();
+        });
+
+        it("Should construct coins with default params if _customCoinBuilder return null for some and useRestrictedCoinsSet is false", async () => {
+            const someResp = {
+                data: [
+                    { code: "aaa", network: "n1" },
+                    {
+                        code: "bbb",
+                        network: "n2",
+                        name: "some",
+                        contractAddress: "addr",
+                    },
+                    { code: "ccc", network: "n3" },
+                ],
+            };
+            const _customCoinBuilderStub = sinon.stub();
+            _customCoinBuilderStub.onFirstCall().returns({ ticker: "AAAN1" });
+            _customCoinBuilderStub.onSecondCall().returns(null);
+            _customCoinBuilderStub.onThirdCall().returns({ ticker: "CCCN3" });
+
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub,
+                false
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            p._supportedCoins.length.should.be.equal(3);
+
+            const newCoin = p._supportedCoins.find(
+                (i) => i.coin.ticker === "BBBN2"
+            )?.coin;
+            (newCoin instanceof Coin).should.be.true();
+            newCoin.tickerPrintable.should.be.equal("BBB");
+            newCoin.latinName.should.be.equal("some");
+            newCoin.digits.should.be.equal(8);
+            (newCoin.maxValue === null).should.be.true();
+            newCoin.atomName.should.be.equal("");
+            (newCoin.mainnet === null).should.be.true();
+            (newCoin.testnet === null).should.be.true();
+            newCoin.minConfirmations.should.be.equal(1);
+            (newCoin.payableEntityStringForFeeRate === null).should.be.true();
+            newCoin.feeOptionsTimeStringsSortedDesc.should.be.deepEqual([]);
+            newCoin.feeRatesExpirationTimeMs.should.be.equal(60000);
+            newCoin.protocol.should.be.deepEqual(new Protocol("N2"));
+            (newCoin.blockchain === null).should.be.true();
+            newCoin.tokenAddress.should.be.equal("addr");
+            newCoin.feeCoin.should.be.equal(newCoin);
+            newCoin.doesUseLowerCaseAddresses.should.be.equal(false);
+            newCoin.doesUseOutputs.should.be.equal(false);
+        });
+
+        it("Should construct coins with null protocol and ticker===<uppercase code> if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and code and network are equal for item", async () => {
+            const someResp = {
+                data: [
+                    {
+                        code: "bbb",
+                        network: "bbb",
+                    },
+                ],
+            };
+            const _customCoinBuilderStub = sinon.stub();
+            _customCoinBuilderStub.onFirstCall().returns(null);
+
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub,
+                false
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            p._supportedCoins[0].coin.ticker.should.be.equal("BBB");
+            (p._supportedCoins[0].coin.protocol === null).should.be.true();
+        });
+
+        it("Should construct coins ticker===<uppercasecodeProtocol> and protocol with name===<uppercasenetwork> if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and code and network are nopt equal for item", async () => {
+            const someResp = {
+                data: [
+                    {
+                        code: "bbb",
+                        network: "bbb1",
+                    },
+                ],
+            };
+            const _customCoinBuilderStub = sinon.stub();
+            _customCoinBuilderStub.onFirstCall().returns(null);
+
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub,
+                false
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            p._supportedCoins[0].coin.ticker.should.be.equal("BBBBBB1");
+            p._supportedCoins[0].coin.protocol.should.be.deepEqual(
+                new Protocol("BBB1")
+            );
+        });
+
+        it("Should construct coins with tokenAddress === null if _customCoinBuilder return null for item and useRestrictedCoinsSet is false and contractAddress is nullish for item", async () => {
+            const someResp = {
+                data: [
+                    {
+                        code: "bbb",
+                        network: "bbb1",
+                    },
+                ],
+            };
+            const _customCoinBuilderStub = sinon.stub();
+            _customCoinBuilderStub.onFirstCall().returns(null);
+
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub,
+                false
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            (p._supportedCoins[0].coin.tokenAddress === null).should.be.true();
+        });
+
+        const setupAndExecstoreCoinDataFormatTest = async (attribute) => {
+            const someResp = {
+                data: [
+                    {
+                        code: "aaa",
+                        network: "aaa",
+                        hasExtraId: false,
+                        extraIdName: "",
+                        popular: false,
+                        iconURL: "/aaa",
+                        deposit: true,
+                        withdrawal: true,
+                        validationRegexp: "any",
+                    },
+                    {
+                        code: "bbb",
+                        network: "bbb1",
+                        hasExtraId: false,
+                        extraIdName: "",
+                        iconURL: "/bbb/bbb1.svg",
+                        deposit: false,
+                        withdrawal: false,
+                        validationRegexp: "any",
+                    },
+                    {
+                        code: "ccc",
+                        network: "n3",
+                        hasExtraId: true,
+                        extraIdName: "",
+                        popular: false,
+                        iconURL: "/1/ccc.jpg",
+                        deposit: true,
+                        withdrawal: false,
+                    },
+                    {
+                        code: "ddd",
+                        network: "n4",
+                        hasExtraId: true,
+                        extraIdName: "MEMO",
+                        popular: false,
+                        deposit: false,
+                        withdrawal: true,
+                        validationRegexp: "any",
+                    },
+                ],
+            };
+
+            const _customCoinBuilderStub = sinon.stub();
+            _customCoinBuilderStub.returns(null);
+            // _customCoinBuilderStub.onCall(1).returns({ ticker: "CCCN3" });
+
+            axiosGetStub.resetBehavior();
+            axiosGetStub.resolves(someResp);
+            const p = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                _customCoinBuilderStub,
+                false
+            );
+
+            await p._fetchSupportedCurrenciesIfNeeded();
+
+            return { provider: p, data: someResp.data };
+        };
+
+        it("Should save constructed coin as a coin list item", async () => {
+            const { provider } = await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((i) =>
+                i.coin.should.be.instanceof(Coin)
+            );
+        });
+
+        it("Should save code as is", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.code.should.be.equal(data[i].code);
+            });
+        });
+
+        it("Should save network as is", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.network.should.be.equal(data[i].network);
+            });
+        });
+
+        it("Should save hasExtraId as is", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.hasExtraId.should.be.equal(data[i].hasExtraId);
+            });
+        });
+
+        it("Should save extraIdName as is", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.extraIdName.should.be.equal(data[i].extraIdName);
+            });
+        });
+
+        it("Should save popular to isPopular as boolean", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.isPopular.should.be.equal(!!data[i].popular);
+            });
+        });
+
+        it("Should save icon or default URL to iconURL", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.iconURL.should.be.equal(
+                    data[i].icon
+                        ? `https://storage.swapspace.co${data[i].iconURL}`
+                        : "https://rabbit.io/asset-icons/fallback.svg"
+                );
+            });
+        });
+
+        it("Should save deposit as is", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.deposit.should.be.equal(data[i].deposit);
+            });
+        });
+
+        it("Should save withdrawal as is", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                dataItem.withdrawal.should.be.equal(data[i].withdrawal);
+            });
+        });
+
+        it("Should save validationRegexp or null if it is nullish", async () => {
+            const { provider, data } =
+                await setupAndExecstoreCoinDataFormatTest();
+
+            provider._supportedCoins.forEach((dataItem, i) => {
+                (
+                    dataItem.validationRegexp ===
+                    (data[i].validationRegexp ?? null)
+                ).should.be.true();
+            });
+        });
+
+        it("should sort list by isPopular and alphabetically by ticker", async () => {
+            const swapspaceProvider = new SwapspaceSwapProvider(
+                "/",
+                new Cache(),
+                () => null,
+                false
+            );
+            const fakeResponse = {
+                data: [
+                    {
+                        network: "eth",
+                        code: "eth",
+                        popular: true,
+                    },
+                    {
+                        network: "bac",
+                        code: "bac",
+                        popular: false,
+                    },
+                    {
+                        network: "bbb",
+                        code: "btc",
+                        popular: false,
+                    },
+                    {
+                        network: "eee",
+                        code: "aaa",
+                        popular: false,
+                    },
+                    {
+                        network: "xxx",
+                        code: "aaa",
+                        popular: true,
+                    },
+                ],
+            };
+            axiosGetStub.returns(Promise.resolve(fakeResponse));
+
+            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+
+            swapspaceProvider._supportedCoins
+                .map((coin) => coin.coin.ticker)
+                .should.be.deepEqual([
+                    "AAAXXX",
+                    "ETH",
+                    "AAAEEE",
+                    "BAC",
+                    "BTCBBB",
+                ]);
+        });
+
+        it("should handle empty response data", async () => {
+            const fakeResponse = { data: null };
+            axiosGetStub.returns(Promise.resolve(fakeResponse));
+
+            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+
+            swapspaceProvider._supportedCoins.should.deepEqual([]);
+        });
+
+        it("should handle absence of data field in response", async () => {
+            const fakeResponse = {};
+            axiosGetStub.returns(Promise.resolve(fakeResponse));
+
+            await swapspaceProvider._fetchSupportedCurrenciesIfNeeded();
+            swapspaceProvider._supportedCoins.should.deepEqual([]);
+        });
+    });
+});