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

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

@@ -1,171 +1,306 @@
 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 { Cache } from "../../../../../common-apis/utils/cache.js";
 import { GoexmeSwapProvider } from "../../../../external-apis/goexmeSwapProvider.js";
+import { FALLBACK_ASSET_ICON_URL } from "../../../../../common-apis/globalConstants.jsx";
 
 const GOEXME_API_KEY = process.env.GOEXME_API_KEY?.trim?.() || "";
 const maybeDescribe = GOEXME_API_KEY ? describe : describe.skip;
 
-maybeDescribe("GoexmeSwapProvider – live integration tests", () => {
-    let provider;
-    const axiosOriginalGet = axios.get;
+maybeDescribe("external-apis/goexmeSwapProvider integration", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        let provider;
+        let axiosGetOriginal;
 
-    beforeEach(() => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
-    });
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+            axiosGetOriginal = axios.get;
+        });
 
-    afterEach(() => {
-        axios.get = axiosOriginalGet;
-    });
+        afterEach(() => {
+            if (axios.get.restore) {
+                axios.get.restore();
+            } else {
+                axios.get = axiosGetOriginal;
+            }
+        });
 
-    const fetchRawCurrencies = async () => {
-        const { data } = await axiosOriginalGet(`${provider._URL}/currencies`, {
-            params: { key: GOEXME_API_KEY },
+        const fetchRawCurrencies = async () => {
+            const { data } = await axiosGetOriginal(`${provider._URL}/currencies`, {
+                params: { key: GOEXME_API_KEY },
+            });
+            return data;
+        };
+
+        it("Should filter out unavailable coins", async () => {
+            const raw = await fetchRawCurrencies();
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            const providerCodes = new Set(provider._supportedCoins.map(c => c.code));
+            const unavailableCodes = Object.entries(raw)
+                .filter(([, meta]) => meta?.available === false)
+                .map(([code]) => code.toUpperCase());
+
+            unavailableCodes.forEach(code => providerCodes.has(code).should.be.false());
+            providerCodes.size.should.be.above(0);
         });
-        return data;
-    };
 
-    it("filters out unavailable coins", async () => {
-        const raw = await fetchRawCurrencies();
-        await provider._fetchSupportedCurrenciesIfNeeded();
+        it("Should set hasExtraId and extraIdName correctly", async () => {
+            const raw = await fetchRawCurrencies();
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-        const providerCodes = new Set(provider._supportedCoins.map(c => c.code));
-        const unavailableCodes = Object.entries(raw)
-            .filter(([, meta]) => meta?.available === false)
-            .map(([code]) => code.toUpperCase());
+            const infoWithTag = provider._supportedCoins.find(i => i.hasExtraId);
+            should.exist(infoWithTag);
 
-        unavailableCodes.forEach(code => expect(providerCodes.has(code)).toBe(false));
-        expect(providerCodes.size).toBeGreaterThan(0);
-    });
+            const meta =
+                raw[infoWithTag.code] ??
+                Object.values(raw).find(m => (m.code ?? m.ticker ?? "").toUpperCase() === infoWithTag.code);
+            should.exist(meta);
+            (meta.tagname ?? "").trim().should.not.be.empty();
 
-    it("sets hasExtraId and extraIdName correctly", async () => {
-        const raw = await fetchRawCurrencies();
-        await provider._fetchSupportedCurrenciesIfNeeded();
+            infoWithTag.extraIdName.should.equal(meta.tagname);
+        });
 
-        const infoWithTag = provider._supportedCoins.find(i => i.hasExtraId);
-        expect(infoWithTag).toBeDefined();
+        it("Should handle duplicate tickers across networks", async () => {
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-        const meta =
-            raw[infoWithTag.code] ??
-            Object.values(raw).find(m => (m.code ?? m.ticker ?? "").toUpperCase() === infoWithTag.code);
-        expect(meta).toBeDefined();
-        expect((meta.tagname ?? "").trim()).not.toBe("");
+            const suffixRx = /(ERC20|TRC20|BEP20|BSC|AVALANCHEC|OPTIMISM|SOLANA|ARBITRUM)$/i;
+            const grouped = {};
 
-        expect(infoWithTag.extraIdName).toBe(meta.tagname);
-    });
+            provider._supportedCoins.forEach(i => {
+                const base = i.code.toUpperCase().replace(suffixRx, "");
+                grouped[base] = grouped[base] || [];
+                grouped[base].push(i);
+            });
 
-    it("handles duplicate tickers across networks", async () => {
-        await provider._fetchSupportedCurrenciesIfNeeded();
+            const entry = Object.entries(grouped).find(([, arr]) => arr.length >= 2);
+            if (!entry) return;
 
-        const suffixRx = /(ERC20|TRC20|BEP20|BSC|AVALANCHEC|OPTIMISM|SOLANA|ARBITRUM)$/i;
-        const grouped = {};
+            const [, infos] = entry;
+            infos.length.should.be.aboveOrEqual(2);
 
-        provider._supportedCoins.forEach(i => {
-            const base = i.code.toUpperCase().replace(suffixRx, "");
-            grouped[base] = grouped[base] || [];
-            grouped[base].push(i);
+            infos.forEach(info => {
+                provider._findInfoByTicker(info.coin.ticker).should.equal(info);
+            });
         });
 
-        const entry = Object.entries(grouped).find(([, arr]) => arr.length >= 2);
-        if (!entry) {
-            console.warn("No duplicate tickers among allowed coins – skipping duplicate assertion");
-            return;
-        }
+        it("Should skip HTTP call when cached list is fresh", async () => {
+            provider._supportedCoins = [{ dummy: true }];
+            provider._supportedCoinsLastUpdateTimestamp = Date.now();
 
-        const [, infos] = entry;
-        expect(infos.length).toBeGreaterThanOrEqual(2);
+            let calls = 0;
+            sinon.stub(axios, "get").callsFake((url, opts) => {
+                if (url.includes("/currencies")) calls += 1;
+                return axiosGetOriginal(url, opts);
+            });
 
-        infos.forEach(info => {
-            expect(provider._findInfoByTicker(info.coin.ticker)).toBe(info);
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            calls.should.equal(0);
         });
-    });
 
-    it("uses currencies cache within TTL", async () => {
-        let calls = 0;
-        axios.get = async (...args) => {
-            if (args[0].includes("/currencies")) calls += 1;
-            return axiosOriginalGet(...args);
-        };
+        it("Should make one HTTP call when cache empty, then reuse cache within TTL", async () => {
+            let calls = 0;
+            sinon.stub(axios, "get").callsFake((url, opts) => {
+                if (url.includes("/currencies")) calls += 1;
+                return axiosGetOriginal(url, opts);
+            });
 
-        await provider._fetchSupportedCurrenciesIfNeeded();
-        provider._supportedCoinsLastUpdateTimestamp -= 4 * 60 * 1000;
-        await provider._fetchSupportedCurrenciesIfNeeded();
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            provider._supportedCoinsLastUpdateTimestamp -= 4 * 60 * 1000;
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-        expect(calls).toBe(1);
-    });
+            calls.should.equal(1);
+        });
 
-    it("reloads currencies cache after TTL expiry", async () => {
-        let calls = 0;
-        axios.get = async (...args) => {
-            if (args[0].includes("/currencies")) calls += 1;
-            return axiosOriginalGet(...args);
-        };
+        it("Should refresh list after TTL expiry", async () => {
+            let calls = 0;
+            sinon.stub(axios, "get").callsFake((url, opts) => {
+                if (url.includes("/currencies")) calls += 1;
+                return axiosGetOriginal(url, opts);
+            });
 
-        await provider._fetchSupportedCurrenciesIfNeeded();
-        provider._supportedCoinsLastUpdateTimestamp -= 10 * 60 * 1000;
-        await provider._fetchSupportedCurrenciesIfNeeded();
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            provider._supportedCoinsLastUpdateTimestamp -= 10 * 60 * 1000;
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-        expect(calls).toBe(2);
-    });
+            calls.should.equal(2);
+        });
 
-    it("uses pairs cache within TTL", async () => {
-        let calls = 0;
-        axios.get = async (...args) => {
-            if (args[0].includes("/pairs")) calls += 1;
-            return axiosOriginalGet(...args);
-        };
+        it("Should return empty list for status 200 with empty object", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 200, data: {} });
+                }
+                return axiosGetOriginal(url, opts);
+            });
 
-        await provider._ensurePairsLoaded();
-        provider._pairsCacheTimestamp -= 4 * 60 * 1000;
-        await provider._ensurePairsLoaded();
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-        expect(calls).toBe(1);
-    });
+            Array.isArray(provider._supportedCoins).should.be.true();
+            provider._supportedCoins.length.should.equal(0);
+        });
 
