webhoster 0.3.3 → 0.3.5

package/test/lib/HttpResponse/send.js

@@ -1,275 +0,0 @@
-import { PassThrough, pipeline } from 'node:stream';
-
-import test from 'ava';
-
-import HttpHandler from '../../../lib/HttpHandler.js';
-import HttpResponse from '../../../lib/HttpResponse.js';
-
-test('HttpResponse.sendStatusOnly() - header sent', async (t) => {
-  const res = new HttpResponse({
-    onHeadersSent: () => true,
-    stream: new PassThrough(),
-  });
-  const error = await t.throwsAsync(() => res.sendStatusOnly(500));
-  t.is(error.message, 'ERR_HEADER_SENT');
-});
-
-test('HttpResponse.sendStatusOnly() - not implemented', async (t) => {
-  const res = new HttpResponse({
-    onHeadersSent: () => false,
-    stream: new PassThrough(),
-  });
-  const error = await t.throwsAsync(() => res.sendStatusOnly(500));
-  t.is(error.message, 'NOT_IMPLEMENTED');
-});
-
-test('HttpResponse.sendStatusOnly() - not writable', async (t) => {
-  const res = new HttpResponse({
-    onHeadersSent: () => false,
-    stream: new PassThrough(),
-  });
-  res.stream.destroy();
-  const error = await t.throwsAsync(() => res.sendStatusOnly(500));
-  t.is(error.message, 'NOT_WRITABLE');
-});
-
-test('HttpResponse.sendStatusOnly()', async (t) => {
-  t.plan(3);
-  const res = new HttpResponse({
-    onHeadersSent: () => false,
-    stream: new PassThrough(),
-    onSendHeaders: (flush, end) => {
-      t.true(end);
-    },
-  });
-  const result = await res.sendStatusOnly(500);
-  t.is(res.status, 500);
-  t.is(result, HttpHandler.END);
-});
-
-test('HttpResponse.sendHeaders()', async (t) => {
-  const res = new HttpResponse({
-    stream: new PassThrough(),
-    onSendHeaders: () => {},
-  });
-  t.false(res.headersSent);
-  const result = await res.sendHeaders();
-  t.true(res.headersSent);
-});
-
-test('HttpResponse.sendHeaders() - cannot resend', async (t) => {
-  const res = new HttpResponse({
-    stream: new PassThrough(),
-    onSendHeaders: () => {},
-  });
-  t.false(res.headersSent);
-  res.sendHeaders();
-  t.true(res.headersSent);
-  const error = t.throws(() => res.sendHeaders());
-  t.is(error.message, 'HEADER_SENT');
-});
-
-test('HttpResponse.sendRaw()', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const res = new HttpResponse({ stream, onSendHeaders: () => {} });
-  t.false(stream.writableEnded);
-  const result = await res.sendRaw(Buffer.from('foo'));
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.is(chunk.toString(), 'foo');
-  }
-});
-
-test('HttpResponse.send() - non-writable', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const res = new HttpResponse({ stream, onSendHeaders: () => {} });
-  t.false(stream.destroyed);
-  stream.destroy();
-  const error = await t.throwsAsync(() => res.send(Buffer.from('foo')));
-  t.is(error.message, 'NOT_WRITABLE');
-});
-
-test('HttpResponse.send() - null', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const res = new HttpResponse({ stream, onSendHeaders: () => {} });
-  t.false(stream.writableEnded);
-  const result = await res.send();
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.fail();
-  }
-});
-
-test('HttpResponse.send() - content-handler typeof string', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  response.finalizers.push((res) => {
-    if (typeof res.body === 'string') {
-      res.body = Buffer.from(res.body, 'latin1');
-    }
-  });
-  t.false(stream.writableEnded);
-  const result = await response.send('foo');
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.true(Buffer.isBuffer(chunk));
-    t.is(chunk.toString('latin1'), 'foo');
-  }
-});
-
-test('HttpResponse.send() - content-handler instanceof Date', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  const d = new Date(0);
-  response.finalizers.push((res) => {
-    if (res.body instanceof Date) {
-      res.body = Buffer.from(res.body.toISOString(), 'latin1');
-    }
-  });
-  t.false(stream.writableEnded);
-  const result = await response.send(d);
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.true(Buffer.isBuffer(chunk));
-    t.is(chunk.toString('latin1'), d.toISOString());
-  }
-});
-
-test('HttpResponse.send()', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const res = new HttpResponse({ stream, onSendHeaders: () => {} });
-  t.false(stream.writableEnded);
-  const result = await res.send(Buffer.from('foo'));
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.true(Buffer.isBuffer(chunk));
-    t.is(chunk.toString(), 'foo');
-  }
-});
-
-test('HttpResponse.end() - non-writable', async (t) => {
-  t.plan(7);
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  pipeline(stream, reader, (err) => {
-    if (err) t.pass();
-    else t.fail();
-  });
-  // stream.pipe(reader);
-  const res = new HttpResponse({ stream, onSendHeaders: () => {} });
-  t.false(stream.destroyed);
-  stream.destroy();
-  t.true(stream.destroyed);
-
-  const result = res.end(Buffer.from('foo'));
-  t.is(result, HttpHandler.END);
-  t.false(stream.writableEnded);
-  t.true(stream.destroyed);
-  try {
-    for await (const chunk of reader) {
-      t.fail();
-    }
-  } catch {
-    // Cannot read from destroyed stream;
-    t.pass();
-  }
-});
-
-test('HttpResponse.end() - content-handler typeof string', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({
-    stream,
-    onSendHeaders: () => {},
-  });
-  response.finalizers.push((res) => {
-    if (typeof res.body === 'string') {
-      res.body = Buffer.from(res.body, 'latin1');
-    }
-  });
-  t.false(stream.writableEnded);
-  const result = response.end('foo');
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.true(Buffer.isBuffer(chunk));
-    t.is(chunk.toString('latin1'), 'foo');
-  }
-});
-
-test('HttpResponse.end() - content-handler instanceof Date', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  const d = new Date(0);
-  response.finalizers.push((res) => {
-    if (res.body instanceof Date) {
-      res.body = Buffer.from(res.body.toISOString(), 'latin1');
-    }
-  });
-  t.false(stream.writableEnded);
-  const result = response.end(d);
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.true(Buffer.isBuffer(chunk));
-    t.is(chunk.toString('latin1'), d.toISOString());
-  }
-});
-
-test('HttpResponse.end() - null', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const res = new HttpResponse({ stream, onSendHeaders: () => {} });
-  t.false(stream.writableEnded);
-  const result = res.end();
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.fail();
-  }
-});
-
-test('HttpResponse.end()', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const res = new HttpResponse({ stream, onSendHeaders: () => {} });
-  t.false(stream.writableEnded);
-  const result = res.end(Buffer.from('foo'));
-  t.is(result, HttpHandler.END);
-  t.true(stream.writableEnded);
-
-  for await (const chunk of reader) {
-    t.true(Buffer.isBuffer(chunk));
-    t.is(chunk.toString(), 'foo');
-  }
-});

