@marianmeres/http-utils 1.0.2 → 1.2.0

package/src/api.ts

@@ -1,198 +0,0 @@
-import { dset } from 'dset/merge';
-import { createHttpError } from './error.js';
-
-// this is all very opinionated and may not be useful for every use case...
-// there is no magic added over plain fetch calls, just more opinionated and dry api
-
-interface BaseParams {
-	method: 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT';
-	path: string;
-}
-
-interface FetchParams {
-	data?: any;
-	token?: string | null;
-	headers?: any;
-	signal?: any;
-	credentials?: null | 'omit' | 'same-origin' | 'include';
-	raw?: null | boolean;
-	assert?: null | boolean;
-}
-
-type BaseFetchParams = BaseParams & FetchParams; // Exclude<Drinks, Soda> |
-
-const _fetchRaw = async ({
-	method,
-	path,
-	data = null,
-	token = null,
-	headers = null,
-	signal = null,
-	credentials,
-}: BaseFetchParams) => {
-	headers = Object.entries(headers || {}).map(([k, v]) => ({ [k.toLowerCase()]: v }));
-	const opts: any = { method, credentials, headers, signal };
-
-	if (data) {
-		const isObj = typeof data === 'object';
-
-		// multipart/form-data -- no explicit Content-Type
-		if (data instanceof FormData) {
-			opts.body = data;
-		}
-		// cover 99% use cases (may not fit all)
-		else {
-			// if not stated, assuming json
-			if (isObj || !headers['content-type']) {
-				opts.headers['content-type'] = 'application/json';
-			}
-			opts.body = JSON.stringify(data);
-		}
-	}
-
-	// opinionated convention
-	if (token) {
-		opts.headers['authorization'] = `Bearer ${token}`;
-	}
-
-	return await fetch(path, opts);
-};
-
-const _fetch = async (
-	params: BaseFetchParams,
-	respHeaders = null,
-	_dumpParams = false
-) => {
-	if (_dumpParams) return params;
-
-	const r = await _fetchRaw(params);
-	if (params.raw) return r;
-
-	// quick-n-dirty reference to headers (so it's still accessible over this api wrap)
-	if (respHeaders) {
-		Object.assign(
-			respHeaders,
-			[...r.headers.entries()].reduce((m, [k, v]) => ({ ...m, [k]: v }), {}),
-			// adding status/text under special keys
-			{
-				__http_status_code__: r.status,
-				__http_status_text__: r.statusText,
-			}
-		);
-	}
-
-	let body: string = await r.text();
-	// prettier-ignore
-	try { body = JSON.parse(body); } catch (e) {}
-
-	params.assert ??= true; // default is true
-
-	if (!r.ok && params.assert) {
-		throw createHttpError(r.status, null, body);
-	}
-
-	return body;
-};
-
-export const createHttpApi = (
-	base: string | null,
-	defaults?: Partial<BaseFetchParams> | (() => Promise<Partial<BaseFetchParams>>)
-) => {
-	const _merge = (a: any, b: any): any => {
-		const wrap = { result: a };
-		dset(wrap, 'result', b);
-		return wrap.result;
-	};
-
-	const _getDefs = async () => {
-		return new Promise<Partial<BaseFetchParams>>(async (resolve) => {
-			if (typeof defaults === 'function') {
-				resolve(await defaults());
-			} else {
-				resolve(defaults || {});
-			}
-		});
-	};
-
-	return {
-		// GET
-		async get(
-			path: string,
-			params?: FetchParams,
-			respHeaders = null,
-			_dumpParams = false
-		) {
-			path = `${base || ''}` + path;
-			return _fetch(
-				_merge(await _getDefs(), { ...params, method: 'GET', path }),
-				respHeaders,
-				_dumpParams
-			);
-		},
-
-		// POST
-		async post(
-			path: string,
-			data = null,
-			params?: FetchParams,
-			respHeaders = null,
-			_dumpParams = false
-		) {
-			path = `${base || ''}` + path;
-			return _fetch(
-				_merge(await _getDefs(), { ...(params || {}), data, method: 'POST', path }),
-				respHeaders,
-				_dumpParams
-			);
-		},
-
-		// PUT
-		async put(
-			path: string,
-			data = null,
-			params?: FetchParams,
-			respHeaders = null,
-			_dumpParams = false
-		) {
-			path = `${base || ''}` + path;
-			return _fetch(
-				_merge(await _getDefs(), { ...(params || {}), data, method: 'PUT', path }),
-				respHeaders,
-				_dumpParams
-			);
-		},
-
-		// PATCH
-		async patch(
-			path: string,
-			data = null,
-			params?: FetchParams,
-			respHeaders = null,
-			_dumpParams = false
-		) {
-			path = `${base || ''}` + path;
-			return _fetch(
-				_merge(await _getDefs(), { ...(params || {}), data, method: 'PATCH', path }),
-				respHeaders,
-				_dumpParams
-			);
-		},
-
-		// DELETE
-		// https://stackoverflow.com/questions/299628/is-an-entity-body-allowed-for-an-http-delete-request
-		async del(
-			path: string,
-			data = null,
-			params?: FetchParams,
-			respHeaders = null,
-			_dumpParams = false
-		) {
-			path = `${base || ''}` + path;
-			return _fetch(
-				_merge(await _getDefs(), { ...(params || {}), data, method: 'DELETE', path }),
-				respHeaders,
-				_dumpParams
-			);
-		},
-	};
-};

