@rabbitio/ui-kit 1.0.0-beta.12 → 1.0.0-beta.121

package/src/swaps-lib/test/external-apis/changeNowSwapProvider/getExistingSwapsDetailsAndStatus.test.js

@@ -0,0 +1,353 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+import { describe, it, beforeEach, afterEach } from "vitest";
+import { DEFAULT_CRYPTO_DECIMAL_COUNT } from "../../../../common-apis/globalConstants.jsx";
+import { toRabbitTicker } from "../../../../common-apis/utils/rabbitTicker.js";
+
+import { ChangeNowSwapProvider } from "../../../external-apis/changeNowSwapProvider.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { Coin } from "../../../../common-apis/models/coin.js";
+
+describe("src/swaps-lib/external-apis/changeNowSwapProvider.js", function () {
+    describe("getExistingSwapsDetailsAndStatus", function () {
+        let provider;
+        let axiosGetStub;
+        let fetchCoinsStub;
+        let fromCoin;
+        let toCoin;
+        let clock;
+
+        function buildCoin(ticker, digits = 8) {
+            return new Coin(
+                ticker,
+                ticker,
+                ticker,
+                digits,
+                null,
+                "",
+                null,
+                null,
+                1,
+                null,
+                [],
+                60000,
+                null,
+                null,
+                null,
+                false
+            );
+        }
+
+        beforeEach(function () {
+            provider = new ChangeNowSwapProvider(null, new Cache());
+            axiosGetStub = sinon.stub(axios, "get");
+            fetchCoinsStub = sinon.stub(provider, "_fetchSupportedCurrenciesIfNeeded").resolves();
+            fromCoin = buildCoin("BTC");
+            toCoin = buildCoin("ETH");
+            provider._supportedCoins = [
+                { coin: fromCoin, code: "BTC", network: null },
+                { coin: toCoin, code: "ETH", network: null },
+            ];
+            clock = sinon.useFakeTimers();
+        });
+
+        afterEach(function () {
+            clock.restore();
+            sinon.restore();
+        });
+
+        it("Should return an empty array when no swap ids are supplied", async function () {
+            const res = await provider.getExistingSwapsDetailsAndStatus([]);
+            res.result.should.be.true();
+            res.swaps.should.deepEqual([]);
+            axiosGetStub.called.should.be.false();
+        });
+
+        it("Should insert null for non-200 responses and resolve remaining ids", async function () {
+            const ids = ["id1", "id2"];
+            axiosGetStub.onCall(0).resolves({ status: 404, data: {} });
+            axiosGetStub.onCall(1).resolves({
+                status: 200,
+                data: {
+                    status: "waiting",
+                    createdAt: null,
+                    validUntil: null,
+                    amountFrom: "1",
+                    amountTo: "2",
+                    payinAddress: "from",
+                    payoutAddress: "to",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(ids);
+            res.result.should.be.true();
+            res.swaps.should.have.length(2);
+            should(res.swaps[0]).be.null();
+            res.swaps[1].swapId.should.equal("id2");
+            res.swaps[1].status.should.equal(SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT);
+        });
+
+        it("Should map provider statuses into internal enums", async function () {
+            const statuses = [
+                { input: "new", expected: SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT },
+                { input: "waiting", expected: SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT },
+                { input: "confirming", expected: SwapProvider.SWAP_STATUSES.CONFIRMING },
+                { input: "exchanging", expected: SwapProvider.SWAP_STATUSES.EXCHANGING },
+                { input: "sending", expected: SwapProvider.SWAP_STATUSES.EXCHANGING },
+                { input: "finished", expected: SwapProvider.SWAP_STATUSES.COMPLETED },
+                { input: "failed", expected: SwapProvider.SWAP_STATUSES.FAILED },
+                { input: "refunded", expected: SwapProvider.SWAP_STATUSES.REFUNDED },
+                { input: "verifying", expected: SwapProvider.SWAP_STATUSES.VERIFYING },
+            ];
+            const swapIds = statuses.map((_, idx) => `s${idx}`);
+            statuses.forEach((st, index) => {
+                axiosGetStub.onCall(index).resolves({
+                    status: 200,
+                    data: {
+                        status: st.input,
+                        createdAt: null,
+                        validUntil: null,
+                        fromAmount: "1",
+                        toAmount: "1",
+                        payinAddress: "from",
+                        payoutAddress: "to",
+                        fromCurrency: "BTC",
+                        toCurrency: "ETH",
+                    },
+                });
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(swapIds);
+            res.result.should.be.true();
+            res.swaps.forEach((swap, index) => {
+                swap.status.should.equal(statuses[index].expected);
+            });
+        });
+
+        it("Should compute expiresAt using validUntil when provided or fallback to createdAt plus expiration", async function () {
+            const now = Date.now();
+            const validUntil = new Date(now + 3600 * 1000).toISOString();
+            axiosGetStub.onCall(0).resolves({
+                status: 200,
+                data: {
+                    status: "waiting",
+                    createdAt: new Date(now - 1000).toISOString(),
+                    validUntil: validUntil,
+                    fromAmount: "1",
+                    toAmount: "1",
+                    payinAddress: "from",
+                    payoutAddress: "to",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            axiosGetStub.onCall(1).resolves({
+                status: 200,
+                data: {
+                    status: "waiting",
+                    createdAt: new Date(now).toISOString(),
+                    validUntil: null,
+                    fromAmount: "1",
+                    toAmount: "1",
+                    payinAddress: "from",
+                    payoutAddress: "to",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const ids = ["id1", "id2"];
+            const res = await provider.getExistingSwapsDetailsAndStatus(ids);
+            res.result.should.be.true();
+            res.swaps[0].expiresAt.should.equal(new Date(validUntil).getTime());
+            const createdAtMs = new Date(now).getTime();
+            res.swaps[1].expiresAt.should.equal(createdAtMs + provider._swapExpirationMs);
+        });
+
+        it("Should continue processing after per-item network errors and leave null in place", async function () {
+            axiosGetStub.onCall(0).rejects(new Error("network failure"));
+            axiosGetStub.onCall(1).resolves({
+                status: 200,
+                data: {
+                    status: "waiting",
+                    createdAt: null,
+                    validUntil: null,
+                    fromAmount: "1",
+                    toAmount: "1",
+                    payinAddress: "from",
+                    payoutAddress: "to",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["a", "b"]);
+            res.result.should.be.true();
+            should(res.swaps[0]).be.null();
+            should.exist(res.swaps[1]);
+        });
+
+        it("Should return REQUESTS_LIMIT_EXCEEDED when the loader fails with 429", async function () {
+            fetchCoinsStub.rejects({ response: { status: 429 } });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["id"]);
+            res.result.should.be.false();
+            res.reason.should.equal(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        });
+
+        it("Should create a placeholder coin when 'to' asset is unsupported", async function () {
+            provider._supportedCoins = [{ coin: fromCoin, code: "BTC", network: null }];
+            axiosGetStub.resolves({
+                status: 200,
+                data: {
+                    status: "sending",
+                    createdAt: null,
+                    validUntil: null,
+                    fromAmount: "1",
+                    toAmount: "2",
+                    payinAddress: "in",
+                    payoutAddress: "out",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["x"]);
+            res.result.should.be.true();
+            res.swaps.length.should.equal(1);
+            const swap = res.swaps[0];
+            should.exist(swap.toCoin);
+            swap.toCoin.should.have.properties(["ticker", "digits"]);
+            const expectedTicker = toRabbitTicker("ETH", "ETH");
+            swap.toCoin.ticker.should.equal(expectedTicker);
+            swap.toCoin.digits.should.equal(DEFAULT_CRYPTO_DECIMAL_COUNT);
+        });
+
+        it("Should return separate results for duplicate ids", async function () {
+            axiosGetStub.onCall(0).resolves({
+                status: 200,
+                data: {
+                    status: "sending",
+                    createdAt: null,
+                    validUntil: null,
+                    amountFrom: "1",
+                    amountTo: "2",
+                    payinAddress: "from",
+                    payoutAddress: "to",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            axiosGetStub.onCall(1).resolves({
+                status: 200,
+                data: {
+                    status: "sending",
+                    createdAt: null,
+                    validUntil: null,
+                    amountFrom: "2",
+                    amountTo: "4",
+                    payinAddress: "from2",
+                    payoutAddress: "to2",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["dup", "dup"]);
+            res.result.should.be.true();
+            res.swaps.should.have.length(2);
+            res.swaps[0].fromAmount.should.equal("1");
+            res.swaps[1].fromAmount.should.equal("2");
+        });
+
+        it("Should insert null for 500 HTTP status and continue processing", async function () {
+            axiosGetStub.onCall(0).resolves({ status: 500, data: {} });
+            axiosGetStub.onCall(1).resolves({
+                status: 200,
+                data: {
+                    status: "finished",
+                    createdAt: null,
+                    validUntil: null,
+                    fromAmount: "1",
+                    toAmount: "2",
+                    payinAddress: "in",
+                    payoutAddress: "out",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["x", "y"]);
+            res.result.should.be.true();
+            res.swaps.should.have.length(2);
+            should(res.swaps[0]).be.null();
+            res.swaps[1].status.should.equal(SwapProvider.SWAP_STATUSES.COMPLETED);
+        });
+
+        it("Should map payinHash and payoutHash into swap transaction ids", async function () {
+            axiosGetStub.resolves({
+                status: 200,
+                data: {
+                    status: "sending",
+                    createdAt: null,
+                    validUntil: null,
+                    fromAmount: "1",
+                    toAmount: "1",
+                    payinAddress: "in",
+                    payoutAddress: "out",
+                    payinHash: "txIN",
+                    payoutHash: "txOUT",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["hashTest"]);
+            res.result.should.be.true();
+            const swap = res.swaps[0];
+            swap.fromTransactionId.should.equal("txIN");
+            swap.toTransactionId.should.equal("txOUT");
+        });
+
+        it("Should include extra IDs from provider into ExistingSwap", async function () {
+            axiosGetStub.resolves({
+                status: 200,
+                data: {
+                    status: "sending",
+                    createdAt: null,
+                    validUntil: null,
+                    fromAmount: "1",
+                    toAmount: "1",
+                    payinAddress: "in",
+                    payoutAddress: "out",
+                    payinExtraId: "memoIn",
+                    payoutExtraId: "memoOut",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["extraTest"]);
+            res.result.should.be.true();
+            const swap = res.swaps[0];
+            swap.fromExtraId.should.equal("memoIn");
+            swap.toExtraId.should.equal("memoOut");
+        });
+
+        it("Should keep createdAt null when not provided", async function () {
+            clock.tick(5000);
+            axiosGetStub.resolves({
+                status: 200,
+                data: {
+                    status: "waiting",
+                    createdAt: null,
+                    validUntil: null,
+                    fromAmount: "1",
+                    toAmount: "1",
+                    payinAddress: "in",
+                    payoutAddress: "out",
+                    fromCurrency: "BTC",
+                    toCurrency: "ETH",
+                },
+            });
+            const res = await provider.getExistingSwapsDetailsAndStatus(["timeTest"]);
+            res.result.should.be.true();
+            const swap = res.swaps[0];
+            should(swap.createdAt).be.null();
+        });
+    });
+});