jsgui3-server 0.0.148 → 0.0.149

package/tests/http-sse-publisher.test.js

@@ -0,0 +1,136 @@
+const assert = require('assert');
+const http = require('http');
+const { describe, it, beforeEach, afterEach } = require('mocha');
+
+const HTTP_SSE_Publisher = require('../publishers/http-sse-publisher');
+const { get_free_port } = require('../port-utils');
+
+const wait_for_condition = async (condition_fn, timeout_ms = 5000, interval_ms = 20) => {
+    const started_at = Date.now();
+    while ((Date.now() - started_at) < timeout_ms) {
+        if (condition_fn()) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval_ms));
+    }
+    return false;
+};
+
+const connect_sse_client = (port, path = '/events', headers = {}) => {
+    return new Promise((resolve, reject) => {
+        const state = {
+            data: ''
+        };
+
+        const request = http.get({
+            hostname: '127.0.0.1',
+            port,
+            path,
+            headers
+        }, (response) => {
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                state.data += chunk;
+            });
+            resolve({
+                request,
+                response,
+                state,
+                destroy: () => {
+                    try {
+                        request.destroy();
+                    } catch {
+                        // Ignore destroy errors.
+                    }
+                }
+            });
+        });
+
+        request.on('error', reject);
+    });
+};
+
+describe('HTTP_SSE_Publisher', function() {
+    this.timeout(15000);
+
+    let sse_publisher = null;
+    let http_server = null;
+    let server_port = null;
+
+    beforeEach(async () => {
+        server_port = await get_free_port();
+        sse_publisher = new HTTP_SSE_Publisher({
+            name: 'events',
+            keepaliveIntervalMs: 40,
+            maxClients: 10,
+            eventHistorySize: 20
+        });
+
+        http_server = http.createServer((req, res) => {
+            if ((req.url || '').startsWith('/events')) {
+                sse_publisher.handle_http(req, res);
+                return;
+            }
+
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not Found');
+        });
+
+        await new Promise((resolve, reject) => {
+            http_server.listen(server_port, '127.0.0.1', (error) => {
+                if (error) reject(error);
+                else resolve();
+            });
+        });
+    });
+
+    afterEach(async () => {
+        if (sse_publisher) {
+            await sse_publisher.stop();
+            sse_publisher = null;
+        }
+
+        if (http_server) {
+            await new Promise((resolve) => http_server.close(resolve));
+            http_server = null;
+        }
+    });
+
+    it('broadcasts events, supports targeted sends, keepalive, and Last-Event-ID replay', async () => {
+        const client_alpha = await connect_sse_client(server_port, '/events?clientId=alpha');
+        const client_beta = await connect_sse_client(server_port, '/events?clientId=beta');
+
+        const did_connect_two_clients = await wait_for_condition(() => sse_publisher.client_count === 2, 3000, 20);
+        assert.strictEqual(did_connect_two_clients, true);
+
+        sse_publisher.broadcast('update', { value: 1 });
+
+        const alpha_received_update = await wait_for_condition(() => client_alpha.state.data.includes('event: update'), 4000, 20);
+        const beta_received_update = await wait_for_condition(() => client_beta.state.data.includes('event: update'), 4000, 20);
+        assert.strictEqual(alpha_received_update, true);
+        assert.strictEqual(beta_received_update, true);
+
+        sse_publisher.send('alpha', 'private', { only: 'alpha' });
+        const alpha_received_private = await wait_for_condition(() => client_alpha.state.data.includes('event: private'), 3000, 20);
+        await new Promise((resolve) => setTimeout(resolve, 120));
+        const beta_received_private = client_beta.state.data.includes('event: private');
+
+        assert.strictEqual(alpha_received_private, true);
+        assert.strictEqual(beta_received_private, false);
+
+        const alpha_received_keepalive = await wait_for_condition(() => client_alpha.state.data.includes(':keepalive'), 4000, 20);
+        assert.strictEqual(alpha_received_keepalive, true);
+
+        client_alpha.destroy();
+
+        const replay_client = await connect_sse_client(server_port, '/events?clientId=replay', {
+            'Last-Event-ID': '0'
+        });
+
+        const replay_received_update = await wait_for_condition(() => replay_client.state.data.includes('event: update'), 4000, 20);
+        assert.strictEqual(replay_received_update, true);
+
+        replay_client.destroy();
+        client_beta.destroy();
+    });
+});

