@rabbitio/ui-kit 1.0.0-beta.9 → 1.0.0-beta.91

package/src/swaps-lib/test/external-apis/exolixSwapProvider/getSwapInfo.test.js

@@ -0,0 +1,611 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { ExolixSwapProvider } from "../../../external-apis/exolixSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { AmountUtils } from "../../../../common-apis/utils/amountUtils.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+import { Blockchain } from "../../../../common-apis/models/blockchain.js";
+
+describe("exolixSwapProvider", function () {
+    describe("getSwapInfo", function () {
+        const BTC = new Coin(
+            "Bitcoin",
+            "BTC",
+            "BTC",
+            8,
+            null,
+            "sat",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Bitcoin")
+        );
+        const ETH = new Coin(
+            "Ethereum",
+            "ETH",
+            "ETH",
+            18,
+            null,
+            "wei",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Ethereum")
+        );
+        const TRX = new Coin(
+            "Tron",
+            "TRX",
+            "TRX",
+            18,
+            null,
+            "sun",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Tron")
+        );
+        const USDCTRC20 = new Coin(
+            "USDCTRC20",
+            "USDCTRC20",
+            "USDC",
+            6,
+            null,
+            "millicents",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Tron")
+        );
+        const USDTERC20 = new Coin(
+            "USDTERC20",
+            "USDTERC20",
+            "USDT",
+            6,
+            null,
+            "millicents",
+            null,
+            null,
+            1,
+            null,
+            [],
+            null,
+            new Blockchain("Ethereum")
+        );
+
+        const mockResponse = {
+            fromAmount: 1,
+            toAmount: 2,
+            rate: 2,
+            message: null,
+            minAmount: 0.1,
+            withdrawMin: 0.001,
+            maxAmount: 1000,
+        };
+
+        let exolixSwapProvider;
+        let axiosGetStub;
+        let trimCryptoAmountByCoinStub;
+        let _fetchSupportedCurrenciesIfNeededStub;
+        let modifiedResponse;
+
+        beforeEach(() => {
+            exolixSwapProvider = new ExolixSwapProvider("", new Cache());
+
+            axiosGetStub = sinon.stub(axios, "get");
+
+            trimCryptoAmountByCoinStub = sinon.stub(AmountUtils, "trim");
+            trimCryptoAmountByCoinStub.callsFake(amount => amount?.toString());
+
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(exolixSwapProvider, "_fetchSupportedCurrenciesIfNeeded");
+            _fetchSupportedCurrenciesIfNeededStub.resolves();
+        });
+
+        afterEach(() => {
+            sinon.restore();
+            modifiedResponse = undefined;
+        });
+
+        it("should return a result of correct format when available exchanges are present", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: mockResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.true();
+            result.min.should.be.String();
+            result.max.should.be.String();
+            result.smallestMin.should.be.String();
+            result.greatestMax.should.be.String();
+            result.rate.should.be.String();
+            result.rawSwapData.should.be.Object();
+            result.fixed.should.be.Boolean();
+        });
+
+        it("should return result with proper rate calculation if the selected exchange has toAmount, fromAmount and the coin usd rate is successfully retrieved", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            delete modifiedResponse.rate;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.rate.should.be.equal("2");
+        });
+
+        it("should return a rawSwapData object for available exchanges", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: mockResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.rawSwapData.should.be.deepEqual(mockResponse);
+        });
+
+        it("should handle REQUESTS_LIMIT_EXCEEDED when axios returns a 429", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.returns(Promise.reject({ response: { status: 429 } }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.reason.should.be.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        it("should return TOO_HIGH when amount is above the maxAmount", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            axiosGetStub.returns(Promise.reject({ response: { status: 422, data: mockResponse } }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "10000");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.TOO_HIGH);
+        });
+
+        it("should return TOO_LOW when amount is below the minAmount", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            axiosGetStub.returns(Promise.reject({ response: { status: 422, data: mockResponse } }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "0.001");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.TOO_LOW);
+        });
+
+        it("should return NOT_SUPPORTED when the response is empty", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.returns(Promise.reject({ response: { status: 422, data: {} } }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("should correctly handle when there is no numeric min", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.minAmount = "SHOULDBENUMBER";
+
+            axiosGetStub.resolves({
+                status: 200,
+                data: modifiedResponse,
+            });
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "10");
+
+            result.result.should.be.false();
+            (result.smallestMin === undefined).should.be.true();
+        });
+
+        it("should correctly handle when there is no numeric max", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.maxAmount = "SHOULDBENUMBER";
+
+            axiosGetStub.resolves({
+                status: 200,
+                data: modifiedResponse,
+            });
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "10");
+
+            result.result.should.be.false();
+            (result.greatestMax === undefined).should.be.true();
+        });
+
+        it("should handle general axios error", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            const error = new Error();
+            error.response = { status: 500 };
+            axiosGetStub.throws(error);
+
+            try {
+                await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+
+        it("should handle missing data in axios response", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.returns(Promise.resolve({}));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("should fail with not supported when fromAmount is not number greater than 0", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.fromAmount = 0;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("should fail with not supported when toAmount is not number greater than 0", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.toAmount = 0;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("should treat min=0 as unlimited and set to null", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.minAmount = 0;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "100");
+
+            result.result.should.be.true();
+            (result.smallestMin === null).should.be.true();
+        });
+
+        it("should treat max=0 as unlimited and set to null", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.maxAmount = 0;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "100");
+
+            result.result.should.be.true();
+            (result.greatestMax === null).should.be.true();
+        });
+
+        it("should handle exchanges with non-numeric toAmount", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.toAmount = "SHOULDBENUMBER";
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("should consider min > max as an invalid exchange option", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.minAmount = 5;
+            modifiedResponse.maxAmount = 1;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "10");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("should consider an exchange with negative fromAmount as not supporting the pair", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.fromAmount = -1;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("should consider an exchange with negative toAmount as not supporting the pair", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+
+            let modifiedResponse = { ...mockResponse };
+            modifiedResponse.toAmount = -1;
+
+            axiosGetStub.returns(Promise.resolve({ status: 200, data: modifiedResponse }));
+
+            const result = await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+
+            result.result.should.be.false();
+            result.reason.should.be.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it(`should use toNetwork from _supportedCoins`, async () => {
+            const expToNetwork = "slkjfn2";
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, network: "btc" },
+                { coin: ETH, network: expToNetwork },
+            ];
+
+            // TODO: Not working, test and fix
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.networkTo === expToNetwork).should.be.false();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it(`should use fromNetwork from _supportedCoins`, async () => {
+            const expNetwork = "slkjfn2";
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, network: expNetwork },
+                { coin: ETH, network: "eth" },
+            ];
+
+            // TODO: Not working, test and fix
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.networkFrom === expNetwork).should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should respect the fixed=false parameter in the axios request", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.rateType === "float").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1", false);
+        });
+
+        it("should respect the fixed=true parameter in the axios request", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.rateType === "fixed").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1", true);
+        });
+
+        it("should respect amount parameter in the axios request", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.amount === "1").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1", true);
+        });
+
+        it("should pass the from code from supportedCoins as parameter in the axios request", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "aaa", network: "btc" },
+                { coin: ETH, code: "eth", network: "eth" },
+            ];
+            // TODO: Not working, test and fix
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.coinFrom === "aaa").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should pass the to code from supportedCoins as parameter in the axios request", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc" },
+                { coin: ETH, code: "aaa", network: "eth" },
+            ];
+            // TODO: Not working, test and fix
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.coinTo === "aaa").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+        });
+
+        it("should generate correct URL for TRX to ERC20 USDT swap", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: TRX, code: "trx", network: "trx" },
+                { coin: USDTERC20, code: "usdt", network: "erc20" },
+            ];
+            // TODO: Not working, test and fix
+            axiosGetStub.callsFake((url, config) => {
+                (config.params?.coinFrom === "trx").should.be.true();
+                (config.params?.networkFrom === "trx").should.be.true();
+                (config.params?.coinTo === "usdt").should.be.true();
+                (config.params?.networkTo === "erc20").should.be.true();
+                (config.params?.amount === "100").should.be.true();
+                (config.params?.rateType === "float").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(TRX, USDTERC20, "100");
+        });
+
+        it("should generate correct URL for BTC to ETH swap", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+            ];
+            axiosGetStub.callsFake((url, config) => {
+                url.should.containEql(`/api/v2/rate`);
+                (config.params?.coinFrom === "btc").should.be.true();
+                (config.params?.networkFrom === "btc").should.be.true();
+                (config.params?.coinTo === "eth").should.be.true();
+                (config.params?.networkTo === "eth").should.be.true();
+                (config.params?.amount === "1").should.be.true();
+                (config.params?.rateType === "float").should.be.true();
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(BTC, ETH, "1", false);
+        });
+
+        it("should generate correct URL for TRC20 USDC to BTC swap", async () => {
+            exolixSwapProvider._supportedCoins = [
+                { coin: BTC, code: "btc", network: "btc", deposit: true, isAvailable: true },
+                { coin: ETH, code: "eth", network: "eth", withdrawal: true, isAvailable: true },
+                { coin: USDCTRC20, code: "usdc", network: "trc20" },
+            ];
+            // TODO: Not working, test and fix
+            axiosGetStub.callsFake(url => {
+                url.should.containEql(`/api/v2/rate`);
+                (config.params?.coinFrom === "usdc").should.be.true();
+                (config.params?.networkFrom === "trc20").should.be.true();
+                (config.params?.coinTo === "btc").should.be.true();
+                (config.params?.networkTo === "btc").should.be.true();
+                (config.params?.amount === "50.0235").should.be.true();
+                (config.params?.rateType === "float").should.be.true();
+
+                return Promise.resolve({ data: [] });
+            });
+
+            await exolixSwapProvider.getSwapInfo(USDCTRC20, BTC, "50.0235");
+        });
+
+        it("should throw error when passing coins with unknown tickers or protocols", async () => {
+            try {
+                await exolixSwapProvider.getSwapInfo({ ticker: "unknownCoin" }, ETH, "1");
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+
+        it("should throw error for non-string amountCoins input", async () => {
+            try {
+                await exolixSwapProvider.getSwapInfo(BTC, ETH, "1");
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+
+        it("should throw error for negative amountCoins input", async () => {
+            try {
+                await exolixSwapProvider.getSwapInfo(BTC, ETH, -1);
+            } catch (error) {
+                error.should.be.an.instanceof(Error);
+            }
+        });
+    });
+});

package/src/swaps-lib/test/external-apis/swapProvider/getAllSupportedCurrencies.test.js

@@ -0,0 +1,63 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("swapProvider", function () {
+    describe("getAllSupportedCurrencies", function () {
+        const swapProvider = new SwapProvider(new Cache());
+
+        let _fetchSupportedCurrenciesIfNeededStub;
+        beforeEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(swapProvider, "_fetchSupportedCurrenciesIfNeeded");
+        });
+
+        afterEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+            swapProvider._supportedCoins = [];
+        });
+
+        it("Should return an error if the response status is 429", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.resetBehavior();
+            _fetchSupportedCurrenciesIfNeededStub.rejects({
+                response: { status: 429 },
+            });
+
+            const result = await swapProvider.getAllSupportedCurrencies();
+            result.should.deepEqual({
+                result: false,
+                reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+            });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins if there is initialized list", async () => {
+            swapProvider._supportedCoins = [{ coin: { t: "BTC" }, extraId: "" }, { coin: 1 }, { coin: "4" }];
+            const expectedCoins = swapProvider._supportedCoins.map(item => item.coin);
+
+            const result = await swapProvider.getAllSupportedCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapProvider.getAllSupportedCurrencies();
+
+            _fetchSupportedCurrenciesIfNeededStub.calledOnce.should.be.true();
+        });
+
+        it("Should throw an error if an error occurs while fetching supported currencies", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.throws(new Error("Error fetching supported currencies"));
+
+            try {
+                await swapProvider.getAllSupportedCurrencies();
+                should.fail("Expected an error to be thrown");
+            } catch (error) {
+                error.should.be.instanceOf(Error);
+                error.message.should.containEql("Error fetching supported currencies");
+            }
+        });
+    });
+});