trac-msb 0.2.17 → 0.2.19

package/tests/unit/utils/fileUtils/readBalanceMigrationFile.test.js

@@ -1,149 +0,0 @@
-import { test, hook } from 'brittle';
-import fileUtils from '../../../../src/utils/fileUtils.js';
-import { errorMessageIncludes } from "../../../helpers/regexHelper.js";
-import fs from 'fs';
-import PeerWallet from 'trac-wallet';
-import { config } from '../../../helpers/config.js';
-import { asAddress } from '../../../helpers/address.js';
-
-const DUMMY_PATH_OK = './dummy_balance_ok.csv';
-const DUMMY_PATH_DUP = './dummy_balance_dup.csv';
-const DUMMY_PATH_INVALID_ADDRESS = './dummy_balance_invalid_address.csv';
-const DUMMY_PATH_ADMIN_ADDRESS = './dummy_balance_admin_address.csv';
-const DUMMY_PATH_EMPTY = './dummy_balance_empty.csv';
-const DUMMY_PATH_WHITESPACE = './dummy_balance_whitespace.csv';
-const DUMMY_PATH_INVALID_BALANCE = './dummy_balance_invalid_balance.csv';
-const DUMMY_PATH_NEGATIVE = './dummy_balance_negative.csv';
-const DUMMY_PATH_MALFORMED = './dummy_balance_malformed.csv';
-const DUMMY_PATH_BLANK = './dummy_balance_blank.csv';
-const DUMMY_PATH_ZERO = './dummy_balance_zero.csv';
-const DUMMY_PATH_BOM = './dummy_balance_bom.csv';
-const DUMMY_PATH_LARGE = './dummy_balance_large.csv';
-
-const ADDR1 = asAddress('6a38e14198866f0fdf4d4495b07e066cfd0a2e8cbe774d11af37d15f741ac984');
-const ADDR2 = asAddress('544514242356432739de9af71deb8d526fb03d6c5c15e0a934d9a20b6710e2fe');
-
-hook('Initialize dummy balance files', async t => {
-    // Happy path
-    fs.writeFileSync(DUMMY_PATH_OK, `${ADDR1},1.000000000000000001\n${ADDR2},2.000000000000000000\n`);
-    // Edge: duplicated address
-    fs.writeFileSync(DUMMY_PATH_DUP, `${ADDR1},1.0\n${ADDR1},2.0\n`);
-    // Edge: Empty file
-    fs.writeFileSync(DUMMY_PATH_EMPTY, '');
-    // Edge: address with whitespace
-    fs.writeFileSync(DUMMY_PATH_WHITESPACE, `  ${ADDR1}  , 1.0\n`);
-    // Edge: invalid balance format
-    fs.writeFileSync(DUMMY_PATH_INVALID_BALANCE, `${ADDR1},notanumber\n`);
-    // Edge: negative balance
-    fs.writeFileSync(DUMMY_PATH_NEGATIVE, `${ADDR1},-1.0\n`);
-    // Edge: malformed line (missing balance)
-    fs.writeFileSync(DUMMY_PATH_MALFORMED, `${ADDR1}\n`);
-    // Edge: blank lines and whitespace only
-    fs.writeFileSync(DUMMY_PATH_BLANK, `\n   \n${ADDR1},1.0\n`);
-    // Edge: zero balance
-    fs.writeFileSync(DUMMY_PATH_ZERO, `${ADDR1},0.0\n`);
-    // Edge: file with BOM
-    fs.writeFileSync(DUMMY_PATH_BOM, '\uFEFF' + `${ADDR1},1.0\n`);
-    // Edge: large file
-    let large = '';
-    const randomAddress = async () => {
-        const wallet = new PeerWallet({ derivationPath: config.derivationPath });
-        await wallet.ready;
-        await wallet.generateKeyPair(undefined, config.derivationPath);
-        return wallet.address;
-    }
-    for (let i = 0; i < 1000; i++) {
-        const rand = await randomAddress(config.addressPrefix);
-        large += `${rand},1.0\n`;
-    }
-    fs.writeFileSync(DUMMY_PATH_LARGE, large);
-});
-
-
-test('readBalanceMigrationFile - valid file', async (t) => {
-    const { addressBalancePair, totalBalance, totalAddresses } = await fileUtils.readBalanceMigrationFile(DUMMY_PATH_OK);
-    t.is(typeof addressBalancePair, 'object');
-    t.is(addressBalancePair.size, 2);
-    t.is(totalAddresses, 2);
-    t.ok(totalBalance > 0n);
-    t.ok(addressBalancePair.has(ADDR1));
-    t.ok(addressBalancePair.has(ADDR2));
-});
-
-test('readBalanceMigrationFile - address with whitespace', async (t) => {
-    await t.exception(() => fileUtils.readBalanceMigrationFile( DUMMY_PATH_WHITESPACE),
-        errorMessageIncludes('Failed to read balance migration file: Invalid line in balance migration file:'))
-});
-
-test('readBalanceMigrationFile - duplicate address', async (t) => {
-    await t.exception(() => fileUtils.readBalanceMigrationFile(DUMMY_PATH_DUP),
-        errorMessageIncludes(`Duplicate address found in balance migration file: '${ADDR1}'. Each address must be unique.`))
-});
-
-test('readBalanceMigrationFile - invalid balance format', async (t) => {
-    await t.exception(() => fileUtils.readBalanceMigrationFile(DUMMY_PATH_INVALID_BALANCE),
-        errorMessageIncludes(`Failed to read balance migration file: Invalid line in balance migration file: `))
-});
-
-test('readBalanceMigrationFile - negative balance', async (t) => {
-    await t.exception(() => fileUtils.readBalanceMigrationFile(DUMMY_PATH_NEGATIVE),
-        errorMessageIncludes(`Failed to read balance migration file: Invalid line in balance migration file: `))
-});
-
-test('readBalanceMigrationFile - malformed line', async (t) => {
-    await t.exception(() => fileUtils.readBalanceMigrationFile( DUMMY_PATH_MALFORMED),
-        errorMessageIncludes(`Failed to read balance migration file: Invalid line in balance migration file: `))
-});
-
-test('readBalanceMigrationFile - blank lines and whitespace', async (t) => {
-    const { addressBalancePair, totalBalance, totalAddresses } = await fileUtils.readBalanceMigrationFile(DUMMY_PATH_BLANK);
-    t.is(addressBalancePair.size, 1);
-    t.is(totalAddresses, 1);
-    t.ok(addressBalancePair.has(ADDR1));
-});
-
-test('readBalanceMigrationFile - zero balance', async (t) => {
-    const { addressBalancePair, totalBalance, totalAddresses } = await fileUtils.readBalanceMigrationFile( DUMMY_PATH_ZERO);
-    t.is(addressBalancePair.size, 1);
-    t.is(totalBalance, 0n);
-    t.is(totalAddresses, 1);
-    t.ok(addressBalancePair.has(ADDR1));
-});
-
-test('readBalanceMigrationFile - BOM at start', async (t) => {
-    const { addressBalancePair, totalBalance, totalAddresses } = await fileUtils.readBalanceMigrationFile(DUMMY_PATH_BOM);
-    t.is(addressBalancePair.size, 1);
-    t.is(totalAddresses, 1);
-    t.ok(addressBalancePair.has(ADDR1));
-});
-
-test('readBalanceMigrationFile - large file', async (t) => {
-    const { addressBalancePair, totalBalance, totalAddresses } = await fileUtils.readBalanceMigrationFile(DUMMY_PATH_LARGE);
-    t.is(addressBalancePair.size, 1000);
-    t.is(totalAddresses, 1000);
-});
-
-test('readBalanceMigrationFile - empty file', async (t) => {
-    await t.exception(() => fileUtils.readBalanceMigrationFile(DUMMY_PATH_EMPTY),
-        errorMessageIncludes('Balance migration file is empty. File must contain at least one valid address balance pair.'))
-});
-
-test('readBalanceMigrationFile - file does not exist', async (t) => {
-    const nonExistentPath = './non_existent_balance.csv';
-    await t.exception(() => fileUtils.readBalanceMigrationFile(nonExistentPath),
-        errorMessageIncludes(`Balance migration file not found: ${nonExistentPath}`))
-});
-
-test('readBalanceMigrationFile - invalid file extension', async (t) => {
-    const invalidExtensionPath = './dummy_balance.txt';
-    await t.exception(() => fileUtils.readBalanceMigrationFile(invalidExtensionPath),
-        errorMessageIncludes(`Invalid file format: ${invalidExtensionPath}. Balance migration file must be a CSV file.`))
-});
-
-hook('Cleanup dummy balance files', async t => {
-    [DUMMY_PATH_OK, DUMMY_PATH_DUP, DUMMY_PATH_EMPTY,
-     DUMMY_PATH_WHITESPACE, DUMMY_PATH_INVALID_BALANCE, DUMMY_PATH_NEGATIVE, DUMMY_PATH_MALFORMED, DUMMY_PATH_BLANK,
-     DUMMY_PATH_ZERO, DUMMY_PATH_BOM, DUMMY_PATH_LARGE].forEach(path => {
-        if (fs.existsSync(path)) fs.unlinkSync(path);
-    });
-});

