npm - jsgui3-server - Versions diffs - 0.0.147 → 0.0.149 - Mend

jsgui3-server 0.0.147 → 0.0.149

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (145) hide show

package/tests/serve-resources.test.js ADDED Viewed

@@ -0,0 +1,270 @@
+const assert = require('assert');
+const http = require('http');
+const { describe, it, afterEach, after } = require('mocha');
+const EventEmitter = require('events');
+const { Resource } = require('jsgui3-html');
+const fake_webpage_publisher_path = require.resolve('../publishers/http-webpage-publisher');
+const fake_website_publisher_path = require.resolve('../publishers/http-website-publisher');
+const original_webpage_publisher_module = require.cache[fake_webpage_publisher_path];
+const original_website_publisher_module = require.cache[fake_website_publisher_path];
+class Fake_Publisher_Base extends EventEmitter {
+    constructor(html_route, html_body) {
+        super();
+        const body_buffer = Buffer.from(html_body, 'utf8');
+        this.route = html_route;
+        this.response_headers = {
+            identity: {
+                'Content-Type': 'text/html; charset=utf-8',
+                'Content-Length': body_buffer.length
+            }
+        };
+        this.response_buffers = {
+            identity: body_buffer
+        };
+        this.type = 'html';
+        this.extension = 'html';
+        setImmediate(() => {
+            this.emit('ready', {
+                _arr: [{
+                    type: this.type,
+                    extension: this.extension,
+                    route: this.route,
+                    response_headers: this.response_headers,
+                    response_buffers: this.response_buffers
+                }]
+            });
+        });
+    }
+    handle_http(req, res) {
+        const body_buffer = this.response_buffers.identity;
+        res.writeHead(200, this.response_headers.identity);
+        res.end(body_buffer);
+    }
+    meets_requirements() {
+        return true;
+    }
+    start(callback) {
+        if (typeof callback === 'function') {
+            callback(null, true);
+        }
+        return Promise.resolve(true);
+    }
+    stop(callback) {
+        if (typeof callback === 'function') {
+            callback(null, true);
+        }
+        return Promise.resolve(true);
+    }
+}
+class Fake_Webpage_Publisher extends Fake_Publisher_Base {
+    constructor(options = {}) {
+        const webpage = options.webpage || {};
+        const route = webpage.path || '/';
+        const title = webpage.title || webpage.name || 'Fake Page';
+        const html_body = `<html><head><title>${title}</title></head><body>${route}</body></html>`;
+        super(route, html_body);
+    }
+}
+class Fake_Website_Publisher extends Fake_Publisher_Base {
+    constructor(options = {}) {
+        const title = (options.website && options.website.name) || 'Fake Site';
+        const html_body = `<html><head><title>${title}</title></head><body>site</body></html>`;
+        super('/*', html_body);
+    }
+}
+require.cache[fake_webpage_publisher_path] = { exports: Fake_Webpage_Publisher };
+require.cache[fake_website_publisher_path] = { exports: Fake_Website_Publisher };
+const Server = require('../server');
+const { get_free_port } = require('../port-utils');
+class In_Process_Test_Resource extends Resource {
+    constructor(spec = {}) {
+        super(spec);
+        this.current_state = 'stopped';
+        this.start_calls = 0;
+        this.stop_calls = 0;
+    }
+    start(callback) {
+        this.start_calls += 1;
+        const previous_state = this.current_state;
+        this.current_state = 'running';
+        this.raise('state_change', {
+            from: previous_state,
+            to: this.current_state,
+            timestamp: Date.now()
+        });
+        if (typeof callback === 'function') callback(null, true);
+        return Promise.resolve(true);
+    }
+    stop(callback) {
+        this.stop_calls += 1;
+        const previous_state = this.current_state;
+        this.current_state = 'stopped';
+        this.raise('state_change', {
+            from: previous_state,
+            to: this.current_state,
+            timestamp: Date.now()
+        });
+        if (typeof callback === 'function') callback(null, true);
+        return Promise.resolve(true);
+    }
+    get status() {
+        return {
+            state: this.current_state
+        };
+    }
+    get_abstract() {
+        return {
+            name: this.name,
+            state: this.current_state
+        };
+    }
+}
+const get_http_response = (port, path_name) => {
+    return new Promise((resolve, reject) => {
+        const request = http.get({
+            hostname: '127.0.0.1',
+            port,
+            path: path_name
+        }, (response) => {
+            let body_text = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                body_text += chunk;
+            });
+            response.on('end', () => {
+                resolve({
+                    response,
+                    body_text
+                });
+            });
+        });
+        request.on('error', reject);
+    });
+};
+describe('Server.serve resources integration', function() {
+    this.timeout(20000);
+    const started_servers = [];
+    after(() => {
+        if (original_webpage_publisher_module) {
+            require.cache[fake_webpage_publisher_path] = original_webpage_publisher_module;
+        } else {
+            delete require.cache[fake_webpage_publisher_path];
+        }
+        if (original_website_publisher_module) {
+            require.cache[fake_website_publisher_path] = original_website_publisher_module;
+        } else {
+            delete require.cache[fake_website_publisher_path];
+        }
+        delete require.cache[require.resolve('../server')];
+    });
+    afterEach(async () => {
+        while (started_servers.length > 0) {
+            const server_instance = started_servers.pop();
+            await new Promise((resolve) => {
+                server_instance.close(() => resolve());
+            });
+        }
+    });
+    it('supports in-process resource instances and stops them on server close', async () => {
+        const port = await get_free_port();
+        const in_process_resource = new In_Process_Test_Resource({
+            name: 'in_process_resource'
+        });
+        const server_instance = await Server.serve({
+            host: '127.0.0.1',
+            port,
+            api: {
+                ping: () => 'pong'
+            },
+            resources: {
+                in_process_resource
+            }
+        });
+        started_servers.push(server_instance);
+        assert.strictEqual(in_process_resource.start_calls, 1);
+        assert.strictEqual(in_process_resource.status.state, 'running');
+        const { response, body_text } = await get_http_response(port, '/api/ping');
+        assert.strictEqual(response.statusCode, 200);
+        assert.strictEqual(body_text, 'pong');
+        await new Promise((resolve) => server_instance.close(() => resolve()));
+        started_servers.pop();
+        assert.strictEqual(in_process_resource.stop_calls >= 1, true);
+        assert.strictEqual(in_process_resource.status.state, 'stopped');
+    });
+    it('supports direct process resources with consistent status API', async () => {
+        const port = await get_free_port();
+        let server_instance = null;
+        server_instance = await Server.serve({
+            host: '127.0.0.1',
+            port,
+            api: {
+                process_status: () => {
+                    const process_resource = server_instance.resource_pool.get_resource('worker_process');
+                    return process_resource ? process_resource.status : null;
+                }
+            },
+            resources: {
+                worker_process: {
+                    type: 'process',
+                    command: process.execPath,
+                    args: ['-e', 'setInterval(() => {}, 1000);']
+                }
+            }
+        });
+        started_servers.push(server_instance);
+        const process_resource = server_instance.resource_pool.get_resource('worker_process');
+        assert(process_resource, 'Expected worker_process resource in the pool');
+        const process_status = process_resource.status;
+        assert.strictEqual(process_status.state, 'running');
+        assert.strictEqual(typeof process_status.processManager.type, 'string');
+        assert.strictEqual(process_status.processManager.type, 'direct');
+        assert(Number.isFinite(process_status.pid), 'Expected running process PID');
+        const { response, body_text } = await get_http_response(port, '/api/process_status');
+        assert.strictEqual(response.statusCode, 200);
+        const parsed_status = JSON.parse(body_text);
+        assert.strictEqual(parsed_status.state, 'running');
+        assert.strictEqual(typeof parsed_status.restartCount, 'number');
+        assert('memoryUsage' in parsed_status);
+        assert('lastHealthCheck' in parsed_status);
+        await new Promise((resolve) => server_instance.close(() => resolve()));
+        started_servers.pop();
+        assert.strictEqual(process_resource.status.state, 'stopped');
+    });
+});

