@vbarbarosh/node-helpers 3.74.1 → 3.76.0

package/src/fs_file_md5.test.js

@@ -1,11 +0,0 @@
-const assert = require('assert');
-const fs_file_md5 = require('./fs_file_md5');
-const fs_path_resolve = require('./fs_path_resolve');
-
-describe('fs_file_md5', function () {
-    it('should calculate md5 fs_file_md5.js', async function () {
-        const actual = await fs_file_md5(fs_path_resolve(__dirname, 'fs_file_md5.js'));
-        const expected = '103bffdc1df3af79bfd3f4b8b1bd2ed7';
-        assert.strictEqual(actual, expected);
-    });
-});

package/src/fs_mkdirp.test.js

@@ -1,24 +0,0 @@
-const assert = require('assert');
-const fs_fi = require('./fs_fi');
-const fs_mkdirp = require('./fs_mkdirp');
-const fs_path_resolve = require('./fs_path_resolve');
-const fs_tempdir = require('./fs_tempdir');
-
-describe('fs_mkdirp', function () {
-    it('should accept empty array', async function () {
-        await fs_tempdir(async function (d) {
-            const tmp = fs_path_resolve(d, 'a/b/c/d/e');
-            await fs_mkdirp(tmp);
-            assert(await fs_fi(tmp).then(v => v.isDirectory()));
-        });
-    });
-    it('should create the same directory structure in parallel', async function () {
-        await fs_tempdir(async function (d) {
-            const tmp = fs_path_resolve(d, 'a/b/c/d/e/f/g/h');
-            await Promise.all(Array(10).fill(tmp).map(async function () {
-                await fs_mkdirp(tmp);
-                assert(await fs_fi(tmp).then(v => v.isDirectory()));
-            }));
-        });
-    });
-});

package/src/fs_path_extname.test.js

@@ -1,22 +0,0 @@
-const assert = require('assert');
-const fs_path_extname = require('./fs_path_extname');
-
-const tests = [
-    ['.', ''],
-    ['..', ''],
-    ['.foo', ''],
-    ['..foo', '.foo'],
-    ['.foo.bar', '.bar'],
-    ['fs_path_extname.js', '.js'],
-    ['/path/to/file.js', '.js'],
-    ['/path/to/file.js/foo', ''],
-];
-
-describe('fs_path_extname', function () {
-    tests.forEach(function ([input, expected]) {
-        it(`${input} -> ${expected}`, function () {
-            const actual = fs_path_extname(input);
-            assert.strictEqual(actual, expected);
-        });
-    });
-});

package/src/gettype.test.js

@@ -1,27 +0,0 @@
-const assert = require('assert');
-const const_type = require('./const_type');
-const gettype = require('./gettype');
-
-const items = [
-    ['null', null, const_type.null],
-    ['undefined', undefined, const_type.undefined],
-    ['boolean', true, const_type.boolean],
-    ['number', 1, const_type.number],
-    ['bigint', 1n, const_type.bigint],
-    ['nan', NaN, const_type.nan],
-    ['-inf', Number.NEGATIVE_INFINITY, const_type.neg_inf],
-    ['+inf', Number.POSITIVE_INFINITY, const_type.pos_inf],
-    ['string', 's', const_type.string],
-    ['symbol', Symbol(), const_type.symbol],
-    ['function', () => 1, const_type.function],
-    ['object', {}, const_type.object],
-    ['array', [], const_type.array],
-];
-
-describe('gettype', function () {
-    items.forEach(function ([title, input, expected]) {
-        it(title, function () {
-            assert.deepStrictEqual(gettype(input), expected);
-        });
-    });
-});

package/src/object_schema.test.js

@@ -1,15 +0,0 @@
-const assert = require('assert');
-const object_schema = require('./object_schema');
-
-describe('object_schema', function () {
-    it('basic 1', function () {
-        const actual = object_schema({aaa: 1, bbb: 2});
-        const expected = {aaa: 'number', bbb: 'number'};
-        assert.deepStrictEqual(actual, expected);
-    });
-    it('basic 2', function () {
-        const actual = object_schema({aaa: 1, bbb: [1, 2, 3, 4, 'str']});
-        const expected = {aaa: 'number', bbb: ['number', 'string']};
-        assert.deepStrictEqual(actual, expected);
-    });
-});

