npm - jsgui3-server - Versions diffs - 0.0.143 → 0.0.145 - Mend

jsgui3-server 0.0.143 → 0.0.145

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 (67) hide show

package/docs/comprehensive-documentation.md +25 -6
package/docs/configuration-reference.md +46 -11
package/docs/controls-development.md +54 -26
package/docs/jsgui3-html-improvement-ideas.md +162 -0
package/docs/jsgui3-html-improvement-ideas.svg +151 -0
package/docs/troubleshooting.md +9 -8
package/examples/controls/14d) window, canvas globe/EarthGlobeRenderer.js +19 -14
package/examples/controls/14d) window, canvas globe/pipeline/TransformStage.js +5 -5
package/examples/jsgui3-html/01) mvvm-counter/client.js +648 -0
package/examples/jsgui3-html/01) mvvm-counter/server.js +21 -0
package/examples/jsgui3-html/02) date-transform/client.js +764 -0
package/examples/jsgui3-html/02) date-transform/server.js +21 -0
package/examples/jsgui3-html/03) form-validation/client.js +1045 -0
package/examples/jsgui3-html/03) form-validation/server.js +21 -0
package/examples/jsgui3-html/04) data-grid/client.js +738 -0
package/examples/jsgui3-html/04) data-grid/server.js +21 -0
package/examples/jsgui3-html/05) master-detail/client.js +649 -0
package/examples/jsgui3-html/05) master-detail/server.js +21 -0
package/examples/jsgui3-html/06) theming/client.js +514 -0
package/examples/jsgui3-html/06) theming/server.js +21 -0
package/examples/jsgui3-html/07) mixins/client.js +465 -0
package/examples/jsgui3-html/07) mixins/server.js +21 -0
package/examples/jsgui3-html/08) router/client.js +372 -0
package/examples/jsgui3-html/08) router/server.js +21 -0
package/examples/jsgui3-html/09) resource-transform/client.js +692 -0
package/examples/jsgui3-html/09) resource-transform/server.js +21 -0
package/examples/jsgui3-html/10) binding-debugger/client.js +810 -0
package/examples/jsgui3-html/10) binding-debugger/server.js +21 -0
package/examples/jsgui3-html/README.md +48 -0
package/http/responders/static/Static_Route_HTTP_Responder.js +25 -20
package/lab/README.md +19 -0
package/lab/experiments/window_examples_dom_audit.js +241 -0
package/lab/results/window_examples_dom_audit.json +131 -0
package/lab/results/window_examples_dom_audit.md +46 -0
package/package.json +8 -3
package/publishers/http-webpageorsite-publisher.js +8 -4
package/resources/processors/bundlers/css-bundler.js +28 -173
package/resources/processors/bundlers/js/esbuild/Advanced_JS_Bundler_Using_ESBuild.js +32 -20
package/resources/processors/bundlers/style-bundler.js +288 -0
package/resources/processors/compilers/SASS_Compiler.js +88 -0
package/resources/processors/extractors/js/css_and_js/AST_Node/CSS_And_JS_From_JS_String_Using_AST_Node_Extractor.js +64 -68
package/resources/website-css-resource.js +24 -20
package/resources/website-javascript-resource-processor.js +17 -57
package/resources/website-javascript-resource.js +17 -57
package/serve-factory.js +38 -24
package/server.js +116 -92
package/tests/README.md +38 -3
package/tests/bundlers.test.js +41 -32
package/tests/content-analysis.test.js +19 -18
package/tests/end-to-end.test.js +336 -365
package/tests/error-handling.test.js +13 -11
package/tests/examples-controls.e2e.test.js +13 -1
package/tests/fixtures/end-to-end-client.js +54 -0
package/tests/fixtures/jsgui3-html/binding_debugger_expectations.json +15 -0
package/tests/fixtures/jsgui3-html/counter_expectations.json +31 -0
package/tests/fixtures/jsgui3-html/data_grid_expectations.json +26 -0
package/tests/fixtures/jsgui3-html/date_transform_expectations.json +26 -0
package/tests/fixtures/jsgui3-html/form_validation_expectations.json +27 -0
package/tests/fixtures/jsgui3-html/master_detail_expectations.json +15 -0
package/tests/fixtures/jsgui3-html/mixins_expectations.json +10 -0
package/tests/fixtures/jsgui3-html/resource_transform_expectations.json +11 -0
package/tests/fixtures/jsgui3-html/router_expectations.json +10 -0
package/tests/fixtures/jsgui3-html/theming_expectations.json +10 -0
package/tests/jsgui3-html-examples.puppeteer.test.js +537 -0
package/tests/sass-controls.e2e.test.js +327 -0
package/tests/test-runner.js +4 -1
package/tests/window-examples.puppeteer.test.js +455 -0

