@rabbitio/ui-kit 1.0.0-beta.42 → 1.0.0-beta.45

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

@@ -0,0 +1,76 @@
+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 { SwapspaceSwapProvider } from "../../../external-apis/swapspaceSwapProvider.js";
+import { Cache } from "../../../../common/utils/cache.js";
+
+describe("swapspaceSwapProvider", function () {
+    describe("getAllSupportedCurrencies", function () {
+        const swapspaceProvider = new SwapspaceSwapProvider("/", new Cache());
+
+        let _fetchSupportedCurrenciesIfNeededStub;
+        beforeEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+            swapspaceProvider._supportedCoins = [];
+        });
+
+        it("Should return an error if the response status is 429", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.resetBehavior();
+            _fetchSupportedCurrenciesIfNeededStub.rejects({
+                response: { status: 429 },
+            });
+
+            const swapProvider = new SwapspaceSwapProvider("/", new Cache());
+            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 () => {
+            swapspaceProvider._supportedCoins = [
+                { coin: { t: "BTC" }, extraId: "" },
+                { coin: 1 },
+                { coin: "4" },
+            ];
+            const expectedCoins = swapspaceProvider._supportedCoins.map(
+                (item) => item.coin
+            );
+
+            const result = await swapspaceProvider.getAllSupportedCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapspaceProvider.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 swapspaceProvider.getAllSupportedCurrencies();
+                should.fail("Expected an error to be thrown");
+            } catch (error) {
+                error.should.be.instanceOf(Error);
+                error.message.should.containEql(
+                    "Error fetching supported currencies"
+                );
+            }
+        });
+    });
+});

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

@@ -0,0 +1,82 @@
+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 { SwapspaceSwapProvider } from "../../../external-apis/swapspaceSwapProvider.js";
+import { Cache } from "../../../../common/utils/cache.js";
+
+describe("swapspaceSwapProvider", function () {
+    describe("getDepositCurrencies", function () {
+        const swapspaceProvider = new SwapspaceSwapProvider("/", new Cache());
+
+        let _fetchSupportedCurrenciesIfNeededStub;
+        beforeEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+            swapspaceProvider._supportedCoins = [];
+        });
+
+        it("Should return an error if the response status is 429", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.resetBehavior();
+            _fetchSupportedCurrenciesIfNeededStub.rejects({
+                response: { status: 429 },
+            });
+
+            const swapProvider = new SwapspaceSwapProvider("/", new Cache());
+            const result = await swapProvider.getDepositCurrencies();
+            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 having deposit == true", async () => {
+            swapspaceProvider._supportedCoins = [
+                {
+                    coin: { t: "BTC" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                { coin: 1, withdrawal: false, deposit: true },
+                { coin: "4", withdrawal: true, deposit: null },
+                { coin: "-12312", withdrawal: null, deposit: false },
+            ];
+            const expectedCoins = swapspaceProvider._supportedCoins
+                .filter((i) => i.deposit)
+                .map((item) => item.coin);
+
+            const result = await swapspaceProvider.getDepositCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapspaceProvider.getDepositCurrencies();
+
+            _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 swapspaceProvider.getDepositCurrencies();
+                should.fail("Expected an error to be thrown");
+            } catch (error) {
+                error.should.be.instanceOf(Error);
+                error.message.should.containEql(
+                    "Error fetching supported currencies"
+                );
+            }
+        });
+    });
+});