package/src/object_walk_preorder.test.js

@@ -1,17 +0,0 @@
-const assert = require('assert');
-const object_walk_preorder = require('./object_walk_preorder');
-
-describe('object_walk_preorder', function () {
-    it('basic 1', function () {
-        const actual = [];
-        const expected = ['aaa', 'bbb', 'ccc'];
-        object_walk_preorder({aaa: 1, bbb: 2, ccc: 3}, (v,p) => actual.push(p.join('/')));
-        assert.deepStrictEqual(actual, expected);
-    });
-    it('basic 2', function () {
-        const actual = [];
-        const expected = ['aaa', 'aaa/foo', 'aaa/foo/bar', 'aaa/foo/bar/baz', 'bbb', 'ccc'];
-        object_walk_preorder({aaa: {foo: {bar: {baz: 1}}}, bbb: 2, ccc: 3}, (v,p) => actual.push(p.join('/')));
-        assert.deepStrictEqual(actual, expected);
-    });
-});

package/src/parallel.test.js

@@ -1,11 +0,0 @@
-const assert = require('assert');
-const parallel = require('./parallel');
-
-describe('parallel', function () {
-    it('should reject when [spawn] is async function', function () {
-        assert.rejects(parallel({spawn: async function () {}}));
-    })
-    it('should reject when [spawn] is async generator', function () {
-        assert.rejects(parallel({spawn: async function* () {}}));
-    })
-});

package/src/parse_bytes.test.js

@@ -1,21 +0,0 @@
-const assert = require('assert');
-const parse_bytes = require('./parse_bytes');
-
-const items = [
-    ['', Number.NaN],
-    [null, Number.NaN],
-    [undefined, Number.NaN],
-    ['0KB', 0],
-    ['1KB', 1024],
-    ['2KB', 2048],
-    ['35.45MB', Math.floor(35.45*1024*1024)],
-    ['3.92GB', Math.floor(3.92*1024*1024*1024)],
-];
-
-describe('parse_bytes', function () {
-    items.forEach(function ([input, expected]) {
-        it(`${input} → ${expected}`, function () {
-            assert.strictEqual(expected, parse_bytes(input));
-        });
-    });
-});

package/src/parse_hms.test.js

@@ -1,32 +0,0 @@
-const assert = require('assert');
-const parse_hms = require('./parse_hms');
-
-const items = [
-    ['', 0],
-    [null, 0],
-    [undefined, 0],
-    ['0', 0],
-    ['0:5', 5],
-    ['00:05', 5],
-    ['0:15', 15],
-    ['0:15.123', 15.123],
-    ['0:75.123', 75.123],
-    ['   5', 5],
-    [' 0:05 ', 5],
-    [100, 100],
-    ['1:2:3:4', NaN, 'Too many segments'],
-    ['abc', NaN, 'Non-numeric'],
-    ['0:ab', NaN, 'Non-numeric'],
-    ['1:x:3', NaN, 'Non-numeric'],
-];
-
-describe('parse_hms', function () {
-    items.forEach(function ([input, expected, description]) {
-        const title = description
-            ? `${input} → ${expected} | ${description}`
-            : `${input} → ${expected}`;
-        it(title, function () {
-            assert.strictEqual(expected, parse_hms(input));
-        });
-    });
-});

package/src/parse_http_content_range.test.js

@@ -1,14 +0,0 @@
-const assert = require('assert');
-const parse_http_content_range = require('./parse_http_content_range');
-
-const items = [
-    ['bytes 262144000-272629759/5037662208', {type: 'bytes', first: 262144000, last: 272629759, total: 5037662208}],
-];
-
-describe('parse_http_content_range', function () {
-    items.forEach(function ([expr, expected]) {
-        it(expr, function () {
-            assert.deepStrictEqual(parse_http_content_range(expr), expected);
-        });
-    });
-});

