@rabbitio/ui-kit 1.0.0-beta.12 → 1.0.0-beta.121

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

@@ -0,0 +1,536 @@
+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 { Cache } from "../../../../common-apis/utils/cache.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);
+        // });
+        //
+        // describe("Should process name when creating custom coins", function () {
+        //     [
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: " Bitcoin  " },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "BTC",
+        //                 network: "BTC",
+        //                 name: " Bitcoin  (BTC)  ",
+        //             },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "Bitcoin" },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "BTC" },
+        //             expectedName: "BTC",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "BTC",
+        //                 network: "BTC",
+        //                 name: "Bitcoin (BTC)",
+        //             },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "BTC",
+        //                 network: "BTC",
+        //                 name: "Bitcoin (BTC) (BTC)",
+        //             },
+        //             expectedName: "Bitcoin",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "BTC (BTC)" },
+        //             expectedName: "BTC (BTC)",
+        //         },
+        //         {
+        //             item: { code: "BTC", network: "BTC", name: "(BTC) (BTC)" },
+        //             expectedName: "(BTC) (BTC)",
+        //         },
+        //         {
+        //             item: { code: "USDT", network: "ERC20", name: "Tether" },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: { code: "USDT", network: "ERC20", name: "USDT" },
+        //             expectedName: "USDT",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "Tether (USDT)",
+        //             },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "Tether (USDT)",
+        //             },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "Tether (USDT) (ERC20)",
+        //             },
+        //             expectedName: "Tether",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "USDT (ERC20)",
+        //             },
+        //             expectedName: "USDT",
+        //         },
+        //         {
+        //             item: {
+        //                 code: "USDT",
+        //                 network: "ERC20",
+        //                 name: "(USDT) (ERC20)",
+        //             },
+        //             expectedName: "(USDT) (ERC20)",
+        //         },
+        //     ].forEach(testCase => {
+        //         it("Should construct coins with default params if _customCoinBuilder return null for some and useRestrictedCoinsSet is false", async () => {
+        //             const someResp = {
+        //                 data: [testCase.item],
+        //             };
+        //             axiosGetStub.resetBehavior();
+        //             axiosGetStub.resolves(someResp);
+        //             const p = new SwapspaceSwapProvider("/", new Cache(), () => null, false);
+        //
+        //             await p._fetchSupportedCurrenciesIfNeeded();
+        //
+        //             p._supportedCoins[0].coin.latinName.should.be.equal(testCase.expectedName);
+        //         });
+        //     });
+        // });
+        //
+        // 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 ? 1 : 0);
+        //     });
+        // });
+        //
+        // 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://wallet.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(["ETH", "AAAXXX", "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([]);
+        // });
+    });
+});