@ledgerhq/live-common
Version:
Common ground for the Ledger Live apps
99 lines • 4.33 kB
JavaScript
/**
* @jest-environment jsdom
*/
import "../../__tests__/test-helpers/dom-polyfill";
import { setSupportedCurrencies } from "../../currencies/index";
setSupportedCurrencies(["tron"]);
import { renderHook, act } from "@testing-library/react";
import { useTronSuperRepresentatives, getLastVotedDate, getNextRewardDate, formatVotes, useSortedSr, getUnfreezeData, } from "./react";
import { __NEXT_REWARD_DATE__, __LAST_VOTING_DATE__, mockAccount, mockAccountNoReward, mockAccountNoVote, mockAccountV2, } from "./data.mock";
import superRepresentatives from "@ledgerhq/coin-tron/network/superRepresentativesData.mock";
jest.mock("@ledgerhq/coin-tron/network", () => {
return {
getTronSuperRepresentatives: jest.fn().mockImplementation(() => {
return Promise.resolve(superRepresentatives);
}),
};
});
jest.mock("@ledgerhq/coin-tron/logic/utils", () => {
return {
extractBandwidthInfo: jest.fn().mockImplementation(() => {
return {
freeUsed: 0,
freeLimit: 0,
gainedUsed: 0,
gainedLimit: 0,
};
}),
};
});
test("Tron SuperRepresentatives hook - useTronSuperRepresentatives - Expect super representatives list", async () => {
const { result } = renderHook(() => useTronSuperRepresentatives());
await act(async () => {
expect(result.current).toStrictEqual([]);
});
process.nextTick(() => expect(result.current).toStrictEqual(superRepresentatives));
});
test("Tron get last voting date - getLastVotedDate - Expect to get last voted date", () => {
expect(getLastVotedDate(mockAccount)).toStrictEqual(__LAST_VOTING_DATE__);
expect(getLastVotedDate(mockAccountNoVote)).toStrictEqual(null);
});
test("Tron get next reward date - getNextRewardDate - Expect to get next reward date", () => {
expect(getNextRewardDate(mockAccount)).toStrictEqual(__NEXT_REWARD_DATE__.valueOf() + 24 * 60 * 60 * 1000);
expect(getNextRewardDate(mockAccountNoReward)).toStrictEqual(null);
});
const __VOTES__ = superRepresentatives.slice(0, 2).map(({ address }) => ({
address,
voteCount: 100,
}));
const __FORMATTED_VOTES__ = superRepresentatives.slice(0, 2).map((validator, i) => ({
address: validator.address,
voteCount: 100,
validator,
rank: i + 1,
isSR: true,
}));
test("Tron format votes - formatVotes - Expect to get formatted votes", () => {
expect(formatVotes(undefined, superRepresentatives)).toStrictEqual([]);
expect(formatVotes(__VOTES__, superRepresentatives)).toStrictEqual(__FORMATTED_VOTES__);
});
const SR_INDEX_1 = 9;
const SR_INDEX_2 = 2;
const VOTE_AMOUNT_1 = 10;
const VOTE_AMOUNT_2 = 50;
const votes = [
{
address: superRepresentatives[SR_INDEX_1].address,
voteCount: VOTE_AMOUNT_1,
},
{
address: superRepresentatives[SR_INDEX_2].address,
voteCount: VOTE_AMOUNT_2,
},
];
test("Tron search SR - search SR in the list - Expect to retrieve a specific list SR", () => {
const { result } = renderHook(() => useSortedSr(superRepresentatives[SR_INDEX_1].name,
// @ts-expect-error wat
superRepresentatives, votes));
act(() => {
expect(Array.isArray(result.current)).toBe(true);
expect(result.current[0].address).toBe(superRepresentatives[SR_INDEX_1].address);
});
});
test("Tron search SR - search SR in the list - Expect to retrieve all the list if no search provided and sorted by votes", () => {
const { result } = renderHook(() => useSortedSr("", superRepresentatives, votes));
act(() => {
expect(Array.isArray(result.current)).toBe(true);
expect(result.current.length).toBe(superRepresentatives.length);
expect(result.current[0].address).toBe(votes[1].address);
expect(result.current[1].address).toBe(votes[0].address);
});
});
test("Tron unfreeze - get unfreeze data - Expect to retrieve unfreeze data from account", () => {
const { unfreezeBandwidth, unfreezeEnergy, canUnfreezeBandwidth, canUnfreezeEnergy } = getUnfreezeData(mockAccountV2);
expect(unfreezeBandwidth.toString()).toBe("539000000");
expect(unfreezeEnergy.toString()).toBe("28877000");
expect(canUnfreezeBandwidth).toBe(true);
expect(canUnfreezeEnergy).toBe(true);
});
//# sourceMappingURL=react.test.js.map