package/tests/unit/utils/helpers/helpers.test.js

@@ -1,11 +0,0 @@
-import { default as test } from 'brittle';
-
-async function runMsgUtilsTests() {
-    test.pause();
-
-    await import('./isHexString.test.js');
-    await import('./normalizeHex.test.js');
-    test.resume();
-}
-
-runMsgUtilsTests();

package/tests/unit/utils/helpers/isHexString.test.js

@@ -1,12 +0,0 @@
-import test from 'brittle';
-import { isHexString } from '../../../../src/utils/helpers.js';
-
-test('isHexString', (t) => {
-    t.ok(isHexString('1234567890abcdef'), 'Valid hex string should return true with all lowercase characters');
-    t.ok(isHexString('1234567890ABCDEF'), 'Valid hex string should return true with all uppercase characters');
-    t.ok(isHexString('1234567890AbCdEf'), 'Valid hex string should return true with mixed case characters');
-    t.is(isHexString('0x1234567890abcdef'), false, '0x prefixed hex string should return false');
-    t.is(isHexString('1234567890xyz'), false, 'Invalid hex string should return false');
-    t.is(isHexString('123456789'), false, 'Invalid size hex string should return false');
-    t.is(isHexString(''), false, 'Empty string should return false');
-});

package/tests/unit/utils/helpers/normalizeHex.test.js