package/test/lib/HttpTransaction/class.js

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

package/test/lib/HttpTransaction/ping.js

@@ -1,50 +0,0 @@
-import test from 'ava';
-
-import HttpTransaction from '../../../lib/HttpTransaction.js';
-
-test('HttpTransaction.canPing', (t) => {
-  t.false(new HttpTransaction({}).canPing);
-
-  t.true(new HttpTransaction({ canPing: true }).canPing);
-
-  t.false(new HttpTransaction({ canPing: false }).canPing);
-
-  t.false(new HttpTransaction({ canPing: () => false }).canPing);
-
-  t.true(new HttpTransaction({ canPing: () => true }).canPing);
-});
-
-test('HttpTransaction.ping - not supported', async (t) => {
-  const transaction = new HttpTransaction({});
-  t.false(transaction.canPing);
-  const error = await t.throwsAsync(async () => await transaction.ping());
-  t.is(error.message, 'NOT_SUPPORTED');
-});
-
-test('HttpTransaction.ping - not implemented', async (t) => {
-  const transaction = new HttpTransaction({ canPing: true });
-  const error = await t.throwsAsync(async () => await transaction.ping());
-  t.is(error.message, 'NOT_IMPLEMENTED');
-});
-
-test('HttpTransaction.ping - canPing guard ', async (t) => {
-  let testValue = false;
-  const transaction = new HttpTransaction({
-    canPing: false,
-    onPing() { testValue = true; },
-  });
-  t.false(testValue);
-  await t.throwsAsync(async () => await transaction.ping());
-  t.false(testValue);
-});
-
-test('HttpTransaction.ping', async (t) => {
-  let testValue = false;
-  const transaction = new HttpTransaction({
-    canPing: true,
-    onPing: () => { testValue = true; },
-  });
-  t.false(testValue);
-  await transaction.ping();
-  t.true(testValue);
-});

