@rabbitio/ui-kit 1.0.0-beta.110 → 1.0.0-beta.112

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

@@ -1,7 +1,8 @@
 import sinon from "sinon";
 import axios from "axios";
-import { describe, it, beforeEach, afterEach, expect } from "vitest";
 import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+import BigNumber from "bignumber.js";
 
 import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
 import { Cache } from "../../../../common-apis/utils/cache.js";
@@ -26,124 +27,174 @@ const ETH = new Coin(
     new Blockchain("Ethereum")
 );
 
-describe("goexmeSwapProvider::getSwapInfo", () => {
-    const okRate = { result: true, rate: "15", minamount: "0.01", maxamount: "5" };
-    let provider, axiosStub;
-
-    beforeEach(() => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
-        provider._supportedCoins = [
-            { coin: BTC, code: "BTC", network: "BTC" },
-            { coin: ETH, code: "ETH", network: "ETH" },
-        ];
-        provider._supportedCoinsLastUpdateTimestamp = Date.now();
-        sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
-        axiosStub = sinon.stub(axios, "get").callsFake(url => {
-            if (url.includes("/pairs")) return Promise.resolve({ status: 200, data: { BTC: ["ETH"] } });
-            if (url.includes("/rate")) return Promise.resolve({ status: 200, data: okRate });
-            return Promise.resolve({ status: 200, data: {} });
+describe("goexmeSwapProvider", function () {
+    describe("getSwapInfo", function () {
+        const okRate = { result: true, rate: "15", minamount: "0.01", maxamount: "5" };
+        let provider, axiosStub;
+
+        beforeEach(() => {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
+            provider._supportedCoins = [
+                { coin: BTC, code: "BTC", network: "BTC" },
+                { coin: ETH, code: "ETH", network: "ETH" },
+            ];
+            provider._supportedCoinsLastUpdateTimestamp = Date.now();
+            sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+            axiosStub = sinon.stub(axios, "get").callsFake(url => {
+                if (url.includes("/pairs")) return Promise.resolve({ status: 200, data: { BTC: ["ETH"] } });
+                if (url.includes("/rate")) return Promise.resolve({ status: 200, data: okRate });
+                return Promise.resolve({ status: 200, data: {} });
+            });
         });
-    });
 
-    afterEach(() => sinon.restore());
+        afterEach(() => sinon.restore());
 
-    it("returns NOT_SUPPORTED if pair absent", async () => {
-        axiosStub.withArgs(sinon.match(/\/pairs/)).resolves({ status: 200, data: { BTC: ["USDT"] } });
-        (await provider.getSwapInfo(BTC, ETH, "1")).reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
-    });
+        it("Should return NOT_SUPPORTED if pair absent", async () => {
+            axiosStub.withArgs(sinon.match(/\/pairs/)).resolves({ status: 200, data: { BTC: ["USDT"] } });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
 
-    it("returns TOO_LOW / TOO_HIGH against min/max", async () => {
-        (await provider.getSwapInfo(BTC, ETH, "0.001")).reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_LOW);
-        (await provider.getSwapInfo(BTC, ETH, "10")).reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_HIGH);
-    });
+        it("Should return TOO_LOW and TOO_HIGH against min/max", async () => {
+            let info = await provider.getSwapInfo(BTC, ETH, "0.001");
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_LOW);
+            info = await provider.getSwapInfo(BTC, ETH, "10");
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_HIGH);
+        });
 
-    it("handles case with no min/max limits", async () => {
-        axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: { result: true, rate: "15" } });
-        const r = await provider.getSwapInfo(BTC, ETH, "1");
-        r.result.should.be.true();
-    });
+        it("Should handle case with no min/max limits", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: { result: true, rate: "15" } });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.true();
+        });
 
-    it("maps 429 to REQUESTS_LIMIT_EXCEEDED", async () => {
-        axiosStub.withArgs(sinon.match(/\/rate/)).rejects({ response: { status: 429 } });
-        const r = await provider.getSwapInfo(BTC, ETH, "1");
-        r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
-    });
+        it("Should map HTTP 429 to REQUESTS_LIMIT_EXCEEDED", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).rejects({ response: { status: 429 } });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
 
-    it("returns valid structure on success", async () => {
-        const r = await provider.getSwapInfo(BTC, ETH, "1");
-        r.result.should.be.true();
-        parseFloat(r.rate).should.be.greaterThan(0);
-    });
+        it("Should return valid structure on success", async () => {
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.true();
+            parseFloat(info.rate).should.be.greaterThan(0);
+        });
 
