webhoster 0.1.0 → 0.3.0

package/test/helpers/HttpListener/events.js

@@ -0,0 +1,77 @@
+import * as http from 'node:http';
+import { Socket } from 'node:net';
+
+import test from 'ava';
+
+import HttpListener from '../../../helpers/HttpListener.js';
+
+// Event listener coverage: simulate error/clientError/request events
+
+test('httpServer emits error and clientError', (t) => {
+  const listener = new HttpListener();
+  const server = listener.createHttpServer();
+  let errorCalled = false;
+  let clientErrorCalled = false;
+  server.on('error', () => { errorCalled = true; });
+  server.on('clientError', () => { clientErrorCalled = true; });
+  server.emit('error', new Error('test error'));
+  server.emit('clientError', new Error('test client error'), new EventTarget());
+  t.true(errorCalled);
+  t.true(clientErrorCalled);
+});
+
+// Cannot easily test request/stream/session events without real network, but can check listeners are attached
+
+test('listeners are attached for request and error events', async (t) => {
+  const listener = new HttpListener({ insecurePort: 0 });
+  await listener.startHttpServer();
+  const server = listener.httpServer;
+  t.true(server.listenerCount('request') > 0);
+  t.true(server.listenerCount('error') > 0);
+  t.true(server.listenerCount('clientError') > 0);
+  await listener.stopHttpServer();
+});
+
+// Test that 'clientError' event handler is called for bad request
+test('httpServer clientError event is called for bad request', async (t) => {
+  const listener = new HttpListener({ insecurePort: 0 });
+  await listener.startHttpServer();
+  const server = listener.httpServer;
+  let called = false;
+  server.on('clientError', () => { called = true; });
+  const address = server.address();
+  const port = typeof address === 'object' && address ? address.port : address;
+  const socket = new Socket();
+  socket.connect(Number(port), '127.0.0.1', () => {
+    socket.write('BAD REQUEST\r\n\r\n');
+    setTimeout(() => {
+      socket.destroy();
+    }, 50);
+  });
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  t.true(called);
+  await listener.stopHttpServer();
+});
+
+// Test that 'error' event handler is called for server error
+test('httpServer error event is called', async (t) => {
+  const listener = new HttpListener({ insecurePort: 0 });
+  await listener.startHttpServer();
+  const server = listener.httpServer;
+  let called = false;
+  server.on('error', () => { called = true; });
+  server.emit('error', new Error('test error')); // Simulate error
+  t.true(called);
+  await listener.stopHttpServer();
+});
+
+// Test that listeners are removed after stop
+test('listeners are removed after stop', async (t) => {
+  const listener = new HttpListener({ insecurePort: 0 });
+  await listener.startHttpServer();
+  const server = listener.httpServer;
+  await listener.stopHttpServer();
+  t.is(server.listenerCount('request'), 0);
+  t.is(server.listenerCount('error'), 0);
+  t.is(server.listenerCount('clientError'), 0);
+});

package/test/helpers/HttpListener/http.js

@@ -0,0 +1,31 @@
+import { Socket } from 'node:net';
+
+import test from 'ava';
+
+import HttpListener from '../../../helpers/HttpListener.js';
+
+test('HttpListener.startHttpServer() and stopHttpServer() work', async (t) => {
+  const listener = new HttpListener({ insecurePort: 0 }); // Use ephemeral port
+  const server = await listener.startHttpServer();
+  t.truthy(server);
+  await listener.stopHttpServer();
+  t.pass();
+});
+
+test('HttpListener HTTP server closes idle socket after keepAliveTimeout', async (t) => {
+  const listener = new HttpListener({ insecurePort: 0 });
+  await listener.startHttpServer();
+  const server = listener.httpServer;
+  server.setTimeout(1000); // Set keepAliveTimeout to 1 seconds
+  const address = server.address();
+  const port = typeof address === 'object' && address ? address.port : address;
+  const socket = new Socket();
+  let destroyed = false;
+  socket.on('close', () => { destroyed = true; });
+  socket.connect(Number(port), '127.0.0.1', () => {
+    // Do not send any data, just keep connection open
+  });
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  t.true(destroyed, 'Socket should be destroyed after keepAliveTimeout');
+  await listener.stopHttpServer();
+});

package/test/helpers/HttpListener/http2.js

@@ -0,0 +1,41 @@
+import { connect } from 'node:http2';
+
+import test from 'ava';
+
+import HttpListener from '../../../helpers/HttpListener.js';
+
+const key = process.env.TEST_SSL_KEY;
+const cert = process.env.TEST_SSL_CERT;
+const haveCerts = key && cert;
+
+const testFn = haveCerts ? test : test.skip;
+
+testFn('HttpListener.startHttp2Server() and stopHttp2Server() work', async (t) => {
+  const tlsOptions = { key, cert };
+  const listener = new HttpListener({ securePort: 0, useHttp2: true, tlsOptions });
+  const server = await listener.startHttp2Server();
+  t.truthy(server);
+  await listener.stopHttp2Server();
+  t.pass();
+});
+
+testFn('HttpListener HTTP2 server closes idle socket after setTimeout', async (t) => {
+  const tlsOptions = { key, cert };
+  const listener = new HttpListener({ securePort: 0, useHttp2: true, tlsOptions });
+  await listener.startHttp2Server();
+  const server = listener.http2Server;
+  server.setTimeout(1000); // Set keepAliveTimeout to 1 seconds
+  const address = server.address();
+  const port = typeof address === 'object' && address ? address.port : address;
+  const client = connect(`https://127.0.0.1:${port}`, {
+    ca: cert,
+    rejectUnauthorized: false,
+  });
+  let closed = false;
+  client.on('close', () => { closed = true; });
+  // Do not send any requests, just keep connection open
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  t.true(closed, 'HTTP2 client should be closed after setTimeout');
+  client.destroy();
+  await listener.stopHttp2Server();
+});