-    it("reloads pairs cache after TTL expiry", async () => {
-        let calls = 0;
-        axios.get = async (...args) => {
-            if (args[0].includes("/pairs")) calls += 1;
-            return axiosOriginalGet(...args);
-        };
+        it("Should throw when status 200 with null data", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 200, data: null });
+                }
+                return axiosGetOriginal(url, opts);
+            });
 
-        await provider._ensurePairsLoaded();
-        provider._pairsCacheTimestamp -= 10 * 60 * 1000;
-        await provider._ensurePairsLoaded();
+            await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
+        });
 
-        expect(calls).toBe(2);
-    });
+        it("Should return empty list for status 200 with data array", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 200, data: [] });
+                }
+                return axiosGetOriginal(url, opts);
+            });
 
-    it("throws on non-200 response", async () => {
-        axios.get = vi.fn((url, opts = {}) =>
-            url.endsWith("/currencies") ? Promise.resolve({ status: 500, data: {} }) : axiosOriginalGet(url, opts)
-        );
-        await expect(provider._fetchSupportedCurrenciesIfNeeded()).rejects.toThrow();
-    });
+            await provider._fetchSupportedCurrenciesIfNeeded();
 
-    it("keeps cache consistent under concurrent calls", async () => {
-        await Promise.all([
-            provider._fetchSupportedCurrenciesIfNeeded(),
-            provider._fetchSupportedCurrenciesIfNeeded(),
-            provider._fetchSupportedCurrenciesIfNeeded(),
-        ]);
+            Array.isArray(provider._supportedCoins).should.be.true();
+            provider._supportedCoins.length.should.equal(0);
+        });
 
