src/hero.mjs: Add validateUpgrade(), computeHash() and their helper functions

1 files changed, 169 insertions, 2 deletions

diff --git a/tests/js/hero.mjs b/tests/js/hero.mjs
index b183e9a..bbb03ec 100644
--- a/tests/js/hero.mjs
+++ b/tests/js/hero.mjs
@@ -1,8 +1,7 @@
 import assert        from "node:assert/strict";
-import child_process from "node:child_process";
 import fs            from "node:fs";
 import http          from "node:http";
-import procees       from "node:process";
+import process       from "node:process";
 
 import * as runner from "../runner.mjs";
 import * as u      from "../../src/utils.mjs";
@@ -12,6 +11,12 @@ import {
 	configLogger,
 	logit,
 	makeLogger,
+	isValidMethod,
+	isValidUpgrade,
+	isValidKey,
+	isValidVersion,
+	validateUpgrade,
+	computeHash,
 	interceptorsFn,
 	interceptors,
 	defaultInterceptors,
@@ -192,6 +197,162 @@ const test_makeLogger = async t => {
 	});
 };
 
+const test_isValidMethod = async t => {
+	t.start("isValidMethod()");
+
+	await t.test("we only accept a single value", () => {
+		assert.ok(isValidMethod("GET"));
+		assert.ok(!isValidMethod("get"));
+		assert.ok(!isValidMethod("PUT"));
+	})
+};
+
+const test_isValidUpgrade = async t => {
+	t.start("isValidUpgrade()");
+
+	await t.test("we ignoee the case", () => {
+		assert.ok(isValidUpgrade("Websocket"));
+		assert.ok(isValidUpgrade("WebSocket"));
+		assert.ok(isValidUpgrade("websocket"));
+		assert.ok(!isValidUpgrade("web socket"));
+	});
+};
+
+const test_isValidKey = async t => {
+	t.start("isValidKey()");
+
+	await t.test("RFC example value", () => {
+		const key = "dGhlIHNhbXBsZSBub25jZQ==";
+		assert.ok(isValidKey(key));
+	});
+
+	await t.test("wrong example values", () => {
+		const key1 = "_GhlIHNhbXBsZSBub25jZQ==";
+		const key2 = "dGhlIHNhbXBsZSBub25jZQ=";
+		assert.ok(!isValidKey(key1));
+		assert.ok(!isValidKey(key2));
+	});
+};
+
+const test_isValidVersion = async t => {
+	t.start("isValidVersion()");
+
+	await t.test("we only accept a single value", () => {
+		assert.ok(isValidVersion(13));
+		assert.ok(!isValidVersion(9));
+		assert.ok(!isValidVersion(10));
+		assert.ok(!isValidVersion(11));
+		assert.ok(!isValidVersion(12));
+	});
+};
+
+const test_validateUpgrade = async t => {
+	t.start("validateUpgrade()");
+
+	await t.test("invalid method", () => {
+		assert.deepEqual(validateUpgrade("POST", {}), {
+			isValid: false,
+			response: {
+				status: 405,
+			},
+		});
+	});
+
+	await t.test("missing upgrade", () => {
+		assert.deepEqual(validateUpgrade("GET", {}), {
+			isValid: false,
+			response: {
+				status: 400,
+				body: 'Missing "Upgrade" header\n',
+			},
+		});
+	});
+
+	await t.test("invalid upgrade", () => {
+		assert.deepEqual(validateUpgrade("GET", {
+			"upgrade": "web socket",
+		}), {
+			isValid: false,
+			response: {
+				status: 400,
+				body: 'Invalid "Upgrade" value\n',
+			},
+		});
+	});
+
+	await t.test("missing sec-websocket-key", () => {
+		assert.deepEqual(validateUpgrade("GET", {
+			"upgrade": "websocket",
+		}), {
+			isValid: false,
+			response: {
+				status: 400,
+				body: 'Missing "Sec-WebSocket-Key" header\n',
+			},
+		});
+	});
+
+	await t.test("invalid sec-websocket-key", () => {
+		assert.deepEqual(validateUpgrade("GET", {
+			"upgrade": "websocket",
+			"sec-websocket-key": "bad value",
+		}), {
+			isValid: false,
+			response: {
+				status: 400,
+				body: 'Invalid "Sec-WebSocket-Key" value\n',
+			},
+		});
+	});
+
+	await t.test("missing sec-websocket-version", () => {
+		assert.deepEqual(validateUpgrade("GET", {
+			"upgrade": "websocket",
+			"sec-websocket-key": "aaaaabbbbbcccccdddddee==",
+		}), {
+			isValid: false,
+			response: {
+				status: 400,
+				body: 'Missing "Sec-WebSocket-Version" header\n',
+			},
+		});
+	});
+
+	await t.test("invalid sec-websocket-version", () => {
+		assert.deepEqual(validateUpgrade("GET", {
+			"upgrade": "websocket",
+			"sec-websocket-key": "aaaaabbbbbcccccdddddee==",
+			"sec-websocket-version": "12",
+		}), {
+			isValid: false,
+			response: {
+				status: 400,
+				body: 'Invalid "Sec-WebSocket-Version" value\n',
+			},
+		});
+	});
+
+	await t.test("valid upgrade", () => {
+		assert.deepEqual(validateUpgrade("GET", {
+			"upgrade": "websocket",
+			"sec-websocket-key": "aaaaabbbbbcccccdddddee==",
+			"sec-websocket-version": "13",
+		}), {
+			isValid: true,
+		});
+	});
+};
+
+const test_computeHash = async t => {
+	t.start("computeHash()");
+
+	await t.test("RFC example value", () => {
+		const key  = "dGhlIHNhbXBsZSBub25jZQ==";
+		const hash = "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=";
+		assert.equal(computeHash(key), hash);
+	});
+};
+
 const test_interceptorsFn = async t => {
 	const next = x => x;
 
@@ -2025,6 +2186,12 @@ await runner.runTests([
 	test_configLogger,
 	test_logit,
 	test_makeLogger,
+	test_isValidMethod,
+	test_isValidUpgrade,
+	test_isValidKey,
+	test_isValidVersion,
+	test_validateUpgrade,
+	test_computeHash,
 	test_interceptorsFn,
 	test_chainInterceptors,
 	test_wrapHandler,