@@ -1,82 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-import { normalizeHex } from '../../../../src/utils/helpers.js';
-
-test('normalizeHex should convert hex string to buffer', t => {
-    const hexString = '1234abcd';
-    const result = normalizeHex(hexString);
-    t.ok(b4a.isBuffer(result), 'Result should be a buffer');
-    t.is(b4a.toString(result, 'hex'), hexString, 'Buffer should contain correct hex value');
-});
-
-test('normalizeHex should return buffer as is', t => {
-    const originalBuffer = b4a.from('1234abcd', 'hex');
-    const result = normalizeHex(originalBuffer);
-    t.is(result, originalBuffer, 'Should return the same buffer instance');
-    t.ok(b4a.isBuffer(result), 'Result should be a buffer');
-});
-
-test('normalizeHex should handle empty string', t => {
-    try {
-        normalizeHex('');
-        t.fail('Should throw on empty string');
-    } catch (err) {
-        t.pass('Throws on empty string');
-    }
-});
-
-test('normalizeHex should handle invalid hex string', t => {
-    try {
-        normalizeHex('invalid hex');
-        t.fail('Should throw on invalid hex string');
-    } catch (err) {
-        t.pass('Throws on invalid hex string');
-    }
-});
-
-test('normalizeHex should handle uppercase hex string', t => {
-    const hexString = '1234ABCD';
-    const result = normalizeHex(hexString);
-    t.ok(b4a.isBuffer(result), 'Result should be a buffer');
-    t.is(b4a.toString(result, 'hex'), hexString.toLowerCase(), 'Buffer should contain correct hex value');
-});
-
-test('normalizeHex should handle hex string with 0x prefix', t => {
-    const hexString = '0x1234abcd';
-    const result = normalizeHex(hexString.slice(2));
-    t.ok(b4a.isBuffer(result), 'Result should be a buffer');
-    t.is(b4a.toString(result, 'hex'), '1234abcd', 'Buffer should contain correct hex value without prefix');
-});
-
-
-test('normalizeHex should handle invalid data types', t => {
-    const invalidTypes = [
-        { value: 997, desc: 'number' },
-        { value: true, desc: 'boolean' },
-        { value: null, desc: 'null' },
-        { value: undefined, desc: 'undefined' },
-        { value: Infinity, desc: 'Infinity' },
-        { value: {}, desc: 'empty object' },
-        { value: [], desc: 'empty array' },
-        { value: () => { }, desc: 'function' },
-        { value: "invalid hex", desc: 'non-hex string' },
-        { value: BigInt(997), desc: 'BigInt' },
-        { value: new Date(), desc: 'Date object' },
-        { value: NaN, desc: 'NaN' },
-        { value: new Map(), desc: 'Map' },
-        { value: new Set(), desc: 'Set' },
-        { value: /abc/, desc: 'RegExp' },
-        { value: new Error('fail'), desc: 'Error' },
-        { value: Promise.resolve(), desc: 'Promise' },
-        { value: new Float32Array([1.1, 2.2]), desc: 'Float32Array' }
-    ];
-
-    for (const { value, desc } of invalidTypes) {
-        try {
-            normalizeHex(value);
-            t.fail(`Should throw on ${desc} input`);
-        } catch (err) {
-            t.pass(`Correctly throws on ${desc} input`);
-        }
-    }
-});