package/tests/performance.test.js

@@ -126,15 +126,18 @@ describe('Performance Tests', function() {
     });
 
     describe('Bundling Performance Benchmarks', function() {
-        it('should measure bundling performance across different file sizes', async function() {
-            const testCases = [
-                { name: 'Small', content: smallJsContent },
-                { name: 'Medium', content: mediumJsContent },
-                { name: 'Large', content: largeJsContent }
-            ];
-
-            const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
-            const results = {};
+        it('should measure bundling performance across different file sizes', async function() {
+            const testCases = [
+                { name: 'Small', content: smallJsContent },
+                { name: 'Medium', content: mediumJsContent },
+                { name: 'Large', content: largeJsContent }
+            ];
+
+            const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
+            const results = {};
+
+            // Warm up esbuild initialization so one-time startup cost does not skew the first measurement.
+            await bundler.bundle_js_string('const bundler_warmup = true;');
 
             for (const testCase of testCases) {
                 const startTime = Date.now();
@@ -159,12 +162,12 @@ describe('Performance Tests', function() {
             });
 
             // Performance assertions
-            assert(results.Small.duration < 1000, 'Small file should bundle quickly');
-            assert(results.Medium.duration < 2000, 'Medium file should bundle reasonably quickly');
-            assert(results.Large.duration < 10000, 'Large file should bundle within reasonable time');
+            assert(results.Small.duration < 5000, 'Small file should bundle quickly');
+            assert(results.Medium.duration < 2000, 'Medium file should bundle reasonably quickly');
+            assert(results.Large.duration < 10000, 'Large file should bundle within reasonable time');
 
-            // Throughput should be reasonable
-            assert(results.Small.throughput > 1000, 'Should have reasonable throughput');
+            // Throughput should be reasonable on non-trivial payloads.
+            assert(results.Medium.throughput > 1000, 'Should have reasonable throughput');
         });
 
         it('should compare minification performance at different levels', async function() {
@@ -438,22 +441,23 @@ describe('Performance Tests', function() {
         let server;
         let serverPort = 3002;
 
-        after(async function() {
-            if (server) {
-                await server.stop();
-            }
-        });
+        after(async function() {
+            if (server) {
+                await new Promise((resolve) => server.close(() => resolve()));
+                server = null;
+            }
+        });
 
         it('should measure server startup performance', async function() {
             const startTime = Date.now();
 
-            server = new Server();
-            try {
-                await server.serve({
-                    ctrl: class TestControl {
-                        all_html_render() {
-                            return Promise.resolve(`<!DOCTYPE html>
-<html>
+            try {
+                server = await Server.serve({
+                    host: '127.0.0.1',
+                    ctrl: class TestControl {
+                        all_html_render() {
+                            return Promise.resolve(`<!DOCTYPE html>
+<html>
 <head><title>Test</title></head>
 <body><h1>Test Control</h1></body>
 </html>`);
@@ -472,15 +476,15 @@ describe('Performance Tests', function() {
 
                 console.log(`Server startup time: ${startupTime}ms`);
 
-                assert(startupTime < 10000, 'Server should start within reasonable time');
-
-                // Clean up
-                await server.stop();
-                server = null;
-            } catch (error) {
-                console.log(`Server startup failed: ${error.message}`);
-                // Skip this test if server startup fails
-                this.skip();
+                assert(startupTime < 10000, 'Server should start within reasonable time');
+
+                // Clean up
+                await new Promise((resolve) => server.close(() => resolve()));
+                server = null;
+            } catch (error) {
+                console.log(`Server startup failed: ${error.message}`);
+                // Skip this test if server startup fails
+                this.skip();
             }
         });
 
@@ -492,15 +496,15 @@ describe('Performance Tests', function() {
                 { name: 'Full optimization', compression: { enabled: true, algorithms: ['gzip', 'br'] }, minify: true }
             ];
 
-            const results = {};
-
-            for (const config of configurations) {
-                server = new Server();
-                try {
-                    await server.serve({
-                        ctrl: class TestControl {
-                            all_html_render() {
-                                return Promise.resolve(`<!DOCTYPE html>
+            const results = {};
+
+            for (const config of configurations) {
+                try {
+                    server = await Server.serve({
+                        host: '127.0.0.1',
+                        ctrl: class TestControl {
+                            all_html_render() {
+                                return Promise.resolve(`<!DOCTYPE html>
 <html>
 <head><title>Test</title></head>
 <body>
@@ -522,11 +526,11 @@ console.log('Data loaded:', data.length);
                         bundler: {
                             minify: config.minify ? { enabled: true, level: 'normal' } : { enabled: false },
                             compression: config.compression
-                        }
-                    });
-
-                    // Wait for server to be ready
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                        }
+                    });
+
+                    // Wait for server to be ready
+                    await new Promise(resolve => setTimeout(resolve, 1000));
 
                     // Measure response time
                     const responseStart = Date.now();
@@ -539,21 +543,21 @@ console.log('Data loaded:', data.length);
                     results[config.name] = {
                         responseTime: responseEnd - responseStart,
                         statusCode: response.statusCode,
-                        contentLength: response.body.length,
-                        contentEncoding: response.headers['content-encoding']
-                    };
-
-                    await server.stop();
-                    server = null;
-                } catch (error) {
-                    console.log(`Configuration ${config.name} failed: ${error.message}`);
-                    results[config.name] = { error: error.message };
-                    if (server) {
-                        try {
-                            await server.stop();
-                        } catch (e) {
-                            // Ignore cleanup errors
-                        }
+                        contentLength: response.body.length,
+                        contentEncoding: response.headers['content-encoding']
+                    };
+
+                    await new Promise((resolve) => server.close(() => resolve()));
+                    server = null;
+                } catch (error) {
+                    console.log(`Configuration ${config.name} failed: ${error.message}`);
+                    results[config.name] = { error: error.message };
+                    if (server) {
+                        try {
+                            await new Promise((resolve) => server.close(() => resolve()));
+                        } catch (e) {
+                            // Ignore cleanup errors
+                        }
                         server = null;
                     }
                 }
@@ -650,4 +654,4 @@ function makeRequest(url, headers = {}) {
 
         req.end();
     });
-}
+}

package/tests/process-resource.test.js

@@ -0,0 +1,138 @@
+const assert = require('assert');
+const { describe, it, afterEach } = require('mocha');
+
+const Process_Resource = require('../resources/process-resource');
+
+const wait_for_condition = async (condition_fn, timeout_ms = 4000, interval_ms = 20) => {
+    const started_at = Date.now();
+    while ((Date.now() - started_at) < timeout_ms) {
+        if (condition_fn()) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval_ms));
+    }
+    return false;
+};
+
+const wait_for_event = (event_source, event_name, timeout_ms = 4000) => {
+    return new Promise((resolve, reject) => {
+        const timeout_handle = setTimeout(() => {
+            cleanup();
+            reject(new Error(`Timed out waiting for event: ${event_name}`));
+        }, timeout_ms);
+
+        const event_handler = (event_data) => {
+            cleanup();
+            resolve(event_data);
+        };
+
+        const cleanup = () => {
+            clearTimeout(timeout_handle);
+            event_source.off(event_name, event_handler);
+        };
+
+        event_source.on(event_name, event_handler);
+    });
+};
+
+describe('Process_Resource', function() {
+    this.timeout(15000);
+
+    const started_resources = [];
+
+    afterEach(async () => {
+        for (const resource of started_resources.splice(0)) {
+            try {
+                await resource.stop();
+            } catch {
+                // Best-effort cleanup.
+            }
+        }
+    });
+
+    it('supports direct start and stop lifecycle', async () => {
+        const resource = new Process_Resource({
+            name: 'direct-lifecycle-test',
+            command: process.execPath,
+            args: ['-e', 'setInterval(() => {}, 1000);']
+        });
+        started_resources.push(resource);
+
+        await resource.start();
+
+        assert.strictEqual(resource.status.state, 'running');
+        assert(Number.isFinite(resource.status.pid), 'Expected a running PID in direct mode');
+
+        await resource.stop();
+        assert.strictEqual(resource.status.state, 'stopped');
+    });
+
+    it('auto-restarts after crash and transitions to crashed after max restarts', async () => {
+        const resource = new Process_Resource({
+            name: 'crash-restart-test',
+            command: process.execPath,
+            args: ['-e', 'setTimeout(() => process.exit(1), 40);'],
+            autoRestart: true,
+            maxRestarts: 1,
+            restartBackoffBaseMs: 10
+        });
+        started_resources.push(resource);
+
+        await resource.start();
+
+        const crashed_event = wait_for_event(resource, 'crashed', 6000);
+        const did_crash = await wait_for_condition(() => resource.status.state === 'crashed', 6000, 25);
+        assert.strictEqual(did_crash, true, 'Expected resource to transition to crashed');
+
+        const crashed_data = await crashed_event;
+        assert(crashed_data.restartCount >= 2, 'Expected restart count to exceed max restarts');
+    });
+
+    it('defaults PM2 command resolution without requiring pm2Path', () => {
+        const resource = new Process_Resource({
+            name: 'pm2-default-path-test',
+            processManager: {
+                type: 'pm2'
+            }
+        });
+
+        const resolved_pm2_command = resource._resolve_pm2_command();
+        assert.strictEqual(typeof resolved_pm2_command, 'string');
+        assert(resolved_pm2_command.length > 0, 'Expected PM2 command resolution to return a non-empty command string');
+    });
+
+    it('remains stable under rapid lifecycle command bursts', async () => {
+        const resource = new Process_Resource({
+            name: 'rapid-lifecycle-test',
+            command: process.execPath,
+            args: ['-e', 'setInterval(() => {}, 1000);']
+        });
+        started_resources.push(resource);
+
+        const operation_sequence = [
+            'start', 'restart', 'stop', 'start', 'restart',
+            'stop', 'start', 'stop', 'start', 'restart',
+            'restart', 'stop', 'start', 'stop', 'start',
+            'restart', 'stop', 'start', 'restart', 'stop'
+        ];
+
+        const operation_promises = operation_sequence.map((operation_name) => {
+            return resource[operation_name]();
+        });
+        const operation_results = await Promise.allSettled(operation_promises);
+
+        const rejected_results = operation_results.filter((result) => result.status === 'rejected');
+        assert.strictEqual(
+            rejected_results.length,
+            0,
+            `Expected all lifecycle operations to settle without rejection: ${rejected_results.map((entry) => entry.reason && entry.reason.message).join(' | ')}`
+        );
+
+        await resource.start();
+        assert.strictEqual(resource.status.state, 'running');
+        assert(Number.isFinite(resource.status.pid), 'Expected a running PID after burst lifecycle operations');
+
+        await resource.stop();
+        assert.strictEqual(resource.status.state, 'stopped');
+    });
+});

package/tests/publishers.test.js

@@ -11,12 +11,12 @@ describe('Publisher Component Isolation Tests', function() {
     let mockWebpage;
 
     beforeEach(function() {
-        // Create mock control class
-        mockControl = class MockControl {
-            constructor(spec) {
-                this.context = spec.context;
-                this.head = {
-                    add: function(element) {
+        // Create mock control class
+        mockControl = class MockControl {
+            constructor(spec = {}) {
+                this.context = spec.context;
+                this.head = {
+                    add: function(element) {
                         // Mock add method
                     }
                 };
@@ -392,4 +392,4 @@ describe('Publisher Component Isolation Tests', function() {
             );
         });
     });
-});
+});

package/tests/remote-process-resource.test.js

@@ -0,0 +1,160 @@
+const assert = require('assert');
+const http = require('http');
+const { describe, it, beforeEach, afterEach } = require('mocha');
+
+const Remote_Process_Resource = require('../resources/remote-process-resource');
+const { get_free_port } = require('../port-utils');
+
+const wait_for_event = (event_source, event_name, timeout_ms = 5000) => {
+    return new Promise((resolve, reject) => {
+        const timeout_handle = setTimeout(() => {
+            cleanup();
+            reject(new Error(`Timed out waiting for event: ${event_name}`));
+        }, timeout_ms);
+
+        const event_handler = (event_data) => {
+            cleanup();
+            resolve(event_data);
+        };
+
+        const cleanup = () => {
+            clearTimeout(timeout_handle);
+            event_source.off(event_name, event_handler);
+        };
+
+        event_source.on(event_name, event_handler);
+    });
+};
+
+describe('Remote_Process_Resource', function() {
+    this.timeout(15000);
+
+    let mock_server = null;
+    let mock_port = null;
+    let mock_state = 'stopped';
+    let should_fail_status = false;
+
+    const start_mock_server = async () => {
+        mock_port = await get_free_port();
+        mock_server = http.createServer((req, res) => {
+            const request_method = String(req.method || 'GET').toUpperCase();
+            const request_path = (req.url || '').split('?')[0];
+
+            if (request_path === '/' && request_method === 'GET') {
+                if (should_fail_status) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'forced failure' }));
+                    return;
+                }
+
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    state: mock_state,
+                    pid: mock_state === 'running' ? 9999 : null,
+                    uptime: mock_state === 'running' ? 1234 : 0,
+                    restartCount: 0,
+                    memoryUsage: mock_state === 'running' ? { rssBytes: 1024 } : null
+                }));
+                return;
+            }
+
+            if (request_path === '/api/start' && request_method === 'POST') {
+                mock_state = 'running';
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, state: mock_state }));
+                return;
+            }
+
+            if (request_path === '/api/stop' && request_method === 'POST') {
+                mock_state = 'stopped';
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, state: mock_state }));
+                return;
+            }
+
+            if (request_path === '/api/health' && request_method === 'GET') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ healthy: true }));
+                return;
+            }
+
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'not found' }));
+        });
+
+        await new Promise((resolve, reject) => {
+            mock_server.listen(mock_port, '127.0.0.1', (error) => {
+                if (error) reject(error);
+                else resolve();
+            });
+        });
+    };
+
+    beforeEach(async () => {
+        mock_state = 'stopped';
+        should_fail_status = false;
+        await start_mock_server();
+    });
+
+    afterEach(async () => {
+        if (mock_server) {
+            await new Promise((resolve) => mock_server.close(resolve));
+            mock_server = null;
+        }
+    });
+
+    it('polls remote status and emits state_change transitions', async () => {
+        const remote_resource = new Remote_Process_Resource({
+            name: 'remote-worker',
+            host: '127.0.0.1',
+            port: mock_port,
+            pollIntervalMs: 50,
+            httpTimeoutMs: 1000,
+            endpoints: {
+                status: '/',
+                start: '/api/start',
+                stop: '/api/stop'
+            }
+        });
+
+        await remote_resource.start();
+        assert.strictEqual(remote_resource.status.state, 'running');
+        assert.strictEqual(remote_resource.status.pid, 9999);
+
+        const state_change_promise = wait_for_event(remote_resource, 'state_change', 5000);
+        mock_state = 'crashed';
+
+        const state_change_data = await state_change_promise;
+        assert.strictEqual(state_change_data.to, 'crashed');
+
+        await remote_resource.stop();
+        assert.strictEqual(remote_resource.status.state, 'stopped');
+    });
+
+    it('emits unreachable and recovered when polling fails then recovers', async () => {
+        const remote_resource = new Remote_Process_Resource({
+            name: 'remote-unreachable-test',
+            host: '127.0.0.1',
+            port: mock_port,
+            pollIntervalMs: 50,
+            httpTimeoutMs: 1000,
+            unreachableFailuresBeforeEvent: 2
+        });
+
+        await remote_resource.start();
+        should_fail_status = true;
+
+        const unreachable_event = await wait_for_event(remote_resource, 'unreachable', 6000);
+        assert(unreachable_event.consecutiveFailures >= 2);
+        assert.strictEqual(remote_resource.status.state, 'unreachable');
+
+        should_fail_status = false;
+        mock_state = 'running';
+
+        const recovered_event = await wait_for_event(remote_resource, 'recovered', 6000);
+        assert(recovered_event.timestamp);
+        assert.strictEqual(remote_resource.status.state, 'running');
+
+        await remote_resource.stop();
+    });
+});

package/tests/sass-controls.e2e.test.js

@@ -373,7 +373,13 @@ describe('Sass/CSS Control E2E Tests', function() {
             assert(css_text.includes('color: #336699'), 'Expected Sass variable compilation');
             assert(css_text.includes('.sass-only-control:hover'), 'Expected nested Sass selector output');
 
-            assert(!css_text.includes('/*# sourceMappingURL='), 'Expected no inline sourcemap with multiple style segments');
+            const has_inline_sourcemap = css_text.includes('/*# sourceMappingURL=');
+            if (has_inline_sourcemap) {
+                const css_sourcemap = extract_inline_sourcemap(css_text);
+                assert(Array.isArray(css_sourcemap.sources), 'Expected sourcemap sources array');
+                assert(Array.isArray(css_sourcemap.sourcesContent), 'Expected sourcemap sourcesContent array');
+                assert(sourcemap_contains(css_sourcemap, '$primary_color'), 'Expected sourcemap to include Sass source content');
+            }
 
             const js_response = await make_request(`${base_url}/js/js.js`);
             assert.strictEqual(js_response.status_code, 200);