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

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

@@ -0,0 +1,111 @@
+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("getWithdrawalCurrencies", 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.getWithdrawalCurrencies();
+            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 withdrawal == 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.withdrawal)
+                .map((item) => item.coin);
+
+            const result = await swapspaceProvider.getWithdrawalCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins having withdrawal == true except the passed coin ticker", async () => {
+            swapspaceProvider._supportedCoins = [
+                {
+                    coin: { ticker: "BTC" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                {
+                    coin: { ticker: "ALGO" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                { coin: 1, withdrawal: false, deposit: null },
+                { coin: "4", withdrawal: true, deposit: true },
+                { coin: "-12312", withdrawal: null, deposit: false },
+            ];
+            const expectedCoins = swapspaceProvider._supportedCoins
+                .filter((i) => i.withdrawal && i.coin.ticker !== "ALGO")
+                .map((item) => item.coin);
+
+            const result = await swapspaceProvider.getWithdrawalCurrencies({
+                ticker: "ALGO",
+            });
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapspaceProvider.getWithdrawalCurrencies();
+
+            _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.getWithdrawalCurrencies();
+                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/utils/swapUtils/safeHandleRequestsLimitExceeding.test.js

@@ -0,0 +1,88 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+import { Logger } from "../../../../common/utils/logging/logger.js";
+import { EmailsApi } from "../../../../common/utils/emailAPI.js";
+import { SwapUtils } from "../../../utils/swapUtils.js";
+
+describe("SwapUtils", function () {
+    let sendEmailStub;
+
+    beforeEach(function () {
+        sendEmailStub = sinon.stub(EmailsApi, "sendEmail").resolves();
+    });
+
+    afterEach(function () {
+        sendEmailStub.restore();
+    });
+
+    describe("safeHandleRequestsLimitExceeding", function () {
+        it("Should ensure that sendEmail is called when safeHandleRequestsLimitExceeding is invoked", function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub.called.should.be.true();
+        });
+
+        it("Should verify that sendEmail is called once", function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub.callCount.should.equal(1);
+        });
+
+        it('Should ensure that sendEmail is called with the correct subject: "AUTOMATIC EMAIL - SWAPSPACE REQUESTS LIMIT EXCEEDED"', function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub
+                .calledWith(
+                    "AUTOMATIC EMAIL - SWAPSPACE REQUESTS LIMIT EXCEEDED"
+                )
+                .should.be.true();
+        });
+
+        it('Should ensure that sendEmail is called with the correct body: "Requests limit exceeded. Urgently ask swapspace support for limit increasing"', function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub
+                .calledWith(
+                    sinon.match.any,
+                    "Requests limit exceeded. Urgently ask swaps provider support for limit increasing"
+                )
+                .should.be.true();
+        });
+
+        it("Should handle an error thrown by the sendEmail function without crashing", function (done) {
+            sendEmailStub.rejects(new Error("Fake error for testing purposes"));
+
+            let error;
+            try {
+                SwapUtils.safeHandleRequestsLimitExceeding();
+            } catch (e) {
+                error = e;
+            }
+            (error === undefined).should.be.true();
+        });
+
+        it("Should ensure that safeHandleRequestsLimitExceeding does not return a value", function () {
+            const result = SwapUtils.safeHandleRequestsLimitExceeding();
+
+            (!result).should.be.true();
+        });
+
+        it("Should log a descriptive error message when a failure occurs", function (done) {
+            sendEmailStub.rejects(new Error("Fake error for testing purposes"));
+            const logStub = sinon.stub(Logger, "log");
+
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            setTimeout(() => {
+                logStub
+                    .calledWithMatch(
+                        sinon.match("Failed to handle limit exceeding")
+                    )
+                    .should.be.true();
+                logStub.restore();
+            }, 10);
+        });
+    });
+});

package/stories/stubs/exampleContent.jsx

@@ -0,0 +1,20 @@
+import React from "react";
+
+export const exampleContent = (
+    <div
+        style={{
+            width: "100%",
+            height: "300px",
+            borderRadius: "16px",
+            background: "#eee",
+            color: "#bbb",
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+            fontSize: "12px",
+            fontFamily: "monospace",
+        }}
+    >
+        Example content
+    </div>
+);

package/styles/index.scss

@@ -1,33 +1,34 @@
 @import "variables";
 @import "global-classes";
 @import "placeholder";
+@import "_mixins";
 
 @font-face {
-    //src: url("fonts/NunitoSans-ExtraBold.ttf");
-    //font-family: "NunitoSans";
+    src: url("fonts/NunitoSans-ExtraBold.ttf");
+    font-family: "NunitoSans";
     font-weight: $extra-bold;
 }
 
 @font-face {
-    //src: url("fonts/NunitoSans-Bold.ttf");
-    //font-family: "NunitoSans";
+    src: url("fonts/NunitoSans-Bold.ttf");
+    font-family: "NunitoSans";
     font-weight: $bold;
 }
 
 @font-face {
-    //src: url("fonts/NunitoSans-SemiBold.ttf");
-    //font-family: "NunitoSans";
-    font-weight: 600;
+    src: url("fonts/NunitoSans-SemiBold.ttf");
+    font-family: "NunitoSans";
+    font-weight: $semi-bold;
 }
 
 @font-face {
-    //src: url("fonts/NunitoSans-Regular.ttf");
-    //font-family: "NunitoSans";
-    font-weight: 400;
+    src: url("fonts/NunitoSans-Regular.ttf");
+    font-family: "NunitoSans";
+    font-weight: $medium;
 }
 
 @font-face {
-    //src: url("fonts/NunitoSans-Light.ttf");
-    //font-family: "NunitoSans";
-    font-weight: 300;
+    src: url("fonts/NunitoSans-Light.ttf");
+    font-family: "NunitoSans";
+    font-weight: $regular;
 }