-    it("sends proper params to /rate", async () => {
-        await provider.getSwapInfo(BTC, ETH, "1");
-        const p = axiosStub.args.find(a => a[0].includes("/rate"))[1].params;
-        p.should.match({ from: "BTC", to: "ETH", amount: "1" });
-    });
+        it("Should send proper params to /rate", async () => {
+            await provider.getSwapInfo(BTC, ETH, "1");
+            const call = axiosStub.args.find(a => a[0].includes("/rate"));
+            const params = call[1].params;
+            params.should.match({ from: "BTC", to: "ETH", amount: "1" });
+        });
 
-    it("throws on non-Coin params", async () => {
-        await expect(provider.getSwapInfo({}, {}, "1")).rejects.toThrow();
-    });
-});
+        it("Should throw when amount ≤ 0", async () => {
+            await provider.getSwapInfo(BTC, ETH, "0").should.be.rejected();
+        });
 
-describe("goexmeSwapProvider::status mapping & existing swaps", () => {
-    const raw = {
-        status: "success",
-        id: "swap1",
-        date: "21-07-2023 04:17:30",
-        from: "BTC",
-        to: "ETH",
-        depositAddress: "addr-in",
-        destinationAddress: "addr-out",
-        amountFrom: "1",
-        amountTo: "0.01",
-        result: true,
-    };
-    let provider, axiosStub;
-
-    beforeEach(() => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false);
-        provider._supportedCoins = [
-            { coin: BTC, code: "BTC", network: "BTC" },
-            { coin: ETH, code: "ETH", network: "ETH" },
-        ];
-        sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
-        axiosStub = sinon.stub(axios, "get").resolves({ status: 200, data: raw });
-    });
+        it("Should return valid result when amount is empty string", async () => {
+            const info = await provider.getSwapInfo(BTC, ETH, "");
+            info.result.should.be.true();
+        });
 
-    afterEach(() => sinon.restore());
+        it("Should return valid result when amount is non-string", async () => {
+            const info = await provider.getSwapInfo(BTC, ETH, 1);
+            info.result.should.be.true();
+        });
 
-    it("maps every status string", () => {
-        provider._mapGoexmeStatus("time_expired").should.equal(SwapProvider.SWAP_STATUSES.EXPIRED);
-        provider._mapGoexmeStatus("deposit_received").should.equal(SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED);
-        provider._mapGoexmeStatus("failed").should.equal(SwapProvider.SWAP_STATUSES.FAILED);
-        provider._mapGoexmeStatus("exchanging").should.equal(SwapProvider.SWAP_STATUSES.EXCHANGING);
-        provider._mapGoexmeStatus("reverted").should.equal(SwapProvider.SWAP_STATUSES.REFUNDED);
-    });
+        it("Should include fix=true only when fixed quote requested", async () => {
+            await provider.getSwapInfo(BTC, ETH, "1", false);
+            axiosStub.lastCall.args[1].params.should.not.have.property("fix");
 
-    it("throws on unknown status", () => {
-        (() => provider._mapGoexmeStatus("weird")).should.throw(/Unknown Goexme status/);
-    });
+            await provider.getSwapInfo(BTC, ETH, "1", true);
+            axiosStub.lastCall.args[1].params.fix.should.be.true();
+        });
 
-    it("skips 404 responses", async () => {
-        axiosStub.onFirstCall().resolves({ status: 404 });
-        axiosStub.onSecondCall().resolves({ status: 200, data: raw });
-        const res = await provider.getExistingSwapsDetailsAndStatus(["x", "swap1"]);
-        res.swaps.should.have.length(1);
-        res.swaps[0].swapId.should.equal("swap1");
-    });
+        it("Should propagate unexpected network error unchanged", async () => {
+            const boom = new Error("net-boom");
+            axiosStub.rejects(boom);
+            await provider.getSwapInfo(BTC, ETH, "1").should.be.rejectedWith(boom);
+        });
 
-    it("filters out items when coins unsupported", async () => {
-        axiosStub.resetBehavior();
-        axiosStub.resolves({ status: 200, data: { ...raw, from: "LTC" } });
-        const res = await provider.getExistingSwapsDetailsAndStatus(["swapX"]);
-        res.swaps.should.eql([]);
-    });
+        it("Should return NOT_SUPPORTED when provider responds { result:false } with 200", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: { result: false } });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should throw when fromCoin/toCoin are not Coin instances", async () => {
+            await provider.getSwapInfo({}, {}, "1").should.be.rejected();
+        });
+
+        it("Should throw when amountIsToReceive = true", async () => {
+            await provider.getSwapInfo(BTC, ETH, "1", false, null, true).should.be.rejected();
+        });
 