package/tests/serve.test.js CHANGED Viewed

@@ -6,12 +6,14 @@ const EventEmitter = require('events');
 const dummy_client_path = require.resolve('./dummy-client.js');
-const fake_webpage_publisher_path = require.resolve('../publishers/http-webpage-publisher');
-const fake_website_publisher_path = require.resolve('../publishers/http-website-publisher');
+const fake_webpage_publisher_path = require.resolve('../publishers/http-webpage-publisher');
+const fake_website_publisher_path = require.resolve('../publishers/http-website-publisher');
+const original_webpage_publisher_module = require.cache[fake_webpage_publisher_path];
+const original_website_publisher_module = require.cache[fake_website_publisher_path];
-class Fake_Publisher_Base extends EventEmitter {
-    constructor(html_route, html_body) {
-        super();
+class Fake_Publisher_Base extends EventEmitter {
+    constructor(html_route, html_body) {
+        super();
         this.html_route = html_route;
         this.html_body = html_body;
         const buffer = Buffer.from(this.html_body, 'utf8');
@@ -40,27 +42,48 @@ class Fake_Publisher_Base extends EventEmitter {
         };
         this.type = 'html';
         this.extension = 'html';
-        setImmediate(() => {
-            this.emit('ready', {
-                _arr: [{
-                    type: this.type,
-                    extension: this.extension,
-                    route: this.route,
-                    response_headers: this.response_headers,
-                    response_buffers: this.response_buffers
-                }]
-            });
-        });
-    }
+        const ready_delay_ms = Number(this.constructor.ready_delay_ms) || 0;
+        const emit_ready = () => {
+            this.emit('ready', {
+                _arr: [{
+                    type: this.type,
+                    extension: this.extension,
+                    route: this.route,
+                    response_headers: this.response_headers,
+                    response_buffers: this.response_buffers
+                }]
+            });
+        };
+        if (ready_delay_ms > 0) {
+            setTimeout(emit_ready, ready_delay_ms);
+        } else {
+            setImmediate(emit_ready);
+        }
+    }
-    handle_http(req, res) {
-        res.writeHead(200, {
-            'Content-Type': 'text/html; charset=utf-8',
-            'Content-Length': Buffer.byteLength(this.html_body, 'utf8')
-        });
-        res.end(this.html_body);
-    }
-}
+    handle_http(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Content-Length': Buffer.byteLength(this.html_body, 'utf8')
+        });
+        res.end(this.html_body);
+    }
+    meets_requirements() {
+        return true;
+    }
+    start(callback) {
+        if (typeof callback === 'function') callback(null, true);
+        return Promise.resolve(true);
+    }
+    stop(callback) {
+        if (typeof callback === 'function') callback(null, true);
+        return Promise.resolve(true);
+    }
+}
 class Fake_Webpage_Publisher extends Fake_Publisher_Base {
     constructor(opts = {}) {
@@ -72,14 +95,17 @@ class Fake_Webpage_Publisher extends Fake_Publisher_Base {
     }
 }
-class Fake_Website_Publisher extends Fake_Publisher_Base {
+class Fake_Website_Publisher extends Fake_Publisher_Base {
     constructor(opts = {}) {
         const route = '/*';
         const title = (opts.website && opts.website.name) || 'Test Website';
         const body = `<html><head><title>${title}</title></head><body><div class="dummy-control">website</div></body></html>`;
         super(route, body);
     }
-}
+}
+Fake_Webpage_Publisher.ready_delay_ms = 0;
+Fake_Website_Publisher.ready_delay_ms = 0;
 require.cache[fake_webpage_publisher_path] = { exports: Fake_Webpage_Publisher };
 require.cache[fake_website_publisher_path] = { exports: Fake_Website_Publisher };
@@ -120,16 +146,35 @@ const get_http_response = (port, route_path = '/') => new Promise((resolve, reje
     req.on('error', reject);
 });
-describe('Server.serve', function() {
-    this.timeout(10000);
-    let server_instance;
-    afterEach(async () => {
-        if (server_instance) {
-            await new Promise(resolve => server_instance.close(resolve));
-            server_instance = null;
-        }
-    });
+describe('Server.serve', function() {
+    this.timeout(10000);
+    let server_instance;
+    after(() => {
+        if (original_webpage_publisher_module) {
+            require.cache[fake_webpage_publisher_path] = original_webpage_publisher_module;
+        } else {
+            delete require.cache[fake_webpage_publisher_path];
+        }
+        if (original_website_publisher_module) {
+            require.cache[fake_website_publisher_path] = original_website_publisher_module;
+        } else {
+            delete require.cache[fake_website_publisher_path];
+        }
+        delete require.cache[require.resolve('../server')];
+    });
+    afterEach(async () => {
+        Fake_Webpage_Publisher.ready_delay_ms = 0;
+        Fake_Website_Publisher.ready_delay_ms = 0;
+        if (server_instance) {
+            await new Promise(resolve => server_instance.close(resolve));
+            server_instance = null;
+        }
+    });
     it('should serve a simple control', async () => {
         const port = await get_free_port();
@@ -195,16 +240,41 @@ describe('Server.serve', function() {
         assert.strictEqual(body, 'ok');
     });
-    it('should return 404 for unknown routes', async () => {
-        const port = await get_free_port();
-        server_instance = await Server.serve({
-            Ctrl: Dummy_Control,
-            src_path_client_js: dummy_client_path,
-            host: '127.0.0.1',
-            port
-        });
-        const { res, body } = await get_http_response(port, '/missing');
-        assert.strictEqual(res.statusCode, 404);
-        assert.strictEqual(body, 'Not Found');
-    });
-});
+    it('should return 404 for unknown routes', async () => {
+        const port = await get_free_port();
+        server_instance = await Server.serve({
+            Ctrl: Dummy_Control,
+            src_path_client_js: dummy_client_path,
+            host: '127.0.0.1',
+            port
+        });
+        const { res, body } = await get_http_response(port, '/missing');
+        assert.strictEqual(res.statusCode, 404);
+        assert.strictEqual(body, 'Not Found');
+    });
+    it('waits for webpage publisher readiness before resolving serve()', async () => {
+        Fake_Webpage_Publisher.ready_delay_ms = 2600;
+        const port = await get_free_port();
+        const started_at = Date.now();
+        server_instance = await Server.serve({
+            Ctrl: Dummy_Control,
+            src_path_client_js: dummy_client_path,
+            host: '127.0.0.1',
+            port,
+            readyTimeoutMs: 12000
+        });
+        const elapsed_ms = Date.now() - started_at;
+        assert(
+            elapsed_ms >= 2400,
+            `Expected serve() to wait for delayed readiness, elapsed=${elapsed_ms}ms`
+        );
+        const { res, body } = await get_http_response(port, '/');
+        assert.strictEqual(res.statusCode, 200);
+        assert(body.includes('<div class="dummy-control"'));
+    });
+});

package/tests/server-resource-pool.test.js ADDED Viewed

@@ -0,0 +1,106 @@
+const assert = require('assert');
+const { describe, it } = require('mocha');
+const { Resource } = require('jsgui3-html');
+const Server_Resource_Pool = require('../resources/server-resource-pool');
+class Dummy_Managed_Resource extends Resource {
+    constructor(spec = {}) {
+        super(spec);
+        this.current_state = spec.initial_state || 'stopped';
+        this.start_calls = 0;
+        this.stop_calls = 0;
+    }
+    start(callback) {
+        const previous_state = this.current_state;
+        this.start_calls += 1;
+        this.current_state = 'running';
+        this.raise('state_change', {
+            from: previous_state,
+            to: this.current_state,
+            timestamp: Date.now()
+        });
+        if (typeof callback === 'function') callback(null, true);
+        return Promise.resolve(true);
+    }
+    stop(callback) {
+        const previous_state = this.current_state;
+        this.stop_calls += 1;
+        this.current_state = 'stopped';
+        this.raise('state_change', {
+            from: previous_state,
+            to: this.current_state,
+            timestamp: Date.now()
+        });
+        if (typeof callback === 'function') callback(null, true);
+        return Promise.resolve(true);
+    }
+    get status() {
+        return {
+            state: this.current_state
+        };
+    }
+    get_abstract() {
+        return {
+            name: this.name,
+            state: this.current_state
+        };
+    }
+}
+describe('Server_Resource_Pool lifecycle', function() {
+    it('forwards resource state events and supports removal with stop()', async () => {
+        const resource_pool = new Server_Resource_Pool();
+        const managed_resource = new Dummy_Managed_Resource({
+            name: 'managed_resource_one'
+        });
+        resource_pool.add(managed_resource);
+        const forwarded_events = [];
+        resource_pool.on('resource_state_change', (event_data) => {
+            forwarded_events.push(event_data);
+        });
+        await managed_resource.start();
+        assert(forwarded_events.some((event_data) => event_data.resourceName === 'managed_resource_one' && event_data.to === 'running'));
+        const did_remove = await resource_pool.remove('managed_resource_one');
+        assert.strictEqual(did_remove, true);
+        assert.strictEqual(managed_resource.stop_calls > 0, true);
+        assert.strictEqual(resource_pool.has_resource('managed_resource_one'), false);
+    });
+    it('supports stop-all and summary aggregation', async () => {
+        const resource_pool = new Server_Resource_Pool();
+        const resource_one = new Dummy_Managed_Resource({
+            name: 'managed_resource_a',
+            initial_state: 'running'
+        });
+        const resource_two = new Dummy_Managed_Resource({
+            name: 'managed_resource_b',
+            initial_state: 'crashed'
+        });
+        resource_pool.add(resource_one);
+        resource_pool.add(resource_two);
+        const by_constructor = resource_pool.get_resources_by_type(Dummy_Managed_Resource);
+        const by_name = resource_pool.get_resources_by_type('Dummy_Managed_Resource');
+        assert.strictEqual(by_constructor.length >= 2, true);
+        assert.strictEqual(by_name.length >= 2, true);
+        const summary_before_stop = resource_pool.summary;
+        assert(summary_before_stop.byType.Dummy_Managed_Resource);
+        assert(summary_before_stop.byType.Dummy_Managed_Resource.some((entry) => entry.name === 'managed_resource_a'));
+        await resource_pool.stop();
+        assert.strictEqual(resource_one.stop_calls > 0, true);
+        assert.strictEqual(resource_two.stop_calls > 0, true);
+    });
+});