package/test/lib/HttpTransaction/push.js

@@ -1,89 +0,0 @@
-import test from 'ava';
-
-import HttpTransaction from '../../../lib/HttpTransaction.js';
-
-test('HttpTransaction.canPushPath', (t) => {
-  t.false(new HttpTransaction({}).canPushPath);
-
-  t.true(new HttpTransaction({ canPushPath: true }).canPushPath);
-
-  t.false(new HttpTransaction({ canPushPath: false }).canPushPath);
-
-  t.false(new HttpTransaction({ canPushPath: () => false }).canPushPath);
-
-  t.true(new HttpTransaction({ canPushPath: () => true }).canPushPath);
-});
-
-test('HttpTransaction.pushPath - not supported', async (t) => {
-  const request = new HttpTransaction({});
-  t.false(request.canPushPath);
-  const error = await t.throwsAsync(() => request.pushPath());
-  t.is(error.message, 'NOT_SUPPORTED');
-});
-
-test('HttpTransaction.pushPath - not implemented', async (t) => {
-  const request = new HttpTransaction({ canPushPath: true });
-  const error = await t.throwsAsync(() => request.pushPath());
-  t.is(error.message, 'NOT_IMPLEMENTED');
-});
-
-test('HttpTransaction.pushPath - canPushPath guard ', async (t) => {
-  let testValue = false;
-  const request = new HttpTransaction({
-    canPushPath: false,
-    onPushPath() { testValue = true; },
-  });
-  t.false(testValue);
-  await t.throwsAsync(() => request.pushPath());
-  t.false(testValue);
-});
-
-test('HttpTransaction.pushPath - already pushed ', async (t) => {
-  let testValue = false;
-  const request = new HttpTransaction({
-    canPushPath: true,
-    onPushPath: (path) => { testValue = true; },
-  });
-  t.false(testValue);
-  await request.pushPath('/styles.css');
-  t.true(testValue);
-  const error = await t.throwsAsync(() => request.pushPath('/styles.css'));
-  t.is(error.message, 'ALREADY_PUSHED');
-});
-
-test('HttpTransaction.pushPath', async (t) => {
-  let testValue = false;
-  const request = new HttpTransaction({
-    canPushPath: true,
-    onPushPath: () => { testValue = true; },
-  });
-  t.false(testValue);
-  await request.pushPath('/styles.css');
-  t.true(testValue);
-  await request.pushPath('/script.js');
-});
-
-test('HttpTransaction.pushPath - failure', async (t) => {
-  const request = new HttpTransaction({
-    canPushPath: true,
-    onPushPath: (path) => {
-      if (path === '/styles.css') throw new Error('TEST');
-    },
-  });
-  t.deepEqual(request.pushedPaths, []);
-  const error = await t.throwsAsync(() => request.pushPath('/styles.css'));
-  t.is(error.message, 'TEST');
-  await request.pushPath('/script.js');
-  t.deepEqual(request.pushedPaths, ['/script.js']);
-});
-
-test('HttpTransaction.pushedPaths', async (t) => {
-  const request = new HttpTransaction({
-    canPushPath: true,
-    onPushPath: () => {},
-  });
-  t.deepEqual(request.pushedPaths, []);
-  await request.pushPath('/styles.css');
-  await request.pushPath('/script.js');
-  t.deepEqual(request.pushedPaths, ['/styles.css', '/script.js']);
-});