-    it("propagates 429", async () => {
-        axiosStub.resetBehavior();
-        axiosStub.rejects({ response: { status: 429 } });
-        const r = await provider.getExistingSwapsDetailsAndStatus(["id"]);
-        r.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        it("Should set rate=null when provider omits the rate field", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({
+                status: 200,
+                data: { result: true, minamount: "0.1" },
+            });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            should(info.rate).be.null();
+        });
+
+        it("Should return NOT_SUPPORTED when either fromCoin or toCoin is unsupported", async () => {
+            const unsupported = new Coin(
+                "Unsupported",
+                "UNS",
+                "UNS",
+                8,
+                null,
+                "unit",
+                null,
+                null,
+                1,
+                null,
+                [],
+                null,
+                new Blockchain("Unsupported")
+            );
+            let info = await provider.getSwapInfo(unsupported, ETH, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+
+            info = await provider.getSwapInfo(BTC, unsupported, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should return NOT_SUPPORTED when /rate responds with unexpected data shape", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({ status: 200, data: {} });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+        });
+
+        it("Should copy provider .fix flag into info.fixed", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({
+                status: 200,
+                data: { result: true, rate: "15", minamount: "0.01", maxamount: "5", fix: true },
+            });
+            const info = await provider.getSwapInfo(BTC, ETH, "1");
+            info.result.should.be.true();
+            info.fixed.should.be.true();
+        });
+
+        it("Should return TOO_LOW and TOO_HIGH with correct smallestMin and greatestMax", async () => {
+            axiosStub.withArgs(sinon.match(/\/rate/)).resolves({
+                status: 200,
+                data: { result: true, rate: "15", minamount: "0.5", maxamount: "5" },
+            });
+            let info = await provider.getSwapInfo(BTC, ETH, "0.1");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_LOW);
+            info.smallestMin.should.equal("0.50000000");
+
+            info = await provider.getSwapInfo(BTC, ETH, "10");
+            info.result.should.be.false();
+            info.reason.should.equal(SwapProvider.NO_SWAPS_REASONS.TOO_HIGH);
+            info.greatestMax.should.equal("5.00000000");
+        });
     });
 });

package/src/swaps-lib/test/external-apis/goexmeSwapProvider/helpers.test.js

@@ -0,0 +1,26 @@
+import should from "should";
+import { describe, it } from "vitest";
+
+import { GoexmeSwapProvider } from "../../../external-apis/goexmeSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("goexmeSwapProvider", function () {
+    describe("helpers", function () {
+        it("getSwapCreationInfoTtlMs should return 30000 ms", () => {
+            const provider = new GoexmeSwapProvider("/", new Cache());
+            provider.getSwapCreationInfoTtlMs().should.equal(30000);
+        });
+
+        it("_parseGoexmeDate should convert date string to epoch", () => {
+            const timestamp = GoexmeSwapProvider._parseGoexmeDate("01.02.2024 03:04:05");
+            timestamp.should.equal(Date.parse("2024-02-01T03:04:05Z"));
+        });
+
+        it("getPartnersList should return single partner", async () => {
+            const provider = new GoexmeSwapProvider("/", new Cache());
+            const partners = await provider.getPartnersList();
+            partners.should.have.length(1);
+            partners[0].should.have.property("name", "GoExme");
+        });
+    });
+});

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

@@ -1,97 +1,97 @@
 import "dotenv/config";
-import { describe, it, beforeAll, expect } from "vitest";
+import sinon from "sinon";
+import should from "should";
+import { describe, it, beforeAll, afterEach } from "vitest";
+import axios from "axios";
+
 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;
 
-/**
- * ------------------------------------------------------------------
- * Positive-case:  every token below **must** be exchangable
- *                  against a major counterpart (BTC, or ETH for BTC)
- * ------------------------------------------------------------------
- */
 const ALLOWED_RABBIT_TICKERS = [
     "BNBBEP20",
     "BTC",
     "DOGE",
     "DOT",
     "ETH",
-    // "GMTSOL",
     "LTC",
     "SOL",
     "TRX",
     "USDCERC20",
     "USDTERC20",
-    // "USDTBEP20",
     "USDTSOL",
     "USDTTRC20",
     "XMR",
     "XRP",
 ];
 
-/**
- * ------------------------------------------------------------------
- * Negative-case:  these tokens MUST NOT be supported by the adapter
- * ------------------------------------------------------------------
- */
 const FORBIDDEN_TICKERS = ["ADA", "1INCH", "TRUMP"];
 
