@vbarbarosh/node-helpers 3.75.0 → 3.76.1

package/src/format_ms3.test.js

@@ -1,33 +0,0 @@
-const assert = require('assert');
-const format_ms3 = require('./format_ms3');
-const msval = require('./msval');
-
-const items = [
-    ['00:00.000', ''],
-    ['00:00.000', null],
-    ['00:00.000', undefined],
-    ['00:00.000', msval(0, 0, 0, 0)],
-    ['00:00.001', msval(0, 0, 0, 1)],
-    ['00:00.900', msval(0, 0, 0, 900)],
-    ['00:01.000', msval(0, 0, 1, 0)],
-    ['00:01.500', msval(0, 0, 1, 500)],
-    ['00:02.000', msval(0, 0, 2, 0)],
-    ['00:05.445', msval(0, 0, 5, 445)],
-    ['01:00.000', msval(0, 1, 0, 0)],
-    ['12:00.000', msval(0, 12, 0, 0)],
-    ['12:12.012', msval(0, 12, 12, 12)],
-    ['01:00:00.000', msval(1, 0, 0, 0)],
-    ['01:01:00.000', msval(1, 1, 0, 0)],
-    ['01:01:01.000', msval(1, 1, 1, 0)],
-    ['01:01:01.001', msval(1, 1, 1, 1)],
-    ['12:12:12.012', msval(12, 12, 12, 12)],
-    ['999:00:00.000', msval(999, 0, 0, 0)],
-];
-
-describe('format_ms3', function () {
-    items.forEach(function ([expected, input]) {
-        it(`${input} → ${expected}`, function () {
-            assert.strictEqual(format_ms3(input), expected);
-        });
-    });
-});

package/src/format_percents.test.js

@@ -1,22 +0,0 @@
-const assert = require('assert');
-const format_percents = require('./format_percents');
-
-const items = [
-    ['', '0%'],
-    [0, '0%'],
-    [0.01, '1.00%'],
-    [0.0101, '1.01%'],
-    [0.1, '10.00%'],
-    [0.5, '50.00%'],
-    [0.99, '99.00%'],
-    [0.9901, '99.01%'],
-    [1, '100%'],
-];
-
-describe('format_percents', function () {
-    items.forEach(function ([input, expected]) {
-        it(`${input} → ${expected}`, function () {
-            assert.strictEqual(format_percents(input), expected);
-        });
-    });
-});

package/src/format_progress_bytes.test.js

@@ -1,19 +0,0 @@
-const assert = require('assert');
-const format_progress_bytes = require('./format_progress_bytes');
-
-const items = [
-    ['~', {percents: 0, total: 0, done: 0, rate: 0, eta: 0, duration: 0}],
-    ['~ duration=00:00:01', {percents: 0, total: 0, done: 0, rate: 0, eta: 0, duration: 1}],
-    ['25.25% | 5.0MB of 15.0MB at ~ ETA ~ duration=00:00:01', {percents: 0.2525, total: 15*1024*1024, done: 5*1024*1024, rate: 0, eta: 0, duration: 1}],
-    ['25.25% | 5.0MB of 15.0MB at 10.0MB/s ETA 00:00:05 duration=00:00:01', {percents: 0.2525, total: 15*1024*1024, done: 5*1024*1024, rate: 10*1024*1024, eta: 5, duration: 1}],
-    // edge case: done > total
-    ['15.0MB at 10.0MB/s duration=00:00:01', {percents: 5.2525, total: 5*1024*1024, done: 15*1024*1024, rate: 10*1024*1024, eta: 5, duration: 1}],
-];
-
-describe('format_progress_bytes', function () {
-    items.forEach(function ([expected, input]) {
-        it(expected, function () {
-            assert.strictEqual(format_progress_bytes(input), expected);
-        });
-    });
-});

package/src/format_progress_kilo.test.js

@@ -1,19 +0,0 @@
-const assert = require('assert');
-const format_progress_kilo = require('./format_progress_kilo');
-
-const items = [
-    ['~', {percents: 0, total: 0, done: 0, rate: 0, eta: 0, duration: 0}],
-    ['~ duration=00:00:01', {percents: 0, total: 0, done: 0, rate: 0, eta: 0, duration: 1}],
-    ['25.25% | 5.00M of 15.00M at ~ ETA ~ duration=00:00:01', {percents: 0.2525, total: 15*1000*1000, done: 5*1000*1000, rate: 0, eta: 0, duration: 1}],
-    ['25.25% | 5.00M of 15.00M at 10.00M/s ETA 00:00:05 duration=00:00:01', {percents: 0.2525, total: 15*1000*1000, done: 5*1000*1000, rate: 10*1000*1000, eta: 5, duration: 1}],
-    // edge case: done > total
-    ['15.00M at 10.00M/s duration=00:00:01', {percents: 5.2525, total: 5*1000*1000, done: 15*1000*1000, rate: 10*1000*1000, eta: 5, duration: 1}],
-];
-
-describe('format_progress_kilo', function () {
-    items.forEach(function ([expected, input]) {
-        it(expected, function () {
-            assert.strictEqual(format_progress_kilo(input), expected);
-        });
-    });
-});

package/src/format_seconds.test.js

@@ -1,42 +0,0 @@
-const assert = require('assert');
-const format_seconds = require('./format_seconds');
-
-const items = [
-    ['-00:00:01', -1],
-    ['-00:00:10', -10],
-    ['-00:01:40', -100],
-    ['-00:16:40', -1000],
-    ['-02:46:40', -10000],
-    ['-27:46:40', -100000],
-    ['-277:46:40', -1000000],
-    ['00:00:00', 0],
-    ['00:00:00', 0.1],
-    ['00:00:00', 0.12345],
-    ['00:00:00', 0.5],
-    ['00:00:00', 0.6],
-    ['00:00:00', 0.9],
-    ['00:00:00', 0.99],
-    ['00:00:00', 0.999],
-    ['00:00:00', -0.1],
-    ['00:00:00', -0.12345],
-    ['00:00:00', -0.5],
-    ['00:00:00', -0.6],
-    ['00:00:00', -0.9],
-    ['00:00:00', -0.99],
-    ['00:00:00', -0.999],
-    ['00:00:01', 1],
-    ['00:00:10', 10],
-    ['00:01:40', 100],
-    ['00:16:40', 1000],
-    ['02:46:40', 10000],
-    ['27:46:40', 100000],
-    ['277:46:40', 1000000],
-];
-
-describe('format_seconds', function () {
-    items.forEach(function ([expected, ...args]) {
-        it(`${args} → ${expected}`, function () {
-            assert.strictEqual(format_seconds(...args), expected);
-        });
-    });
-});

package/src/format_thousands.test.js

@@ -1,28 +0,0 @@
-const assert = require('assert');
-const format_thousands = require('./format_thousands');
-
-const items = [
-    ['-1', -1],
-    ['-100', -100],
-    ['-1,000', -1000],
-    ['-10,000', -10000],
-    ['-100,000', -100000],
-    ['-1,000,000', -1000000],
-    ['1', 1],
-    ['100', 100],
-    ['1,000', 1000],
-    ['10,000', 10000],
-    ['100,000', 100000],
-    ['1,000,000', 1000000],
-    ['1.55', 1.55],
-    ['1.1234512345', 1.1234512345],
-    ['123,456,789.01234', 123456789.01234],
-];
-
-describe('format_thousands', function () {
-    items.forEach(function ([expected, ...args]) {
-        it(`${args} → ${expected}`, function () {
-            assert.strictEqual(format_thousands(...args), expected);
-        });
-    });
-});

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);
-        })
-    });
-});