package/test/middleware/SendJsonMiddleware.js

@@ -1,222 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { PassThrough } from 'node:stream';
-
-import test from 'ava';
-
-import HttpResponse from '../../lib/HttpResponse.js';
-import SendJsonMiddleware from '../../middleware/SendJsonMiddleware.js';
-
-test('new SendJsonMiddleware()', (t) => {
-  const instance = new SendJsonMiddleware();
-  t.assert(instance instanceof SendJsonMiddleware);
-});
-
-test('SendJsonMiddleware.execute()', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({
-    stream,
-    onSendHeaders: () => {},
-  });
-  const middleware = new SendJsonMiddleware();
-  middleware.execute({ response });
-
-  /** @type {any} */
-  const jsonContent = {
-    number: Math.floor(Math.random() * 10),
-    date: new Date(Math.random() * Date.now()),
-    string: randomBytes(48).toString('hex'),
-    boolean: true,
-    null: null,
-    array: [
-      1,
-      2,
-    ],
-    object: {
-      key: 'value',
-    },
-  };
-
-  await response.send(jsonContent);
-
-  for await (const chunk of reader) {
-    const s = chunk.toString();
-    const data = JSON.parse(s);
-    t.deepEqual(data, {
-      ...jsonContent,
-      date: jsonContent.date.toISOString(),
-    });
-  }
-
-  t.is(response.headers['content-type'], 'application/json;charset=utf-8');
-});
-
-test('SendJsonMiddleware.Execute() (static)', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({
-    stream,
-    onSendHeaders: () => {},
-  });
-  SendJsonMiddleware.Execute({ response });
-
-  /** @type {any} */
-  const jsonContent = {
-    number: Math.floor(Math.random() * 10),
-    date: new Date(Math.random() * Date.now()),
-    string: randomBytes(48).toString('hex'),
-    boolean: true,
-    null: null,
-    array: [
-      1,
-      2,
-    ],
-    object: {
-      key: 'value',
-    },
-  };
-
-  await response.send(jsonContent);
-
-  for await (const chunk of reader) {
-    const s = chunk.toString();
-    const data = JSON.parse(s);
-    t.deepEqual(data, {
-      ...jsonContent,
-      date: jsonContent.date.toISOString(),
-    });
-  }
-
-  t.is(response.headers['content-type'], 'application/json;charset=utf-8');
-});
-
-test('SendJsonMiddleware.charsetAsBufferEncoding covers all branches', (t) => {
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('utf-8'), 'utf-8');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('utf8'), 'utf-8');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('latin1'), 'latin1');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('iso-8859-1'), 'latin1');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('ascii'), 'latin1');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('binary'), 'latin1');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('utf16le'), 'utf16le');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('utf-16le'), 'utf16le');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('ucs-2'), 'utf16le');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('ucs2'), 'utf16le');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('base64'), 'base64');
-  t.is(SendJsonMiddleware.charsetAsBufferEncoding('hex'), 'hex');
-});
-
-test('SendJsonMiddleware: setMediaType false but setCharset true appends charset only', async (t) => {
-  const stream = new PassThrough();
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  const middleware = new SendJsonMiddleware({ setMediaType: false });
-  middleware.execute({ response });
-  await response.send({ foo: 'bar' });
-  t.is(response.headers['content-type'], ';charset=utf-8');
-});
-
-test('SendJsonMiddleware: setCharset false still sets application/json', async (t) => {
-  const stream = new PassThrough();
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  const middleware = new SendJsonMiddleware({ setCharset: false });
-  middleware.execute({ response });
-  await response.send({ foo: 'bar' });
-  t.is(response.headers['content-type'], 'application/json');
-});
-
-test('SendJsonMiddleware: setMediaType false and setCharset false does not set content-type', async (t) => {
-  const stream = new PassThrough();
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  const middleware = new SendJsonMiddleware({ setMediaType: false, setCharset: false });
-  middleware.execute({ response });
-  await response.send({ foo: 'bar' });
-  t.falsy(response.headers['content-type']);
-});
-
-test('SendJsonMiddleware: custom defaultCharset (latin1)', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  const middleware = new SendJsonMiddleware({ defaultCharset: 'latin1' });
-  middleware.execute({ response });
-  await response.send({ foo: 'bär' });
-  t.regex(String(response.headers['content-type']), /charset=latin1/);
-  for await (const chunk of reader) {
-    t.is(chunk.toString('latin1'), JSON.stringify({ foo: 'bär' }));
-  }
-});
-
-test('SendJsonMiddleware: respects existing content-type with charset', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  response.headers['content-type'] = 'application/json; charset=utf-16le';
-  const middleware = new SendJsonMiddleware();
-  middleware.execute({ response });
-  await response.send({ foo: 'bar' });
-  t.regex(String(response.headers['content-type']), /charset=utf-16le/);
-  for await (const chunk of reader) {
-    t.is(chunk.toString('utf16le'), JSON.stringify({ foo: 'bar' }));
-  }
-});
-
-test('SendJsonMiddleware: adds charset if content-type is just "application/json"', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  response.headers['content-type'] = 'application/json';
-  const middleware = new SendJsonMiddleware();
-  middleware.execute({ response });
-  await response.send({ foo: 'bar' });
-  t.is(response.headers['content-type'], 'application/json;charset=utf-8');
-  for await (const chunk of reader) {
-    t.is(chunk.toString('utf-8'), JSON.stringify({ foo: 'bar' }));
-  }
-});
-
-test('SendJsonMiddleware: quoted charset in content-type', async (t) => {
-  const stream = new PassThrough();
-  const reader = new PassThrough();
-  stream.pipe(reader);
-  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
-  response.headers['content-type'] = 'application/json; charset="utf-8"';
-  const middleware = new SendJsonMiddleware();
-  middleware.execute({ response });
-  await response.send({ foo: 'bar' });
-  t.regex(String(response.headers['content-type']), /charset="?utf-8"?/);
-  for await (const chunk of reader) {
-    t.is(chunk.toString('utf-8'), JSON.stringify({ foo: 'bar' }));
-  }
-});
-
-test('SendJsonMiddleware: does nothing for streaming response', (t) => {
-  const response = new HttpResponse({ stream: new PassThrough(), onSendHeaders: () => {} });
-  response.isStreaming = true;
-  const middleware = new SendJsonMiddleware();
-  middleware.execute({ response });
-  // Should not throw or modify body
-  t.notThrows(() => { for (const function_ of response.finalizers) function_(response); });
-});
-
-test('SendJsonMiddleware: does nothing for Buffer body', (t) => {
-  const response = new HttpResponse({ stream: new PassThrough(), onSendHeaders: () => {} });
-  response.body = Buffer.from('foo');
-  const middleware = new SendJsonMiddleware();
-  middleware.execute({ response });
-  t.notThrows(() => { for (const function_ of response.finalizers) function_(response); });
-  t.true(Buffer.isBuffer(response.body));
-});
-
-test('SendJsonMiddleware: does nothing for null/undefined body', (t) => {
-  const response = new HttpResponse({ stream: new PassThrough(), onSendHeaders: () => {} });
-  response.body = null;
-  const middleware = new SendJsonMiddleware();
-  middleware.execute({ response });
-  t.notThrows(() => { for (const function_ of response.finalizers) function_(response); });
-  response.body = undefined;
-  t.notThrows(() => { for (const function_ of response.finalizers) function_(response); });
-});

package/test/sanity.js

@@ -1,10 +0,0 @@
-import test from 'ava';
-
-test('sync test', (t) => {
-  t.pass();
-});
-
-test('async test', async (t) => {
-  const bar = Promise.resolve('bar');
-  t.is(await bar, 'bar');
-});