@ledgerhq/coin-casper/lib/bridge/estimateMaxSpendable.test.js

Ledger Casper integration

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const bignumber_js_1 = require("bignumber.js");
const estimateMaxSpendable_1 = require("./estimateMaxSpendable");
const fee_1 = require("./bridgeHelpers/fee");
const fixtures_1 = require("../test/fixtures");
// Mock the fee helper
jest.mock("./bridgeHelpers/fee", () => ({
    getEstimatedFees: jest.fn().mockReturnValue(new bignumber_js_1.BigNumber(1000000)),
}));
describe("estimateMaxSpendable", () => {
    const mockAccount = {
        id: "casper:0:testAccount",
        type: "Account",
        spendableBalance: new bignumber_js_1.BigNumber(10000000),
    };
    afterEach(() => {
        jest.clearAllMocks();
    });
    test("should return zero when balance is zero", async () => {
        const zeroBalanceAccount = {
            ...mockAccount,
            spendableBalance: new bignumber_js_1.BigNumber(0),
        };
        const result = await (0, estimateMaxSpendable_1.estimateMaxSpendable)({
            account: zeroBalanceAccount,
            parentAccount: undefined,
        });
        expect(result.toNumber()).toBe(0);
        expect(fee_1.getEstimatedFees).not.toHaveBeenCalled();
    });
    test("should return balance minus fees when no transaction is provided", async () => {
        const result = await (0, estimateMaxSpendable_1.estimateMaxSpendable)({
            account: mockAccount,
            parentAccount: undefined,
        });
        const expectedFees = new bignumber_js_1.BigNumber(1000000);
        const expectedMaxSpendable = mockAccount.spendableBalance.minus(expectedFees);
        expect(result.toString()).toBe(expectedMaxSpendable.toString());
        expect(fee_1.getEstimatedFees).toHaveBeenCalled();
    });
    test("should use transaction fees when transaction is provided", async () => {
        const transactionFees = new bignumber_js_1.BigNumber(500000);
        const mockTransaction = {
            fees: transactionFees,
        };
        const result = await (0, estimateMaxSpendable_1.estimateMaxSpendable)({
            account: mockAccount,
            parentAccount: undefined,
            transaction: mockTransaction,
        });
        const expectedMaxSpendable = mockAccount.spendableBalance.minus(transactionFees);
        expect(result.toString()).toBe(expectedMaxSpendable.toString());
        expect(fee_1.getEstimatedFees).not.toHaveBeenCalled();
    });
    test("should return zero when balance is less than fees", async () => {
        const lowBalanceAccount = {
            ...mockAccount,
            spendableBalance: new bignumber_js_1.BigNumber(500000), // Less than default fee of 1000000
        };
        const result = await (0, estimateMaxSpendable_1.estimateMaxSpendable)({
            account: lowBalanceAccount,
            parentAccount: undefined,
        });
        expect(result.toString()).toBe("0");
    });
    test("should use main account when parentAccount is provided", async () => {
        const parentAccount = {
            id: "casper:parent",
            spendableBalance: new bignumber_js_1.BigNumber(0),
        };
        const result = await (0, estimateMaxSpendable_1.estimateMaxSpendable)({
            account: mockAccount,
            parentAccount: parentAccount,
        });
        const expectedFees = new bignumber_js_1.BigNumber(1000000);
        const expectedMaxSpendable = mockAccount.spendableBalance.minus(expectedFees);
        expect(result.toString()).toBe(expectedMaxSpendable.toString());
    });
});
// Add test cases from fixtures
describe("estimateMaxSpendable with standard test cases", () => {
    const standardFees = new bignumber_js_1.BigNumber("1000000");
    beforeEach(() => {
        fee_1.getEstimatedFees.mockReturnValue(standardFees);
    });
    test.each([
        {
            name: "Standard account",
            account: (0, fixtures_1.createMockAccount)(),
            expectedResult: new bignumber_js_1.BigNumber("10000000000").minus(standardFees),
        },
        {
            name: "Empty account",
            account: (0, fixtures_1.createMockAccount)({
                balance: new bignumber_js_1.BigNumber("0"),
                spendableBalance: new bignumber_js_1.BigNumber("0"),
            }),
            expectedResult: new bignumber_js_1.BigNumber("0"),
        },
        {
            name: "Account with balance less than fees",
            account: (0, fixtures_1.createMockAccount)({
                balance: standardFees.div(2),
                spendableBalance: standardFees.div(2),
            }),
            expectedResult: new bignumber_js_1.BigNumber("0"),
        },
        {
            name: "Account with balance equal to fees",
            account: (0, fixtures_1.createMockAccount)({
                balance: standardFees,
                spendableBalance: standardFees,
            }),
            expectedResult: new bignumber_js_1.BigNumber("0"),
        },
        {
            name: "Account with high balance",
            account: (0, fixtures_1.createMockAccount)({
                balance: new bignumber_js_1.BigNumber("100000000000000"),
                spendableBalance: new bignumber_js_1.BigNumber("100000000000000"),
            }),
            expectedResult: new bignumber_js_1.BigNumber("100000000000000").minus(standardFees),
        },
    ])("should handle $name", async ({ account, expectedResult }) => {
        const result = await (0, estimateMaxSpendable_1.estimateMaxSpendable)({
            account: account,
            parentAccount: undefined,
        });
        expect(result.toString()).toBe(expectedResult.toString());
    });
});
//# sourceMappingURL=estimateMaxSpendable.test.js.map