package/src/pid_kill_grace.d/ignore-sigterm-for-10ms.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-
-const Promise = require('bluebird');
-const cli = require('../cli');
-const now_human = require('../now_human');
-
-// Child ignores SIGTERM for 10 ms, but dies naturally before the grace loop ends
-
-cli(main);
-
-async function main()
-{
-    let timer;
-
-    process.on('SIGTERM', function () {
-        console.log(`[${now_human()}][ignore-sigterm-for-10ms] SIGTERM_ignoring...`);
-        timer ??= setTimeout(terminate, 10);
-    });
-    process.on('SIGINT', function () {
-        console.log(`[${now_human()}][ignore-sigterm-for-10ms] SIGINT_ignoring...`);
-    });
-
-    for (let iter = 1, last = 100; iter <= last; ++iter) {
-        console.log(`[${now_human()}][ignore-sigterm-for-10ms] ${iter} of ${last}`);
-        await Promise.delay(10);
-    }
-}
-
-function terminate()
-{
-    console.log(`[${now_human()}][ignore-sigterm-for-10ms] TERMINATE_AFTER_10MS`);
-    process.exit(0);
-}

package/src/pid_kill_grace.d/ignore-sigterm.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-
-const Promise = require('bluebird');
-const cli = require('../cli');
-const now_human = require('../now_human');
-
-cli(main);
-
-async function main()
-{
-    process.on('SIGTERM', function () {
-        console.log(`[${now_human()}][ignore-sigterm] SIGTERM_ignoring...`);
-    });
-    process.on('SIGINT', function () {
-        console.log(`[${now_human()}][ignore-sigterm] SIGINT_ignoring...`);
-    });
-
-    for (let iter = 1, last = 100; iter <= last; ++iter) {
-        console.log(`[${now_human()}][ignore-sigterm] ${iter} of ${last}`);
-        await Promise.delay(10);
-    }
-}

package/src/pid_kill_grace.test.js

@@ -1,63 +0,0 @@
-const assert = require('assert');
-const pid_exists = require('./pid_exists');
-const pid_kill_grace = require('./pid_kill_grace');
-const shell_spawn = require('./shell_spawn');
-const stream = require('stream');
-const stream_each = require('./stream_each');
-const stream_lines = require('./stream_lines');
-const wait_while = require('./wait_while');
-
-describe('pid_kill_grace', function() {
-
-    it('happy path', async function () {
-        const proc = await shell_spawn(['sleep', '1m']).init();
-        assert(pid_exists(proc.pid));
-        await pid_kill_grace(proc.pid);
-        assert(!pid_exists(proc.pid));
-    });
-
-    // handling errors and edge cases
-
-    it('should throw "Failed to send SIGTERM to process 123"', async function () {
-        const pid = 999999; // 🎲 unlikely to exist
-        assert(!pid_exists(pid));
-        await assert.rejects(pid_kill_grace(pid), /Failed to send SIGTERM to process \d+:/);
-    });
-
-    it.skip('should throw "Process 123 survived SIGKILL"', async function () {
-        // How to implement this behavior?
-    });
-
-    it('should KILL process after grace period', async function () {
-        const logs = [];
-        const stdout = [];
-        const proc = shell_spawn([`${__dirname}/pid_kill_grace.d/ignore-sigterm.js`]);
-        const r = stream.promises.pipeline(proc.stdout, stream_lines(), stream_each(v => stdout.push(v)));
-        await wait_while(() => !stdout.length);
-        await Promise.all([
-            r,
-            pid_kill_grace(proc.pid, {grace_timeout_ms: 50, log: s => logs.push(s)})
-        ]);
-        assert(!pid_exists(proc.pid));
-        assert(stdout.some(v => v.includes('SIGTERM_ignoring')));
-        assert(logs.some(v => v.match(/Terminating process \d+: sending SIGTERM/)));
-        assert(logs.some(v => v.match(/SIGTERM grace period expired for process \d+; sending SIGKILL/)));
-    });
-
-    it('Child ignores SIGTERM for 10ms, but dies naturally before the grace loop ends', async function () {
-        const logs = [];
-        const stdout = [];
-        const proc = shell_spawn([`${__dirname}/pid_kill_grace.d/ignore-sigterm-for-10ms.js`]);
-        const r = stream.promises.pipeline(proc.stdout, stream_lines(), stream_each(v => stdout.push(v)));
-        await wait_while(() => !stdout.length);
-        await Promise.all([
-            r,
-            pid_kill_grace(proc.pid, {grace_timeout_ms: 50, log: s => logs.push(s)})
-        ]);
-        assert(!pid_exists(proc.pid));
-        assert(stdout.some(v => v.includes('SIGTERM_ignoring')));
-        assert(stdout.some(v => v.includes('TERMINATE_AFTER_10MS')));
-        assert(logs.some(v => v.match(/Terminating process \d+: sending SIGTERM/)));
-        assert(!logs.some(v => v.match(/SIGTERM grace period expired for process \d+; sending SIGKILL/)));
-    });
-});

