@rabbitio/ui-kit 1.0.0-beta.111 → 1.0.0-beta.113

package/src/swaps-lib/test/external-apis/goexmeSwapProvider/integration/getSwapInfo.int.test.js

@@ -1,141 +1,151 @@
 import "dotenv/config";
-import { describe, it, beforeEach, afterEach, expect, vi } from "vitest";
+import sinon from "sinon";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
 import axios from "axios";
 import BigNumber from "bignumber.js";
+
 import { Cache } from "../../../../../common-apis/utils/cache.js";
 import { GoexmeSwapProvider } from "../../../../external-apis/goexmeSwapProvider.js";
 
 const GOEXME_API_KEY = process.env.GOEXME_API_KEY?.trim?.() || "";
 const maybeDescribe = GOEXME_API_KEY ? describe : describe.skip;
 
-maybeDescribe("GoexmeSwapProvider#getSwapInfo – live integration", () => {
-    let provider;
-    const axiosOriginalGet = axios.get;
-
-    beforeEach(async () => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
-        await provider._fetchSupportedCurrenciesIfNeeded();
-        await provider._ensurePairsLoaded();
-    });
-
-    afterEach(() => {
-        axios.get = axiosOriginalGet;
-    });
-
-    const byCode = code => provider._supportedCoins.find(c => c.code === code)?.coin || null;
-    const pickAmount = async (from, to, fallback) => {
-        const info = await provider.getSwapInfo(from, to, fallback);
-        if (info.result) return fallback;
-        if (info.reason === provider.constructor.NO_SWAPS_REASONS.TOO_LOW && info.smallestMin) {
-            return new BigNumber(info.smallestMin).times(1.1).toFixed(from.digits);
-        }
-        throw new Error();
-    };
-
-    it("happy path BTC → ETH", async () => {
-        const BTC = byCode("BTC");
-        const ETH = byCode("ETH");
-        const amount = await pickAmount(BTC, ETH, "0.001");
-        const info = await provider.getSwapInfo(BTC, ETH, amount);
-        expect(info.result).toBe(true);
-        expect(parseFloat(info.rate)).toBeGreaterThan(0);
-        expect(Number(info.min)).toBeLessThanOrEqual(Number(amount));
-        expect(Number(info.max)).toBeGreaterThan(Number(amount));
-    });
-
-    it("pair not supported JOE → TRX", async () => {
-        const JOE = byCode("JOE");
-        const TRX = byCode("TRX");
-        if (!JOE || !TRX) return;
-        const info = await provider.getSwapInfo(JOE, TRX, "50");
-        expect(info.result).toBe(false);
-        expect(info.reason).toBe(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
-    });
-
-    it("too low amount", async () => {
-        const BTC = byCode("BTC");
-        const ETH = byCode("ETH");
-        const minInfo = await provider.getSwapInfo(BTC, ETH, "0.001");
-        const low = new BigNumber(minInfo.min || "0.0001").div(10).toFixed(BTC.digits);
-        const info = await provider.getSwapInfo(BTC, ETH, low);
-        expect(info.result).toBe(false);
-        expect(info.reason).toBe(provider.constructor.NO_SWAPS_REASONS.TOO_LOW);
-    });
-
-    it("too high amount", async () => {
-        const BTC = byCode("BTC");
-        const ETH = byCode("ETH");
-        const base = await provider.getSwapInfo(BTC, ETH, "0.001");
-        const high = new BigNumber(base.max || "1").times(50).toFixed(BTC.digits);
-        const info = await provider.getSwapInfo(BTC, ETH, high);
-        expect(info.result).toBe(false);
-        expect(info.reason).toBe(provider.constructor.NO_SWAPS_REASONS.TOO_HIGH);
-    });
-
-    it("rate limit", async () => {
-        axios.get = vi.fn((url, cfg) =>
-            url.endsWith("/rate") ? Promise.reject({ response: { status: 429 } }) : axiosOriginalGet(url, cfg)
-        );
-        const BTC = byCode("BTC");
-        const ETH = byCode("ETH");
-        const info = await provider.getSwapInfo(BTC, ETH, "0.1");
-        expect(info.result).toBe(false);
-        expect(info.reason).toBe(provider.constructor.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
-    });
-
-    it("amount param equals passed amount when amountIsToReceive=false", async () => {
-        let captured = null;
-        axios.get = async (url, cfg = {}) => {
-            if (url.endsWith("/rate")) captured = cfg.params.amount;
-            return axiosOriginalGet(url, cfg);
-        };
-        const BTC = byCode("BTC");
-        const ETH = byCode("ETH");
-        await provider.getSwapInfo(BTC, ETH, "0.5");
-        expect(captured).toBe("0.5");
-    });
-
-    it("includes fix=true when fixed quote requested", async () => {
-        let captured = null;
-        axios.get = async (url, cfg = {}) => {
-            if (url.endsWith("/rate")) captured = cfg.params.fix;
-            return axiosOriginalGet(url, cfg);
+maybeDescribe("external-apis/goexmeSwapProvider integration", function () {
+    describe("getSwapInfo (live)", function () {
+        let provider;
+        let axiosOriginalGet;
+
+        beforeEach(async function () {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            axiosOriginalGet = axios.get;
+        });
+
+        afterEach(function () {
+            if (axios.get.restore) {
+                axios.get.restore();
+            } else {
+                axios.get = axiosOriginalGet;
+            }
+        });
+
+        const getCoinByCode = code => provider._supportedCoins.find(c => c.code === code)?.coin || null;
+
+        const pickValidAmount = async (fromCoin, toCoin, fallbackAmount) => {
+            const info = await provider.getSwapInfo(fromCoin, toCoin, fallbackAmount);
+            if (info.result) return fallbackAmount;
+            if (info.reason === provider.constructor.NO_SWAPS_REASONS.TOO_LOW && info.smallestMin) {
+                return new BigNumber(info.smallestMin).times(1.1).toFixed(fromCoin.digits);
+            }
+            throw new Error();
         };
-        const BTC = byCode("BTC");
-        const ETH = byCode("ETH");
-        await provider.getSwapInfo(BTC, ETH, "0.2", true);
-        expect(captured).toBe(true);
-    });
-
-    it("handles duplicated tickers", async () => {
-        const DUP = byCode("USDTTRC20TRC20");
-        const BTC = byCode("BTC");
-        if (!DUP) return;
-        const info = await provider.getSwapInfo(DUP, BTC, "50");
-        expect(info.result).toBe(true);
-    });
 
-    it("validates hasExtraId and extraIdName for every allowed coin", async () => {
-        // Fetch raw currencies directly from GoExme to compare against adapter output
-        const raw = await axiosOriginalGet(`${provider._URL}/currencies`, {
-            params: { key: GOEXME_API_KEY },
-        }).then(r => r.data);
-
-        await provider._fetchSupportedCurrenciesIfNeeded();
-
-        Object.entries(raw)
-            .filter(([, meta]) => meta?.available === true)
-            .forEach(([code, meta]) => {
-                const info = provider._supportedCoins.find(c => c.code === code.toUpperCase());
-                if (!info) return; // Coin might be filtered out by allow‑list
-                const tagRaw = (meta.tagname ?? "").trim();
-                const expectsExtra = tagRaw.length > 0;
-                expect(info.hasExtraId).toBe(expectsExtra);
-                if (expectsExtra) {
-                    expect(info.extraIdName).toBe(tagRaw);
-                } else {
-                    expect(info.extraIdName).toBeNull();
-                }
+        it("Should return valid info for BTC→ETH", async function () {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            const amount = await pickValidAmount(btcCoin, ethCoin, "0.001");
+            const info = await provider.getSwapInfo(btcCoin, ethCoin, amount);
+            info.result.should.be.true();
+            parseFloat(info.rate).should.be.above(0);
+            (Number(info.min) <= Number(amount)).should.be.true();
+            (Number(info.max) > Number(amount)).should.be.true();
+        });
+
+        it("Should report NOT_SUPPORTED for unsupported pair JOE→TRX", async function () {
+            const joeCoin = getCoinByCode("JOE");
+            const trxCoin = getCoinByCode("TRX");
+            if (!joeCoin || !trxCoin) return;
+            const info = await provider.getSwapInfo(joeCoin, trxCoin, "50");
+            info.result.should.be.false();
+            info.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should return TOO_LOW for amounts below minimum", async function () {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            const minInfo = await provider.getSwapInfo(btcCoin, ethCoin, "0.001");
+            const lowAmount = new BigNumber(minInfo.min || "0.0001").div(10).toFixed(btcCoin.digits);
+            const info = await provider.getSwapInfo(btcCoin, ethCoin, lowAmount);
+            info.result.should.be.false();
+            info.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.TOO_LOW);
+        });
+
+        it("Should return TOO_HIGH for amounts above maximum", async function () {
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            const base = await provider.getSwapInfo(btcCoin, ethCoin, "0.001");
+            const highAmount = new BigNumber(base.max || "1").times(50).toFixed(btcCoin.digits);
+            const info = await provider.getSwapInfo(btcCoin, ethCoin, highAmount);
+            info.result.should.be.false();
+            info.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.TOO_HIGH);
+        });
+
+        it("Should map HTTP 429 to REQUESTS_LIMIT_EXCEEDED", async function () {
+            sinon.stub(axios, "get").callsFake((url, cfg) => {
+                if (url.endsWith("/rate")) return Promise.reject({ response: { status: 429 } });
+                return axiosOriginalGet(url, cfg);
+            });
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            const info = await provider.getSwapInfo(btcCoin, ethCoin, "0.1");
+            info.result.should.be.false();
+            info.reason.should.equal(provider.constructor.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        it("Should send amount param equal to passed amount when amountIsToReceive=false", async function () {
+            let capturedAmount = null;
+            sinon.stub(axios, "get").callsFake((url, cfg = {}) => {
+                if (url.endsWith("/rate")) capturedAmount = cfg.params.amount;
+                return axiosOriginalGet(url, cfg);
+            });
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            await provider.getSwapInfo(btcCoin, ethCoin, "0.5");
+            capturedAmount.should.equal("0.5");
+        });
+
+        it("Should return NOT_SUPPORTED when /rate responds with status 400", async function () {
+            sinon.stub(axios, "get").callsFake((url, cfg = {}) => {
+                if (url.endsWith("/rate")) return Promise.resolve({ status: 400, data: {} });
+                return axiosOriginalGet(url, cfg);
             });
+            const btcCoin = getCoinByCode("BTC");
+            const ethCoin = getCoinByCode("ETH");
+            const info = await provider.getSwapInfo(btcCoin, ethCoin, "0.3");
+            info.result.should.be.false();
+            info.reason.should.equal(provider.constructor.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should handle duplicated tickers", async function () {
+            const dupCoin = getCoinByCode("USDTTRC20TRC20");
+            const btcCoin = getCoinByCode("BTC");
+            if (!dupCoin) return;
+            const info = await provider.getSwapInfo(dupCoin, btcCoin, "50");
+            info.result.should.be.true();
+        });
+
+        it("Should validate hasExtraId and extraIdName for every allowed coin", async function () {
+            const rawData = await axiosOriginalGet(`${provider._URL}/currencies`, {
+                params: { key: GOEXME_API_KEY },
+            }).then(r => r.data);
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            Object.entries(rawData)
+                .filter(([, meta]) => meta?.available === true)
+                .forEach(([code, meta]) => {
+                    const coinInfo = provider._supportedCoins.find(c => c.code === code.toUpperCase());
+                    if (!coinInfo) return;
+                    const tagRaw = (meta.tagname ?? "").trim();
+                    const expectsExtra = tagRaw.length > 0;
+                    coinInfo.hasExtraId.should.equal(expectsExtra);
+                    if (expectsExtra) {
+                        coinInfo.extraIdName.should.equal(tagRaw);
+                    } else {
+                        should(coinInfo.extraIdName).be.null();
+                    }
+                });
+        });
     });
 });