package/tests/unit/utils/migrationUtils/validateAddressFromIncomingFile.test.js

@@ -1,100 +0,0 @@
-import { test, hook } from 'brittle';
-import migrationUtils from '../../../../src/utils/migrationUtils.js';
-import { errorMessageIncludes } from "../../../helpers/regexHelper.js";
-import { ZERO_LICENSE } from '../../../../src/core/state/utils/nodeEntry.js';
-import b4a from 'b4a';
-import { config } from '../../../helpers/config.js';
-import { asAddress } from '../../../helpers/address.js';
-
-const VALID_ADDRESS = asAddress('6a38e14198866f0fdf4d4495b07e066cfd0a2e8cbe774d11af37d15f741ac984');
-const ADMIN_ADDRESS = asAddress('233aa0b7971509059e4816c782b32fec29b3797876bf92c072d1b0e058c5bf70');
-const INVALID_ADDRESS = 'notanaddress';
-const LICENSE_NUMBER_ONE = b4a.alloc(4, 1);
-
-const mockStateInstance = {
-    getNodeEntryUnsigned: async () => ({
-        isWhitelisted: false,
-        license: ZERO_LICENSE
-    }),
-    getAdminEntry: async () => ({
-        address: ADMIN_ADDRESS
-    })
-};
-
-const mockStateInstanceWhitelisted = {
-    getNodeEntryUnsigned: async () => ({
-        isWhitelisted: true,
-        license: ZERO_LICENSE
-    }),
-    getAdminEntry: async () => ({
-        address: ADMIN_ADDRESS
-    })
-};
-
-const mockStateInstanceBanned = {
-    getNodeEntryUnsigned: async () => ({
-        isWhitelisted: false,
-        license: LICENSE_NUMBER_ONE
-    }),
-    getAdminEntry: async () => ({
-        address: ADMIN_ADDRESS
-    })
-};
-
-test('validateAddressFromIncomingFile - valid address', async (t) => {
-    await migrationUtils.validateAddressFromIncomingFile(
-        mockStateInstance,
-        config,
-        VALID_ADDRESS,
-        { address: ADMIN_ADDRESS }
-    );
-    t.pass('Address validation succeeded as expected');
-});
-
-test('validateAddressFromIncomingFile - invalid address format', async (t) => {
-    await t.exception(
-        () => migrationUtils.validateAddressFromIncomingFile(
-            mockStateInstance,
-            config,
-            INVALID_ADDRESS,
-            { address: ADMIN_ADDRESS }
-        ),
-        errorMessageIncludes('Invalid address format')
-    );
-});
-
-test('validateAddressFromIncomingFile - admin address', async (t) => {
-    await t.exception(
-        () => migrationUtils.validateAddressFromIncomingFile(
-            mockStateInstance,
-            config,
-            ADMIN_ADDRESS,
-            { address: ADMIN_ADDRESS }
-        ),
-        errorMessageIncludes(`The admin address '${ADMIN_ADDRESS}' cannot be included in the current operation`)
-    );
-});
-
-test('validateAddressFromIncomingFile - whitelisted node', async (t) => {
-    await t.exception(
-        () => migrationUtils.validateAddressFromIncomingFile(
-            mockStateInstanceWhitelisted,
-            config,
-            VALID_ADDRESS,
-            { address: ADMIN_ADDRESS }
-        ),
-        errorMessageIncludes(`Whitelisted node address '${VALID_ADDRESS}' cannot be included in the current operation`)
-    );
-});
-
-test('validateAddressFromIncomingFile - banned/previously whitelisted address', async (t) => {
-    await t.exception(
-        () => migrationUtils.validateAddressFromIncomingFile(
-            mockStateInstanceBanned,
-            config,
-            VALID_ADDRESS,
-            { address: ADMIN_ADDRESS }
-        ),
-        errorMessageIncludes(`Address '${VALID_ADDRESS}' has been banned/whitelisted in the past`)
-    );
-});