package/src/ping_socket.test.js

@@ -1,58 +0,0 @@
-const Promise = require('bluebird');
-const assert = require('assert');
-const fs_rmf = require('./fs_rmf');
-const net = require('net');
-const ping_socket = require('./ping_socket');
-const random_hex = require('./random_hex');
-
-const socket = '/tmp/ping_socket_test.sock';
-
-describe('ping_socket', function () {
-
-    afterEach(async function () {
-        await fs_rmf(socket);
-    });
-
-    it('should receive exact string from server', async function () {
-        const uid = random_hex();
-        const server = net.createServer(client => client.resume().end(uid));
-        try {
-            await new Promise(resolve => server.listen(socket, resolve));
-            const buf = await ping_socket(socket);
-            assert.strictEqual(buf.toString(), uid);
-        }
-        finally {
-            await server_close(server);
-        }
-    });
-
-    it('should throw Socket Timeout', async function () {
-        const clients = [];
-        const server = net.createServer(client => clients.push(client));
-        try {
-            await new Promise(resolve => server.listen(socket, resolve));
-            await assert.rejects(ping_socket(socket, 'PING', 100), {message: 'Socket Timeout'});
-        }
-        finally {
-            clients.forEach(v => v.resume().end());
-            await server_close(server);
-        }
-    });
-
-    it('should throw ENOENT', async function () {
-        await assert.rejects(ping_socket(socket), {
-            code: 'ENOENT',
-            syscall: 'connect',
-            address: socket,
-        });
-    });
-});
-
-async function server_close(server)
-{
-    return new Promise(function (resolve, reject) {
-        server.close(function (error) {
-            error ? reject(error) : resolve();
-        });
-    });
-}

package/src/plural.test.js

@@ -1,20 +0,0 @@
-const assert = require('assert');
-const plural = require('./plural');
-
-const tests = [
-    ['1 apple', 1, '# apple', '# apples'],
-    ['2 apples', 2, '# apple', '# apples'],
-    ['10 apples', 10, '# apple', '# apples'],
-    ['21 apple', 21, '# apple', '# apples'],
-    ['0 apples', 0, '# apple', '# apples'],
-    ['No apples', 0, '# apple', '# apples', 'No apples'],
-];
-
-describe('plural', function () {
-    tests.forEach(function ([expected, ...args],) {
-        it(expected, function () {
-            const actual = plural(...args);
-            assert.deepStrictEqual(actual, expected);
-        });
-    });
-});

package/src/range.test.js