-        expect(provider._supportedCoins.length).toBeGreaterThan(0);
-        expect(provider._supportedCoinsLastUpdateTimestamp).toBeGreaterThan(0);
-    });
+        it("Should throw when /currencies responds with non-200 status", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({ status: 400, data: {} });
+                }
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded().should.be.rejected();
+        });
+
+        it("Should ensure every coin has a non-empty icon URL", async () => {
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            provider._supportedCoins.length.should.be.above(0);
+            provider._supportedCoins.every(i => typeof i.iconURL === "string" && i.iconURL.length > 0).should.be.true();
+        });
 
-    it("_mapGoexmeStatus maps every value", () => {
-        const m = provider._mapGoexmeStatus.bind(provider);
-        expect(m("new")).toBe(provider.constructor.SWAP_STATUSES.WAITING_FOR_PAYMENT);
-        expect(m("waiting_deposit")).toBe(provider.constructor.SWAP_STATUSES.CONFIRMING);
-        expect(m("deposit_received")).toBe(provider.constructor.SWAP_STATUSES.PAYMENT_RECEIVED);
-        expect(m("exchanging")).toBe(provider.constructor.SWAP_STATUSES.EXCHANGING);
-        expect(m("sending")).toBe(provider.constructor.SWAP_STATUSES.EXCHANGING);
-        expect(m("success")).toBe(provider.constructor.SWAP_STATUSES.COMPLETED);
-        expect(m("time_expired")).toBe(provider.constructor.SWAP_STATUSES.EXPIRED);
-        expect(m("failed")).toBe(provider.constructor.SWAP_STATUSES.FAILED);
-        expect(m("sending_failed")).toBe(provider.constructor.SWAP_STATUSES.FAILED);
-        expect(m("reverted")).toBe(provider.constructor.SWAP_STATUSES.REFUNDED);
+        it("Should persist raw meta fields exactly", async () => {
+            const raw = await fetchRawCurrencies();
+            const entry = Object.entries(raw).find(([code, meta]) => provider._convertCurrencyMeta(code, meta));
+            should.exist(entry);
+            const [code, meta] = entry;
+            await provider._fetchSupportedCurrenciesIfNeeded();
+
+            const info = provider._supportedCoins.find(i => i.code === code.toUpperCase());
+            should.exist(info);
+            info.code.should.equal(code.toUpperCase());
+
+            const net = (meta.network || "").toUpperCase() || null;
+            (info.network ?? null).should.equal(net ?? null);
+
+            const tag = (meta.tagname ?? "").trim();
+            if (tag) {
+                info.hasExtraId.should.be.true();
+                info.extraIdName.should.equal(tag);
+            } else {
+                info.hasExtraId.should.be.false();
+            }
+        });
+
+        it("Should mark isPopular and use fallback icon when icon is missing", async () => {
+            sinon.stub(axios, "get").callsFake((url, opts = {}) => {
+                if (url.endsWith("/currencies")) {
+                    return Promise.resolve({
+                        status: 200,
+                        data: {
+                            BTC: { coinName: "Bitcoin", available: true },
+                            DOGE: { coinName: "Dogecoin", available: true },
+                        },
+                    });
+                }
+                return axiosGetOriginal(url, opts);
+            });
+
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            const btc = provider._supportedCoins.find(i => i.code === "BTC");
+            const doge = provider._supportedCoins.find(i => i.code === "DOGE");
+
+            btc.iconURL.should.equal(FALLBACK_ASSET_ICON_URL);
+            should.exist(btc.isPopular);
+            should.exist(doge.isPopular);
+        });
+
+        it("Should sort _supportedCoins: popular first, then alphabetically by ticker", async () => {
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            const popular = [
+                "HMSTRTON",
+                "BTC",
+                "ETH",
+                "USDTERC20",
+                "USDTTRC20",
+                "USDCERC20",
+                "XRP",
+                "TON",
+                "XMR",
+                "TRX",
+                "DAIERC20",
+                "DOGE",
+                "BNB",
+                "PEPEERC20",
+                "NOTTON",
+                "SOL",
+                "DOT",
+                "LTC",
+                "SHIBERC20",
+                "AVAX",
+                "UNIERC20",
+                "LINKERC20",
+                "MATIC",
+                "BUSDBEP20",
+                "AAVEERC20",
+                "ATOM",
+                "RUNE",
+                "ADA",
+            ];
+            const list = provider._supportedCoins;
+
+            let reachedNonPopular = false;
+            for (const info of list) {
+                const isPop = popular.includes(info.coin.ticker);
+                if (!reachedNonPopular && !isPop) reachedNonPopular = true;
+                if (reachedNonPopular) isPop.should.be.false();
+            }
+
+            const nonPopularTickers = list.filter(i => !popular.includes(i.coin.ticker)).map(i => i.coin.ticker);
+            const sorted = [...nonPopularTickers].sort((a, b) => a.localeCompare(b));
+            nonPopularTickers.should.eql(sorted);
+        });
+
+        it("Should keep cache consistent under concurrent calls", async () => {
+            await Promise.all([
+                provider._fetchSupportedCurrenciesIfNeeded(),
+                provider._fetchSupportedCurrenciesIfNeeded(),
+                provider._fetchSupportedCurrenciesIfNeeded(),
+            ]);
+
+            provider._supportedCoins.length.should.be.above(0);
+            provider._supportedCoinsLastUpdateTimestamp.should.be.above(0);
+        });
+
+        it("Should map all known provider statuses via _mapGoexmeStatus", () => {
+            const mapGoexmeStatus = provider._mapGoexmeStatus.bind(provider);
+            mapGoexmeStatus("new").should.equal(provider.constructor.SWAP_STATUSES.WAITING_FOR_PAYMENT);
+            mapGoexmeStatus("waiting_deposit").should.equal(provider.constructor.SWAP_STATUSES.CONFIRMING);
+            mapGoexmeStatus("deposit_received").should.equal(provider.constructor.SWAP_STATUSES.PAYMENT_RECEIVED);
+            mapGoexmeStatus("exchanging").should.equal(provider.constructor.SWAP_STATUSES.EXCHANGING);
+            mapGoexmeStatus("sending").should.equal(provider.constructor.SWAP_STATUSES.EXCHANGING);
+            mapGoexmeStatus("success").should.equal(provider.constructor.SWAP_STATUSES.COMPLETED);
+            mapGoexmeStatus("time_expired").should.equal(provider.constructor.SWAP_STATUSES.EXPIRED);
+            mapGoexmeStatus("failed").should.equal(provider.constructor.SWAP_STATUSES.FAILED);
+            mapGoexmeStatus("sending_failed").should.equal(provider.constructor.SWAP_STATUSES.FAILED);
+            mapGoexmeStatus("reverted").should.equal(provider.constructor.SWAP_STATUSES.REFUNDED);
+        });
     });
 });