-/**
- * ------------------------------------------------------------------
- * Helper – treat “pair supported” broadly:
- *            • response.result === true
- *            • OR response.reason is TOO_LOW / TOO_HIGH
- * Any other outcome (NOT_SUPPORTED etc.) means the pair fails
- * ------------------------------------------------------------------
- */
-function isPairSupported(resp, provider) {
-    const { TOO_LOW, TOO_HIGH } = provider.constructor.NO_SWAPS_REASONS;
-    return resp.result === true || [TOO_LOW, TOO_HIGH].includes(resp.reason);
+function checkPairSupported(response, providerInstance) {
+    const { TOO_LOW, TOO_HIGH } = providerInstance.constructor.NO_SWAPS_REASONS;
+    return response.result === true || [TOO_LOW, TOO_HIGH].includes(response.reason);
 }
 
-maybeDescribe("GoexmeSwapProvider – pairs availability (live)", () => {
-    let provider;
+maybeDescribe("external-apis/goexmeSwapProvider integration", function () {
+    describe("pair support (live)", function () {
+        let provider;
 
-    beforeAll(async () => {
-        provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
-        await provider._fetchSupportedCurrenciesIfNeeded();
-        await provider._ensurePairsLoaded();
-    });
+        beforeAll(async function () {
+            provider = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+            await provider._fetchSupportedCurrenciesIfNeeded();
+            await provider._ensurePairsLoaded();
+        });
 
-    /* ------------------------------------------------------------------
-     * Positive tests – one per *allowed* Rabbit-ticker
-     * ---------------------------------------------------------------- */
-    ALLOWED_RABBIT_TICKERS.forEach(ticker => {
-        const fromTicker = ticker;
-        // Use BTC as the counterpart for every token except BTC itself.
-        const toTicker = ticker === "BTC" ? "ETH" : "BTC";
+        ALLOWED_RABBIT_TICKERS.forEach(fromTicker => {
+            const toTicker = fromTicker === "BTC" ? "ETH" : "BTC";
 
-        it(`supports swaps for ${fromTicker} → ${toTicker}`, async () => {
-            const fromCoin = provider.getCoinByTickerIfPresent(fromTicker);
-            const toCoin = provider.getCoinByTickerIfPresent(toTicker);
+            it(`Should support swaps for ${fromTicker}→${toTicker}`, async function () {
+                const fromCoin = provider.getCoinByTickerIfPresent(fromTicker);
+                const toCoin = provider.getCoinByTickerIfPresent(toTicker);
 
-            // Sanity: both coins must be known to the adapter
-            expect(fromCoin, "fromCoin missing").toBeTruthy();
-            expect(toCoin, "toCoin missing").toBeTruthy();
+                should.exist(fromCoin);
+                should.exist(toCoin);
 
-            const resp = await provider.getSwapInfo(fromCoin, toCoin, "1", false);
+                const response = await provider.getSwapInfo(fromCoin, toCoin, "1", false);
+                checkPairSupported(response, provider).should.be.true();
+            });
+        });
 
-            expect(
-                isPairSupported(resp, provider),
-                `Pair ${fromTicker}/${toTicker} unexpectedly unsupported: ${JSON.stringify(resp)}`
-            ).toBe(true);
+        FORBIDDEN_TICKERS.forEach(ticker => {
+            it(`Should not support swaps involving forbidden token ${ticker}`, function () {
+                const coin = provider.getCoinByTickerIfPresent(ticker);
+                should(coin).be.null();
+            });
         });
     });
 
-    /* ------------------------------------------------------------------
-     * Negative tests – one per *forbidden* ticker
-     * ---------------------------------------------------------------- */
-    FORBIDDEN_TICKERS.forEach(ticker => {
-        it(`does NOT support swaps involving forbidden token ${ticker}`, async () => {
-            const coin = provider.getCoinByTickerIfPresent(ticker);
-            expect(coin).toBeNull();
+    describe("_ensurePairsLoaded error propagation (live)", function () {
+        let providerInstance;
+        let axiosOriginalGet;
+
+        beforeAll(function () {
+            providerInstance = new GoexmeSwapProvider("/", new Cache(), () => null, false, GOEXME_API_KEY);
+            axiosOriginalGet = axios.get;
+        });
+
+        afterEach(function () {
+            if (axios.get.restore) {
+                axios.get.restore();
+            } else {
+                axios.get = axiosOriginalGet;
+            }
+        });
+
+        it("Should propagate network error from /pairs", async function () {
+            const networkError = new Error("net-boom");
+            sinon.stub(axios, "get").callsFake((url, cfg = {}) => {
+                if (url.includes("/pairs")) return Promise.reject(networkError);
+                return axiosOriginalGet(url, cfg);
+            });
+
+            await providerInstance._ensurePairsLoaded().should.be.rejectedWith(networkError);
         });
     });
 });