@@ -1,41 +0,0 @@
-const assert = require('assert');
-const range = require('./range');
-
-const cases = [
-    // 1-argument: (stop)
-    {args: [10], expected: [0,1,2,3,4,5,6,7,8,9]},
-    {args: [-10], expected: []}, // 💎 Consider non-standard semantics: range(-5) -> [0,-1,-2,-3,-4]
-
-    // 2-arguments: (start, stop)
-    {args: [3, 7], expected: [3,4,5,6]},
-    {args: [0, 0], expected: []},
-    {args: [5, 3], expected: []}, // positive direction, start > stop → empty
-
-    // 3-arguments: (start, stop, step)
-    {args: [3, 10, 2], expected: [3,5,7,9]},
-    {args: [3, 10, 3], expected: [3,6,9]},
-
-    // Negative step
-    {args: [10, 3, -2], expected: [10,8,6,4]},
-    {args: [10, 3, -3], expected: [10,7,4]},
-
-    // Negative step but no progression
-    {args: [3, 10, -1], expected: []}, // step direction does not match range
-
-    // Step = 1 edge
-    {args: [5, 5, 1], expected: []},
-    {args: [5, 6, 1], expected: [5]},
-
-    // Step = -1 edge
-    {args: [5, 5, -1], expected: []},
-    {args: [6, 5, -1], expected: [6]},
-];
-
-describe('range', function () {
-    cases.forEach(function (item, i) {
-        it(`range #${i+1}: ${JSON.stringify(item)}`, function () {
-            const actual = range(...item.args);
-            assert.deepStrictEqual(actual, item.expected);
-        })
-    });
-});

package/src/redis_lshift.test.js

@@ -1,57 +0,0 @@
-const assert = require('assert');
-const redis_lshift = require('./redis_lshift');
-
-const REDIS_HOST = '127.0.0.1';
-const REDIS_PORT = 6379;
-const REDIS_AUTH = null;
-const REDIS_QUEUE = 'TESTING';
-
-describe('redis_lshift', function () {
-    it('should work with redis@1', async function () {
-        await test_1_2_3(require('redis-v1'));
-    });
-    it('should work with redis@2', async function () {
-        await test_1_2_3(require('redis-v2'));
-    });
-    it('should work with redis@3', async function () {
-        await test_1_2_3(require('redis-v3'));
-    });
-    it('should work with redis@4', async function () {
-        await test_4(require('redis-v4'));
-    });
-});
-
-async function test_1_2_3(redis)
-{
-    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
-    try {
-        const expected = 'aa,bb,cc,dd,ee'.split(',');
-        await new Promise(function (resolve, reject) {
-            r.del(REDIS_QUEUE, (e,v) => e ? reject(e) : resolve(v));
-        });
-        await new Promise(function (resolve, reject) {
-            r.rpush(REDIS_QUEUE, ...expected, (e,v) => e ? reject(e) : resolve(v));
-        });
-        const actual = await redis_lshift(r, REDIS_QUEUE, expected.length);
-        await assert.deepStrictEqual(actual, expected);
-    }
-    finally {
-        await r.quit();
-    }
-}
-
-async function test_4(redis)
-{
-    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
-    await r.connect();
-    try {
-        const expected = 'aa,bb,cc,dd,ee'.split(',');
-        await r.DEL(REDIS_QUEUE);
-        await r.RPUSH(REDIS_QUEUE, expected);
-        const actual = await redis_lshift(r, REDIS_QUEUE, expected.length);
-        await assert.deepStrictEqual(actual, expected);
-    }
-    finally {
-        await r.quit();
-    }
-}

package/src/redis_zshift.test.js

@@ -1,58 +0,0 @@
-const assert = require('assert');
-const redis_zshift = require('./redis_zshift');
-
-const REDIS_HOST = '127.0.0.1';
-const REDIS_PORT = 6379;
-const REDIS_AUTH = null;
-const REDIS_QUEUE = 'TESTING';
-
-describe('redis_zshift', function () {
-    it('should work with redis@1', async function () {
-        await test_1_2_3(require('redis-v1'));
-    });
-    it('should work with redis@2', async function () {
-        await test_1_2_3(require('redis-v2'));
-    });
-    it('should work with redis@3', async function () {
-        await test_1_2_3(require('redis-v3'));
-    });
-    it('should work with redis@4', async function () {
-        await test_4(require('redis-v4'));
-    });
-});
-
-async function test_1_2_3(redis)
-{
-    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
-    try {
-        const expected = 'aa,bb,cc,dd,ee'.split(',');
-        await new Promise(function (resolve, reject) {
-            r.del(REDIS_QUEUE, (e,v) => e ? reject(e) : resolve(v));
-        });
-        await new Promise(function (resolve, reject) {
-            const args = [REDIS_QUEUE, ...expected.map((v,i) => [i,v]).flat()];
-            r.zadd(args, (e,v) => e ? reject(e) : resolve(v));
-        });
-        const actual = await redis_zshift(r, REDIS_QUEUE, expected.length);
-        await assert.deepStrictEqual(actual, expected);
-    }
-    finally {
-        await r.quit();
-    }
-}
-
-async function test_4(redis)
-{
-    const r = redis.createClient(REDIS_PORT, REDIS_HOST, {password: REDIS_AUTH || undefined});
-    await r.connect();
-    try {
-        const expected = 'aa,bb,cc,dd,ee'.split(',');
-        await r.DEL(REDIS_QUEUE);
-        await r.ZADD(REDIS_QUEUE, expected.map((value,i) => ({score: i, value})));
-        const actual = await redis_zshift(r, REDIS_QUEUE, 5);
-        await assert.deepStrictEqual(actual, expected);
-    }
-    finally {
-        await r.quit();
-    }
-}