package/test/helpers/HttpListener/https.js

@@ -0,0 +1,38 @@
+import { connect as tlsConnect } from 'node:tls';
+
+import test from 'ava';
+
+import HttpListener from '../../../helpers/HttpListener.js';
+
+const key = process.env.TEST_SSL_KEY;
+const cert = process.env.TEST_SSL_CERT;
+const haveCerts = key && cert;
+
+const testFn = haveCerts ? test : test.skip;
+
+testFn('HttpListener.startHttpsServer() and stopHttpsServer() work', async (t) => {
+  const tlsOptions = { key, cert };
+  const listener = new HttpListener({ securePort: 0, useHttps: true, tlsOptions });
+  const server = await listener.startHttpsServer();
+  t.truthy(server);
+  await listener.stopHttpsServer();
+  t.pass();
+});
+
+testFn('HttpListener HTTPS server closes idle socket after keepAliveTimeout', async (t) => {
+  const tlsOptions = { key, cert };
+  const listener = new HttpListener({ securePort: 0, useHttps: true, tlsOptions });
+  await listener.startHttpsServer();
+  const server = listener.httpsServer;
+  server.setTimeout(1000);
+  const address = server.address();
+  const port = typeof address === 'object' && address ? address.port : address;
+  let destroyed = false;
+  const socket = tlsConnect({ port: Number(port), host: '127.0.0.1', rejectUnauthorized: false }, () => {
+    // Do not send any data, just keep connection open
+  });
+  socket.on('close', () => { destroyed = true; });
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  t.true(destroyed, 'TLS socket should be destroyed after keepAliveTimeout');
+  await listener.stopHttpsServer();
+});

package/test/helpers/HttpListener/startAll.js

@@ -0,0 +1,31 @@
+import test from 'ava';
+
+import HttpListener from '../../../helpers/HttpListener.js';
+
+// Test startAll and stopAll with all modes enabled (HTTP, HTTPS, HTTP/2)
+
+const key = process.env.TEST_SSL_KEY;
+const cert = process.env.TEST_SSL_CERT;
+const haveCerts = !!key && !!cert;
+
+test('HttpListener.startAll() and stopAll() work (all modes)', async (t) => {
+  const listener = new HttpListener({
+    insecurePort: 0,
+    securePort: 0,
+    useHttp: true,
+    useHttps: haveCerts,
+    useHttp2: haveCerts,
+    tlsOptions: haveCerts ? { key, cert } : undefined,
+  });
+  const [http, https, http2] = await listener.startAll();
+  t.truthy(http);
+  if (haveCerts) {
+    t.truthy(https);
+    t.truthy(http2);
+  } else {
+    t.is(https, null);
+    t.is(http2, null);
+  }
+  await listener.stopAll();
+  t.pass();
+});

package/test/helpers/HttpListener/stopNotStarted.js

@@ -0,0 +1,23 @@
+import test from 'ava';
+import HttpListener from '../../../helpers/HttpListener.js';
+
+// Test stop methods when servers are not started (should resolve, not throw)
+test('stopHttpServer resolves if not started', async t => {
+  const listener = new HttpListener();
+  await t.notThrowsAsync(() => listener.stopHttpServer());
+});
+
+test('stopHttpsServer resolves if not started', async t => {
+  const listener = new HttpListener({ useHttps: true });
+  await t.notThrowsAsync(() => listener.stopHttpsServer());
+});
+
+test('stopHttp2Server resolves if not started', async t => {
+  const listener = new HttpListener({ useHttp2: true });
+  await t.notThrowsAsync(() => listener.stopHttp2Server());
+});
+
+test('stopAll resolves if nothing started', async t => {
+  const listener = new HttpListener({ useHttp: false, useHttps: false, useHttp2: false });
+  await t.notThrowsAsync(() => listener.stopAll());
+});

package/test/lib/HttpHandler/class.js

@@ -0,0 +1,8 @@
+import test from 'ava';
+
+import HttpHandler from '../../../lib/HttpHandler.js';
+
+test('new HttpHandler()', (t) => {
+  const instance = new HttpHandler({});
+  t.assert(instance instanceof HttpHandler);
+});

package/test/lib/HttpHandler/handleRequest.js

@@ -0,0 +1,11 @@
+import test from 'ava';
+import { PassThrough, Readable, Writable } from 'node:stream';
+
+import HttpHandler from '../../../lib/HttpHandler.js';
+import HttpRequest from '../../../lib/HttpRequest.js';
+import HttpResponse from '../../../lib/HttpResponse.js';
+
+test('HttpHandler.handleRequest()', async (t) => {
+
+  t.pass();
+});