package/tests/end-to-end.test.js CHANGED Viewed

@@ -1,123 +1,81 @@
 const assert = require('assert');
 const { describe, it, before, after } = require('mocha');
 const http = require('http');
-const fs = require('fs').promises;
-const path = require('path');
+const path = require('path');
-// Import server and related classes
-const Server = require('../module');
+// Import server and related classes
+const jsgui_module = require('../module');
+const Server = jsgui_module.Server;
 describe('End-to-End Integration Tests', function() {
     this.timeout(30000); // Allow more time for server startup and requests
-    let server;
-    let serverPort = 3001; // Use a different port for testing
-    let testControl;
-    before(async function() {
-        // Create a test control class
-        testControl = class TestControl {
-            constructor(spec) {
-                this.context = spec.context;
-                this.head = {
-                    add: function(element) {
-                        // Mock add method
-                    }
-                };
-                this.body = {
-                    add: function(element) {
-                        // Mock add method
-                    }
-                };
-            }
-            active() {
-                // Mock activation
-            }
-            all_html_render() {
-                return Promise.resolve(`<!DOCTYPE html>
-<html>
-<head>
-    <title>Test Page</title>
-    <script src="/js/js.js"></script>
-</head>
-<body>
-    <div id="test-control">
-        <h1>Test Control</h1>
-        <p>This is a test control with embedded CSS and JS.</p>
-        <button onclick="testFunction()">Test Button</button>
-    </div>
-</body>
-</html>`);
-            }
-        };
-        // Add CSS and JS to the control class
-        testControl.css = `
-            .test-control {
-                background-color: #f0f0f0;
-                padding: 20px;
-                border: 1px solid #ccc;
-                font-family: Arial, sans-serif;
-            }
-            .test-control h1 {
-                color: #333;
-                margin-bottom: 10px;
-            }
-            .test-control p {
-                color: #666;
-                line-height: 1.5;
-            }
-        `;
-        testControl.js = `
-            // Test JavaScript with CSS embedding
-            const css = \`${testControl.css}\`;
-            // Add CSS to document
-            const style = document.createElement('style');
-            style.textContent = css;
-            document.head.appendChild(style);
-            // Test function
-            function testFunction() {
-                console.log('Test function called');
-                alert('Test function executed successfully!');
-                return 'test result';
-            }
-            // Initialize when DOM is ready
-            document.addEventListener('DOMContentLoaded', function() {
-                console.log('Test control initialized');
-                const testDiv = document.getElementById('test-control');
-                if (testDiv) {
-                    testDiv.style.borderColor = '#007bff';
-                }
-            });
-            // Export for testing
-            window.TestControl = { testFunction };
-        `;
-    });
-    after(async function() {
-        // Clean up server
-        if (server) {
-            await server.stop();
-        }
-    });
+    let server;
+    let serverPort = 3001; // Use a different port for testing
+    let testControl;
+    let test_client_path;
+    let base_serve_options;
+    const wait_for_route = async (url, timeout_ms = 20000) => {
+        const start_time = Date.now();
+        let last_error = null;
+        while (Date.now() - start_time < timeout_ms) {
+            try {
+                const response = await makeRequest(url, {
+                    'Accept-Encoding': 'identity'
+                });
+                if (response.statusCode === 200) return response;
+            } catch (error) {
+                last_error = error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        const error = last_error || new Error(`Timed out waiting for ${url}`);
+        throw error;
+    };
+    const start_server = async (serve_options) => {
+        const server_instance = await Server.serve(serve_options);
+        const port = server_instance.port || serve_options.port;
+        if (port) {
+            await wait_for_route(`http://localhost:${port}/js/js.js`);
+        }
+        return server_instance;
+    };
+    const stop_server = async (server_instance) => {
+        if (!server_instance) return;
+        await new Promise((resolve) => server_instance.close(resolve));
+    };
+    before(async function() {
+        test_client_path = path.join(__dirname, 'fixtures', 'end-to-end-client.js');
+        const test_client = require(test_client_path);
+        testControl = test_client.controls && test_client.controls.Test_Control;
+        assert(testControl, `Missing exported control jsgui.controls.Test_Control in ${test_client_path}`);
+        base_serve_options = {
+            ctrl: testControl,
+            port: serverPort,
+            src_path_client_js: test_client_path
+        };
+    });
+    afterEach(async function() {
+        await stop_server(server);
+        server = null;
+    });
+    after(async function() {
+        // Clean up server
+        await stop_server(server);
+        server = null;
+    });
     describe('Full Server Integration with Minification and Compression', function() {
         it('should serve webpage with minified and compressed JavaScript', async function() {
-            // Start server with minification and compression enabled
-            server = new Server();
-            await server.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: false, // Enable minification
-                bundler: {
-                    minify: {
+            // Start server with minification and compression enabled
+            server = await start_server({
+                ...base_serve_options,
+                debug: false, // Enable minification
+                bundler: {
+                    minify: {
                         enabled: true,
                         level: 'normal'
                     },
@@ -128,47 +86,56 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
-            // Wait for server to be ready
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Test gzip compressed JavaScript
-            const jsResponse = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
-                'Accept-Encoding': 'gzip'
-            });
-            assert.strictEqual(jsResponse.statusCode, 200);
-            assert.strictEqual(jsResponse.headers['content-encoding'], 'gzip');
-            assert(jsResponse.headers['content-type'].includes('javascript'));
-            // Verify the response is actually compressed (should be smaller than original)
-            const originalSize = Buffer.from(testControl.js, 'utf8').length;
-            const compressedSize = jsResponse.body.length;
-            assert(compressedSize < originalSize, 'JavaScript should be compressed');
-            // Test brotli compressed JavaScript
-            const brJsResponse = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
-                'Accept-Encoding': 'br'
-            });
-            assert.strictEqual(brJsResponse.statusCode, 200);
-            assert.strictEqual(brJsResponse.headers['content-encoding'], 'br');
-            // Brotli should generally be smaller than gzip for text
-            assert(brJsResponse.body.length <= jsResponse.body.length,
-                   'Brotli should be at least as good as gzip');
-            // Stop server
-            await server.stop();
-        });
-        it('should serve webpage with sourcemaps in debug mode', async function() {
-            // Start server in debug mode
-            server = new Server();
-            await server.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: true, // Enable sourcemaps
-                bundler: {
+            const js_identity_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+                'Accept-Encoding': 'identity'
+            });
+            assert.strictEqual(js_identity_response.statusCode, 200);
+            assert(
+                !js_identity_response.headers['content-encoding'] ||
+                js_identity_response.headers['content-encoding'] === 'identity'
+            );
+            // Test gzip compressed JavaScript
+            const js_gzip_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+                'Accept-Encoding': 'gzip'
+            });
+            assert.strictEqual(js_gzip_response.statusCode, 200);
+            assert.strictEqual(js_gzip_response.headers['content-encoding'], 'gzip');
+            assert(js_gzip_response.headers['content-type'].includes('javascript'));
+            // Verify the response is actually compressed (should be smaller than identity)
+            assert(
+                js_gzip_response.body.length < js_identity_response.body.length,
+                'JavaScript should be compressed'
+            );
+            // Test brotli compressed JavaScript
+            const br_js_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+                'Accept-Encoding': 'br'
+            });
+            assert.strictEqual(br_js_response.statusCode, 200);
+            assert.strictEqual(br_js_response.headers['content-encoding'], 'br');
+            // Brotli should generally be smaller than gzip for text
+            assert(
+                br_js_response.body.length <= js_gzip_response.body.length,
+                'Brotli should be at least as good as gzip'
+            );
+            // Stop server
+            await stop_server(server);
+            server = null;
+        });
+        it('should serve webpage with sourcemaps in debug mode', async function() {
+            // Start server in debug mode
+            server = await start_server({
+                ...base_serve_options,
+                debug: true, // Enable sourcemaps
+                bundler: {
                     sourcemaps: {
                         enabled: true,
                         format: 'inline'
@@ -180,34 +147,30 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
-            // Wait for server to be ready
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Test JavaScript with sourcemaps
-            const jsResponse = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
-                'Accept-Encoding': 'gzip'
-            });
-            assert.strictEqual(jsResponse.statusCode, 200);
-            assert.strictEqual(jsResponse.headers['content-encoding'], 'gzip');
-            // Decompress to check for sourcemap
-            const zlib = require('zlib');
-            const decompressed = zlib.gunzipSync(jsResponse.body).toString();
-            assert(decompressed.includes('//# sourceMappingURL='), 'Debug mode should include inline sourcemaps');
-            // Stop server
-            await server.stop();
-        });
-        it('should serve compressed CSS', async function() {
-            // Start server with compression
-            server = new Server();
-            await server.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: false,
-                bundler: {
+            // Test JavaScript with sourcemaps
+            const js_gzip_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+                'Accept-Encoding': 'gzip'
+            });
+            assert.strictEqual(js_gzip_response.statusCode, 200);
+            assert.strictEqual(js_gzip_response.headers['content-encoding'], 'gzip');
+            // Decompress to check for sourcemap
+            const zlib = require('zlib');
+            const decompressed = zlib.gunzipSync(js_gzip_response.body).toString();
+            assert(decompressed.includes('//# sourceMappingURL='), 'Debug mode should include inline sourcemaps');
+            // Stop server
+            await stop_server(server);
+            server = null;
+        });
+        it('should serve compressed CSS', async function() {
+            // Start server with compression
+            server = await start_server({
+                ...base_serve_options,
+                debug: false,
+                bundler: {
                     compression: {
                         enabled: true,
                         algorithms: ['gzip', 'br']
@@ -215,35 +178,42 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
-            // Wait for server to be ready
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Test gzip compressed CSS
-            const cssResponse = await makeRequest(`http://localhost:${serverPort}/css/css.css`, {
-                'Accept-Encoding': 'gzip'
-            });
-            assert.strictEqual(cssResponse.statusCode, 200);
-            assert.strictEqual(cssResponse.headers['content-encoding'], 'gzip');
-            assert(cssResponse.headers['content-type'].includes('css'));
-            // Verify CSS content is compressed
-            const originalCssSize = Buffer.from(testControl.css, 'utf8').length;
-            const compressedCssSize = cssResponse.body.length;
-            assert(compressedCssSize < originalCssSize, 'CSS should be compressed');
-            // Stop server
-            await server.stop();
-        });
-        it('should serve HTML without compression when below threshold', async function() {
-            // Start server with high compression threshold
-            server = new Server();
-            await server.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: false,
-                bundler: {
+            const css_identity_response = await makeRequest(`http://localhost:${serverPort}/css/css.css`, {
+                'Accept-Encoding': 'identity'
+            });
+            assert.strictEqual(css_identity_response.statusCode, 200);
+            assert(
+                !css_identity_response.headers['content-encoding'] ||
+                css_identity_response.headers['content-encoding'] === 'identity'
+            );
+            // Test gzip compressed CSS
+            const css_gzip_response = await makeRequest(`http://localhost:${serverPort}/css/css.css`, {
+                'Accept-Encoding': 'gzip'
+            });
+            assert.strictEqual(css_gzip_response.statusCode, 200);
+            assert.strictEqual(css_gzip_response.headers['content-encoding'], 'gzip');
+            assert(css_gzip_response.headers['content-type'].includes('css'));
+            // Verify CSS content is compressed
+            assert(
+                css_gzip_response.body.length < css_identity_response.body.length,
+                'CSS should be compressed'
+            );
+            // Stop server
+            await stop_server(server);
+            server = null;
+        });
+        it('should serve HTML without compression when below threshold', async function() {
+            // Start server with high compression threshold
+            server = await start_server({
+                ...base_serve_options,
+                debug: false,
+                bundler: {
                     compression: {
                         enabled: true,
                         threshold: 10000 // Very high threshold
@@ -251,99 +221,107 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
-            // Wait for server to be ready
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Test HTML (should not be compressed due to threshold)
-            const htmlResponse = await makeRequest(`http://localhost:${serverPort}/`, {
+            // Test HTML (should not be compressed due to threshold)
+            const htmlResponse = await makeRequest(`http://localhost:${serverPort}/`, {
                 'Accept-Encoding': 'gzip'
             });
             assert.strictEqual(htmlResponse.statusCode, 200);
             assert(!htmlResponse.headers['content-encoding'], 'HTML should not be compressed due to threshold');
-            assert(htmlResponse.headers['content-type'].includes('html'));
-            // Stop server
-            await server.stop();
-        });
-        it('should handle different minification levels', async function() {
-            const minificationLevels = ['conservative', 'normal', 'aggressive'];
-            for (const level of minificationLevels) {
-                // Start server with specific minification level
-                server = new Server();
-                await server.serve({
-                    ctrl: testControl,
-                    port: serverPort,
-                    debug: false,
-                    bundler: {
-                        minify: {
-                            enabled: true,
-                            level: level
-                        },
-                        compression: {
-                            enabled: false // Disable compression for size comparison
-                        }
-                    }
-                });
-                // Wait for server to be ready
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                // Test JavaScript
-                const jsResponse = await makeRequest(`http://localhost:${serverPort}/js/js.js`);
-                assert.strictEqual(jsResponse.statusCode, 200);
-                assert(!jsResponse.headers['content-encoding'], 'Should not be compressed');
-                // Verify minification occurred (should be smaller than original)
-                const originalSize = Buffer.from(testControl.js, 'utf8').length;
-                const minifiedSize = jsResponse.body.length;
-                assert(minifiedSize < originalSize, `JavaScript should be minified with ${level} level`);
-                // Stop server
-                await server.stop();
-            }
-        });
-        it('should serve identical content with identity encoding when compression disabled', async function() {
-            // Start server with compression disabled
-            server = new Server();
-            await server.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: false,
-                bundler: {
+            assert(htmlResponse.headers['content-type'].includes('html'));
+            // Stop server
+            await stop_server(server);
+            server = null;
+        });
+        it('should handle different minification levels', async function() {
+            this.timeout(90000);
+            const minification_levels = ['conservative', 'normal', 'aggressive'];
+            server = await start_server({
+                ...base_serve_options,
+                debug: true,
+                bundler: {
+                    compression: {
+                        enabled: false
+                    }
+                }
+            });
+            const baseline_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+                'Accept-Encoding': 'identity'
+            });
+            assert.strictEqual(baseline_response.statusCode, 200);
+            const baseline_size = baseline_response.body.length;
+            await stop_server(server);
+            server = null;
+            for (const level of minification_levels) {
+                // Start server with specific minification level
+                server = await start_server({
+                    ...base_serve_options,
+                    debug: false,
+                    bundler: {
+                        minify: {
+                            enabled: true,
+                            level: level
+                        },
+                        compression: {
+                            enabled: false // Disable compression for size comparison
+                        }
+                    }
+                });
+                // Test JavaScript
+                const minified_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+                    'Accept-Encoding': 'identity'
+                });
+                assert.strictEqual(minified_response.statusCode, 200);
+                assert(
+                    minified_response.body.length <= baseline_size,
+                    `JavaScript should be minified with ${level} level`
+                );
+                // Stop server
+                await stop_server(server);
+                server = null;
+            }
+        });
+        it('should serve identical content with identity encoding when compression disabled', async function() {
+            // Start server with compression disabled
+            server = await start_server({
+                ...base_serve_options,
+                debug: false,
+                bundler: {
                     compression: {
                         enabled: false
                     }
                 }
             });
-            // Wait for server to be ready
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Test with gzip request but compression disabled
-            const jsResponse = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+            // Test with gzip request but compression disabled
+            const jsResponse = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
                 'Accept-Encoding': 'gzip'
             });
             assert.strictEqual(jsResponse.statusCode, 200);
-            assert(!jsResponse.headers['content-encoding'], 'Should not have content-encoding when compression disabled');
-            // Stop server
-            await server.stop();
-        });
-        it('should handle multiple concurrent requests', async function() {
-            // Start server
-            server = new Server();
-            await server.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: false,
-                bundler: {
+            assert(!jsResponse.headers['content-encoding'], 'Should not have content-encoding when compression disabled');
+            // Stop server
+            await stop_server(server);
+            server = null;
+        });
+        it('should handle multiple concurrent requests', async function() {
+            // Start server
+            server = await start_server({
+                ...base_serve_options,
+                debug: false,
+                bundler: {
                     compression: {
                         enabled: true,
                         algorithms: ['gzip']
@@ -351,11 +329,8 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
-            // Wait for server to be ready
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Make multiple concurrent requests
-            const requests = [];
+            // Make multiple concurrent requests
+            const requests = [];
             for (let i = 0; i < 5; i++) {
                 requests.push(makeRequest(`http://localhost:${serverPort}/js/js.js`, {
                     'Accept-Encoding': 'gzip'
@@ -365,29 +340,25 @@ describe('End-to-End Integration Tests', function() {
             const responses = await Promise.all(requests);
             // All requests should succeed
-            responses.forEach(response => {
-                assert.strictEqual(response.statusCode, 200);
-                assert.strictEqual(response.headers['content-encoding'], 'gzip');
-            });
-            // Stop server
-            await server.stop();
-        });
-        it('should serve correct content types', async function() {
-            // Start server
-            server = new Server();
-            await server.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: false
-            });
-            // Wait for server to be ready
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Test different content types
-            const tests = [
+            responses.forEach(response => {
+                assert.strictEqual(response.statusCode, 200);
+                assert.strictEqual(response.headers['content-encoding'], 'gzip');
+            });
+            // Stop server
+            await stop_server(server);
+            server = null;
+        });
+        it('should serve correct content types', async function() {
+            // Start server
+            server = await start_server({
+                ...base_serve_options,
+                debug: false
+            });
+            // Test different content types
+            const tests = [
                 { path: '/', expectedType: 'html' },
                 { path: '/js/js.js', expectedType: 'javascript' },
                 { path: '/css/css.css', expectedType: 'css' }
@@ -397,62 +368,62 @@ describe('End-to-End Integration Tests', function() {
                 const response = await makeRequest(`http://localhost:${serverPort}${test.path}`);
                 assert.strictEqual(response.statusCode, 200);
                 assert(response.headers['content-type'].includes(test.expectedType),
-                       `Should serve correct content type for ${test.path}`);
-            }
-            // Stop server
-            await server.stop();
-        });
-    });
+                       `Should serve correct content type for ${test.path}`);
+            }
+            // Stop server
+            await stop_server(server);
+            server = null;
+        });
+    });
     describe('Error Handling in End-to-End Scenarios', function() {
-        it('should handle invalid configuration gracefully', async function() {
-            // Try to start server with invalid configuration
-            server = new Server();
-            try {
-                await server.serve({
-                    ctrl: testControl,
-                    port: serverPort,
-                    bundler: {
-                        compression: {
+        it('should handle invalid configuration gracefully', async function() {
+            // Try to start server with invalid configuration
+            try {
+                server = await start_server({
+                    ...base_serve_options,
+                    bundler: {
+                        compression: {
                             enabled: 'invalid' // Invalid boolean
                         }
                     }
-                });
-                assert.fail('Should have thrown error for invalid configuration');
-            } catch (error) {
-                assert(error, 'Should throw error for invalid configuration');
-            }
-        });
-        it('should handle server port conflicts', async function() {
-            // Start first server
-            const server1 = new Server();
-            await server1.serve({
-                ctrl: testControl,
-                port: serverPort,
-                debug: false
-            });
-            // Try to start second server on same port
-            const server2 = new Server();
-            try {
-                await server2.serve({
-                    ctrl: testControl,
-                    port: serverPort, // Same port
-                    debug: false
-                });
-                assert.fail('Should have failed to start server on occupied port');
-            } catch (error) {
-                assert(error, 'Should throw error for port conflict');
-            }
-            // Clean up
-            await server1.stop();
-        });
-    });
-});
+                });
+                assert.fail('Should have thrown error for invalid configuration');
+            } catch (error) {
+                assert(error, 'Should throw error for invalid configuration');
+            } finally {
+                await stop_server(server);
+                server = null;
+            }
+        });
+        it('should handle server port conflicts', async function() {
+            // Start first server
+            const server1 = await start_server({
+                ...base_serve_options,
+                debug: false,
+                host: '127.0.0.1'
+            });
+            // Try to start second server on same port
+            try {
+                await start_server({
+                    ...base_serve_options,
+                    port: serverPort, // Same port
+                    debug: false,
+                    host: '127.0.0.1'
+                });
+                assert.fail('Should have failed to start server on occupied port');
+            } catch (error) {
+                assert(error, 'Should throw error for port conflict');
+            }
+            // Clean up
+            await stop_server(server1);
+        });
+    });
+});
 // Helper function to make HTTP requests
 function makeRequest(url, headers = {}) {
@@ -493,4 +464,4 @@ function makeRequest(url, headers = {}) {
         req.end();
     });
-}
+}