package/src/error.ts

@@ -1,162 +0,0 @@
-import { HTTP_STATUS } from './status.js';
-
-// opinionated base for all
-class HttpError extends Error {
-	public name = 'HttpError';
-	public status = HTTP_STATUS.ERROR_SERVER.INTERNAL_SERVER_ERROR.CODE;
-	public statusText = HTTP_STATUS.ERROR_SERVER.INTERNAL_SERVER_ERROR.TEXT;
-	public body: string | null = null;
-}
-
-// some more specific instances of the well known ones...
-
-// client
-
-class BadRequest extends HttpError {
-	public name = 'HttpBadRequestError';
-	public status = HTTP_STATUS.ERROR_CLIENT.BAD_REQUEST.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.BAD_REQUEST.TEXT;
-}
-
-class Unauthorized extends HttpError {
-	public name = 'HttpUnauthorizedError';
-	public status = HTTP_STATUS.ERROR_CLIENT.UNAUTHORIZED.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.UNAUTHORIZED.TEXT;
-}
-
-class Forbidden extends HttpError {
-	public name = 'HttpForbiddenError';
-	public status = HTTP_STATUS.ERROR_CLIENT.FORBIDDEN.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.FORBIDDEN.TEXT;
-}
-
-class NotFound extends HttpError {
-	public name = 'HttpNotFoundError';
-	public status = HTTP_STATUS.ERROR_CLIENT.NOT_FOUND.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.NOT_FOUND.TEXT;
-}
-
-class MethodNotAllowed extends HttpError {
-	public name = 'HttpMethodNotAllowedError';
-	public status = HTTP_STATUS.ERROR_CLIENT.METHOD_NOT_ALLOWED.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.METHOD_NOT_ALLOWED.TEXT;
-}
-
-class RequestTimeout extends HttpError {
-	public name = 'HttpRequestTimeoutError';
-	public status = HTTP_STATUS.ERROR_CLIENT.REQUEST_TIMEOUT.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.REQUEST_TIMEOUT.TEXT;
-}
-
-class Conflict extends HttpError {
-	public name = 'HttpConflictError';
-	public status = HTTP_STATUS.ERROR_CLIENT.CONFLICT.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.CONFLICT.TEXT;
-}
-
-class Gone extends HttpError {
-	public name = 'HttpGoneError';
-	public status = HTTP_STATUS.ERROR_CLIENT.GONE.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.GONE.TEXT;
-}
-
-class ImATeapot extends HttpError {
-	public name = 'HttpImATeapotError';
-	public status = HTTP_STATUS.ERROR_CLIENT.IM_A_TEAPOT.CODE;
-	public statusText = HTTP_STATUS.ERROR_CLIENT.IM_A_TEAPOT.TEXT;
-}
-
-// server
-
-class InternalServerError extends HttpError {
-	public name = 'HttpInternalServerError';
-}
-
-class NotImplemented extends HttpError {
-	public name = 'HttpServiceUnavailableError';
-	public status = HTTP_STATUS.ERROR_SERVER.NOT_IMPLEMENTED.CODE;
-	public statusText = HTTP_STATUS.ERROR_SERVER.NOT_IMPLEMENTED.TEXT;
-}
-
-class BadGateway extends HttpError {
-	public name = 'HttpBadGatewayError';
-	public status = HTTP_STATUS.ERROR_SERVER.BAD_GATEWAY.CODE;
-	public statusText = HTTP_STATUS.ERROR_SERVER.BAD_GATEWAY.TEXT;
-}
-
-class ServiceUnavailable extends HttpError {
-	public name = 'HttpServiceUnavailableError';
-	public status = HTTP_STATUS.ERROR_SERVER.SERVICE_UNAVAILABLE.CODE;
-	public statusText = HTTP_STATUS.ERROR_SERVER.SERVICE_UNAVAILABLE.TEXT;
-}
-
-//
-export const HTTP_ERROR = {
-	// base
-	HttpError,
-	// client
-	BadRequest,
-	Unauthorized,
-	Forbidden,
-	NotFound,
-	MethodNotAllowed,
-	RequestTimeout,
-	Conflict,
-	Gone,
-	ImATeapot,
-	// server
-	InternalServerError,
-	NotImplemented,
-	BadGateway,
-	ServiceUnavailable,
-};
-
-const _wellKnownCtorMap = {
-	'400': BadRequest,
-	'401': Unauthorized,
-	'403': Forbidden,
-	'404': NotFound,
-	'405': MethodNotAllowed,
-	'408': RequestTimeout,
-	'409': Conflict,
-	'410': Gone,
-	'418': ImATeapot,
-	//
-	'500': InternalServerError,
-	'501': NotImplemented,
-	'502': BadGateway,
-	'503': ServiceUnavailable,
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
-export const createHttpError = (
-	code: number | string,
-	message?: string | null,
-	body?: any,
-	cause?: any
-) => {
-	const fallback = HTTP_STATUS.ERROR_SERVER.INTERNAL_SERVER_ERROR;
-
-	code = Number(code);
-	if (isNaN(code) || !(code >= 400 && code < 600)) code = fallback.CODE;
-
-	const found = HTTP_STATUS.findByCode(code);
-	const statusText = found?.TEXT ?? fallback.TEXT;
-
-	// opinionated convention
-	if (typeof body === 'string') {
-		// prettier-ignore
-		try { body = JSON.parse(body); } catch (e) {}
-	}
-
-	// try to find the well known one, otherwise fallback to generic
-	const ctor =
-		_wellKnownCtorMap[`${code}` as keyof typeof _wellKnownCtorMap] ?? HttpError;
-
-	let e = new ctor(message || statusText, { cause });
-	e.status = found?.CODE ?? fallback.CODE;
-	e.statusText = statusText;
-	e.body = body;
-
-	return e;
-};

package/src/status.ts

@@ -1,107 +0,0 @@
-export class HTTP_STATUS {
-	// 1xx
-	// prettier-ignore
-	static readonly INFO = {
-		CONTINUE:                        { CODE: 100, TEXT: 'Continue' },
-		SWITCHING_PROTOCOLS:             { CODE: 101, TEXT: 'Switching Protocols' },
-		PROCESSING:                      { CODE: 102, TEXT: 'Processing' },
-		EARLY_HINTS:                     { CODE: 103, TEXT: 'Early Hints' },
-	};
-
-	// 2xx
-	// prettier-ignore
-	static readonly SUCCESS = {
-		OK:                              { CODE: 200, TEXT: 'OK' },
-		NON_AUTHORITATIVE_INFO:          { CODE: 203, TEXT: 'Non-Authoritative Information' },
-		ACCEPTED:                        { CODE: 202, TEXT: 'Accepted' },
-		NO_CONTENT:                      { CODE: 204, TEXT: 'No Content' },
-		RESET_CONTENT:                   { CODE: 205, TEXT: 'Reset Content' },
-		PARTIAL_CONTENT:                 { CODE: 206, TEXT: 'Partial Content' },
-		MULTI_STATUS:                    { CODE: 207, TEXT: 'Multi-Status' },
-		ALREADY_REPORTED:                { CODE: 208, TEXT: 'Already Reported' },
-		IM_USED:                         { CODE: 226, TEXT: 'IM Used' }, // ?
-	};
-
-	// 3xx
-	// prettier-ignore
-	static readonly REDIRECT = {
-		MUTLIPLE_CHOICES:                { CODE: 300, TEXT: 'Multiple Choices' },
-		MOVED_PERMANENTLY:               { CODE: 301, TEXT: 'Moved Permanently' },
-		FOUND:                           { CODE: 302, TEXT: 'Found' },
-		SEE_OTHER:                       { CODE: 303, TEXT: 'See Other' },
-		NOT_MODIFIED:                    { CODE: 304, TEXT: 'Not Modified' },
-		TEMPORARY_REDIRECT:              { CODE: 307, TEXT: 'Temporary Redirect' },
-		PERMANENT_REDIRECT:              { CODE: 308, TEXT: 'Permanent Redirect' },
-	};
-
-	// 4xx
-	// prettier-ignore
-	static readonly ERROR_CLIENT = {
-		BAD_REQUEST:                     { CODE: 400, TEXT: 'Bad Request' },
-		UNAUTHORIZED:                    { CODE: 401, TEXT: 'Unauthorized' },
-		PAYMENT_REQUIRED_EXPERIMENTAL:   { CODE: 402, TEXT: 'Payment Required Experimental' },
-		FORBIDDEN:                       { CODE: 403, TEXT: 'Forbidden' },
-		NOT_FOUND:                       { CODE: 404, TEXT: 'Not Found' },
-		METHOD_NOT_ALLOWED:              { CODE: 405, TEXT: 'Method Not Allowed' },
-		NOT_ACCEPTABLE:                  { CODE: 406, TEXT: 'Not Acceptable' },
-		PROXY_AUTHENTICATION_REQUIRED:   { CODE: 407, TEXT: 'Proxy Authentication Required' },
-		REQUEST_TIMEOUT:                 { CODE: 408, TEXT: 'Request Timeout' },
-		CONFLICT:                        { CODE: 409, TEXT: 'Conflict' },
-		GONE:                            { CODE: 410, TEXT: 'Gone' },
-		LENGTH_REQUIRED:                 { CODE: 411, TEXT: 'Length Required' },
-		PRECONDITION_FAILED:             { CODE: 412, TEXT: 'Precondition Failed' },
-		PAYLOAD_TOO_LARGE:               { CODE: 413, TEXT: 'Payload Too Large' },
-		URI_TOO_LONG:                    { CODE: 414, TEXT: 'URI Too Long' },
-		UNSUPPORTED_MEDIA_TYPE:          { CODE: 415, TEXT: 'Unsupported Media Type' },
-		RANGE_NOT_SATISFIABLE:           { CODE: 416, TEXT: 'Range Not Satisfiable' },
-		EXPECTATION_FAILED:              { CODE: 417, TEXT: 'Expectation Failed' },
-		IM_A_TEAPOT:                     { CODE: 418, TEXT: "I'm a teapot" },
-		MISDIRECTED_REQUEST:             { CODE: 421, TEXT: 'Misdirected Request' },
-		UNPROCESSABLE_CONTENT:           { CODE: 422, TEXT: 'Unprocessable Content' },
-		LOCKED:                          { CODE: 423, TEXT: 'Locked' },
-		FAILED_DEPENDENCY:               { CODE: 424, TEXT: 'Failed Dependency' },
-		TOO_EARLY_EXPERIMENTAL:          { CODE: 425, TEXT: 'Too Early Experimental' },
-		UPGRADE_REQUIRED:                { CODE: 426, TEXT: 'Upgrade Required' },
-		PRECONDITION_REQUIRED:           { CODE: 428, TEXT: 'Precondition Required' },
-		TOO_MANY_REQUESTS:               { CODE: 429, TEXT: 'Too Many Requests' },
-		REQUEST_HEADER_FIELDS_TOO_LARGE: { CODE: 431, TEXT: 'Request Header Fields Too Large' },
-		UNAVAILABLE_FOR_LEGAL_REASONS:   { CODE: 451, TEXT: 'Unavailable For Legal Reasons' },
-	};
-
-	// 5xx
-	// prettier-ignore
-	static readonly ERROR_SERVER = {
-		INTERNAL_SERVER_ERROR:           { CODE: 500, TEXT: 'Internal Server Error' },
-		NOT_IMPLEMENTED:                 { CODE: 501, TEXT: 'Not Implemented' },
-		BAD_GATEWAY:                     { CODE: 502, TEXT: 'Bad Gateway' },
-		SERVICE_UNAVAILABLE:             { CODE: 503, TEXT: 'Service Unavailable' },
-		GATEWAY_TIMEOUT:                 { CODE: 504, TEXT: 'Gateway Timeout' },
-		HTTP_VERSION_NOT_SUPPORTED:      { CODE: 505, TEXT: 'HTTP Version Not Supported' },
-		VARIANT_ALSO_NEGOTIATES:         { CODE: 506, TEXT: 'Variant Also Negotiates' },
-		INSUFFICIENT_STORAGE:            { CODE: 507, TEXT: 'Insufficient Storage' },
-		LOOP_DETECTED:                   { CODE: 508, TEXT: 'Loop Detected' },
-		NOT_EXTENDED:                    { CODE: 510, TEXT: 'Not Extended' },
-		NETWORK_AUTH_REQUIRED:           { CODE: 511, TEXT: 'Network Authentication Required' },
-	};
-
-	//
-	static findByCode(
-		code: number | string
-	): { CODE: number; TEXT: string; _TYPE: string; _KEY: string } | null {
-		const keys: (keyof typeof HTTP_STATUS)[] = [
-			'INFO',
-			'SUCCESS',
-			'REDIRECT',
-			'ERROR_CLIENT',
-			'ERROR_SERVER',
-		];
-		for (const _TYPE of keys) {
-			for (const [_KEY, data] of Object.entries(HTTP_STATUS[_TYPE]) as any) {
-				if (data.CODE == code) {
-					return { ...data, _TYPE, _KEY };
-				}
-			}
-		}
-		return null;
-	}
-}

package/tests/api.test.js

@@ -1,136 +0,0 @@
-import { TestRunner } from '@marianmeres/test-runner';
-import { strict as assert } from 'node:assert';
-import { createServer } from 'node:http';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { HTTP_ERROR, createHttpApi } from '../dist/index.cjs';
-
-let server;
-const hostname = '127.0.0.1';
-const port = 3456;
-const url = `http://${hostname}:${port}`;
-
-// https://nodejs.org/en/learn/modules/anatomy-of-an-http-transaction
-const collectBody = async (request) =>
-	new Promise((resolve) => {
-		let body = [];
-		request
-			.on('data', (chunk) => body.push(chunk))
-			.on('end', () => resolve(Buffer.concat(body).toString()));
-	});
-
-const suite = new TestRunner(path.basename(fileURLToPath(import.meta.url)), {
-	beforeEach: async () => {
-		server = createServer(async (req, res) => {
-			res.setHeader('Content-Type', 'application/json');
-			if (req.url === '/echo') {
-				res.statusCode = 200;
-				if (req.method === 'POST') {
-					res.end(await collectBody(req));
-				} else {
-					res.end('{"foo":"bar"}');
-				}
-			} else {
-				res.statusCode = 404;
-				res.end('{"some":{"deep":"message"}}');
-			}
-		});
-		return new Promise((resolve) => server.listen(port, hostname, resolve));
-	},
-	afterEach: async () => new Promise((resolve) => server.close(resolve)),
-});
-
-suite.test('createHttpApi GET', async () => {
-	let api = createHttpApi();
-	let respHeaders = {};
-
-	let r = await api.get(`${url}/echo`, {}, respHeaders);
-	assert(r.foo === 'bar');
-	assert(respHeaders.__http_status_code__ === 200);
-});
-
-suite.test('createHttpApi base option', async () => {
-	let api = createHttpApi(url);
-	let respHeaders = {};
-
-	let r = await api.get(`/echo`, {}, respHeaders);
-	assert(r.foo === 'bar');
-	assert(respHeaders.__http_status_code__ === 200);
-});
-
-suite.test('createHttpApi RAW', async () => {
-	let api = createHttpApi();
-	let headers = {};
-
-	// raw
-	let r = await api.get(`${url}/echo`, { raw: true });
-	assert(r instanceof Response);
-});
-
-suite.test('createHttpApi error', async () => {
-	let api = createHttpApi();
-
-	let err;
-	try {
-		let r = await api.get(`${url}/asdf`);
-		assert(false); // must not be reached
-	} catch (e) {
-		err = e;
-	}
-
-	assert(err instanceof HTTP_ERROR.NotFound);
-	assert(err.body.some.deep === 'message');
-});
-
-suite.test('createHttpApi error { raw: true }', async () => {
-	let api = createHttpApi();
-
-	let r = await api.get(`${url}/asdf`, { raw: true });
-	assert(r instanceof Response);
-	assert(!r.ok);
-});
-
-suite.test('createHttpApi error { assert: false } does not throw', async () => {
-	let api = createHttpApi();
-	let respHeaders = {};
-
-	let r = await api.get(`${url}/asdf`, { assert: false }, respHeaders);
-	assert(r.some.deep === 'message');
-	assert(respHeaders.__http_status_code__ === 404);
-});
-
-suite.test('createHttpApi POST', async () => {
-	let api = createHttpApi();
-	let respHeaders = {};
-
-	let r = await api.post(`${url}/echo`, { hey: 'ho' }, {}, respHeaders);
-	assert(r.hey === 'ho');
-	assert(respHeaders.__http_status_code__ === 200);
-});
-
-suite.test('createHttpApi merge default params', async () => {
-	let api = createHttpApi(null, {
-		headers: { authorization: 'Bearer foo' },
-		method: 'must be ignored',
-		path: 'must be ignored',
-		credentials: 'include',
-	});
-
-	const params = await api.post(
-		'/hoho',
-		{ foo: 'bar' },
-		{ headers: { hey: 'ho' } },
-		null,
-		true
-	);
-	// console.log(params);
-
-	assert(params.headers.authorization === 'Bearer foo');
-	assert(params.headers.hey === 'ho');
-	assert(params.method === 'POST');
-	assert(params.path === '/hoho');
-	assert(params.credentials === 'include');
-	assert(params.data.foo === 'bar');
-});
-
-export default suite;

package/tests/utils.test.js

@@ -1,64 +0,0 @@
-import { TestRunner } from '@marianmeres/test-runner';
-import { strict as assert } from 'node:assert';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { HTTP_ERROR, HTTP_STATUS, createHttpError } from '../dist/index.cjs';
-
-const suite = new TestRunner(path.basename(fileURLToPath(import.meta.url)));
-
-suite.test('HTTP_STATUS.findByCode', () => {
-	const s = HTTP_STATUS.findByCode(200);
-	assert(s.CODE === 200);
-	assert(s.TEXT === 'OK');
-	assert(s._TYPE === 'SUCCESS');
-	assert(s._KEY === 'OK');
-});
-
-suite.test('HTTP_ERROR', () => {
-	let e = new HTTP_ERROR.HttpError();
-	assert(e.toString() === 'HttpError');
-	assert(e.status === HTTP_STATUS.ERROR_SERVER.INTERNAL_SERVER_ERROR.CODE);
-
-	// random client pick
-	e = new HTTP_ERROR.Unauthorized('Foo');
-	assert(e.toString() === 'HttpUnauthorizedError: Foo');
-	assert(e.status === HTTP_STATUS.ERROR_CLIENT.UNAUTHORIZED.CODE);
-	assert(e.statusText === HTTP_STATUS.ERROR_CLIENT.UNAUTHORIZED.TEXT);
-
-	// random server pick
-	e = new HTTP_ERROR.BadGateway('Foo');
-	assert(e.toString() === 'HttpBadGatewayError: Foo');
-	assert(e.status === HTTP_STATUS.ERROR_SERVER.BAD_GATEWAY.CODE);
-	assert(e.statusText === HTTP_STATUS.ERROR_SERVER.BAD_GATEWAY.TEXT);
-});
-
-suite.test('createHttpErrorByCode', () => {
-	// well known
-	let e = createHttpError(404, null, '{"foo":"bar"}', { baz: 'bat' });
-
-	assert(e instanceof HTTP_ERROR.NotFound);
-	assert(e.toString() === 'HttpNotFoundError: Not Found');
-	assert(e.body.foo === 'bar');
-	assert(e.cause.baz === 'bat');
-
-	// NOT well known
-	e = createHttpError(423, null, '{invalid json}', 123);
-	assert(e instanceof HTTP_ERROR.HttpError);
-	assert(e.toString() === 'HttpError: Locked');
-	assert(e.body === '{invalid json}');
-	assert(e.cause === 123);
-
-	// unknown code must fall back to 500
-	e = createHttpError(123, null, '123');
-	assert(e instanceof HTTP_ERROR.InternalServerError);
-	assert(e.toString() === 'HttpInternalServerError: Internal Server Error');
-	assert(e.body === 123); // '123' is a valid json string
-	assert(e.cause === undefined);
-
-	// custom message
-	e = createHttpError(123, 'Hey', '123');
-	assert(e.toString() === 'HttpInternalServerError: Hey');
-	assert(e.body === 123);
-});
-
-export default suite;