package/src/round.test.js

@@ -1,56 +0,0 @@
-const assert = require('assert');
-const round = require('./round');
-
-const items = [
-    [34, 25, 25],
-    [37.5, 25, 50],
-    [34.037531, 0.001, 34.038],
-    [1.005, 0.01, 1.01],
-    [0.99999, 0.00001, 0.99999],
-
-    // Synthetic cases generated by DeepSeek
-    [1.005, 0.001, 1.005],        // More precise rounding
-    [1.005, 0.1, 1.0],            // Less precise rounding
-    [1.015, 0.01, 1.02],          // Another edge case with 5
-    [1.025, 0.01, 1.03],          // Yet another edge case
-    [0.5, 1, 1],                  // Round to nearest integer
-    [0.4, 1, 0],                  // Round down to integer
-    [123.456, 0.01, 123.46],      // Standard decimal rounding
-    [123.456, 0.1, 123.5],        // Different precision
-    [123.456, 1, 123],            // Round to whole number
-    [123.456, 10, 120],           // Round to tens
-    [123.456, 100, 100],          // Round to hundreds
-    [0, 0.01, 0],                 // Zero value
-    [-1.005, 0.01, -1.01],        // Negative numbers
-    [-1.015, 0.01, -1.02],        // Negative edge case
-    [-37.5, 25, -50],             // Negative with integer precision
-    [1.2345e-5, 1e-6, 0.000012],  // Very small numbers
-    [999.999, 0.001, 999.999],    // Rounding that causes carry-over
-    [0.0000000000001, 0.01, 0],   // Extremely small number
-    [Number.MAX_SAFE_INTEGER, 1000, 9007199254741000], // Large numbers
-
-    [0.005, 0.01, 0.01],
-    [-1.5, 1, -2],                          // Symmetric negative rounding (Math.abs is critical here)
-    [-0.5, 1, -1],                          // Symmetric negative rounding for half
-    [123456789123.45, 1000, 123456789000],  // Testing very large numbers
-    [1.2345e-20, 1e-20, 1e-20],             // Testing very small numbers
-    [1.0000000000000001, 0.0000000000000001, 1.0000000000000000], // Testing rounding near Number.EPSILON range
-
-    [9007199254740992, 1, 9007199254740992],
-    [9007199254740991.5, 1, 9007199254740992],
-    [Number.MIN_SAFE_INTEGER, 1, Number.MIN_SAFE_INTEGER],
-    [Number.MAX_SAFE_INTEGER, 1, Number.MAX_SAFE_INTEGER],
-
-    // Out of scope of standard JS
-    // [0.004999999999999999, 0.01, 0.0],
-    // [Number.MIN_SAFE_INTEGER, 0.1, Number.MIN_SAFE_INTEGER],
-    // [Number.MAX_SAFE_INTEGER, 0.1, Number.MAX_SAFE_INTEGER],
-];
-
-describe('round', function () {
-    items.forEach(function ([value, precision, expected],) {
-        it(`${value} [${precision}] → ${expected}`, function () {
-            assert.deepStrictEqual(round(value, precision), expected);
-        });
-    });
-});