Add TTLMap tests

Author: TheKodeToad

backend/package.json

@@ -10,7 +10,7 @@
 		"migration": "pnpm run _node src/storage/main.ts",
 		"typecheck": "tsc",
 		"lint": "eslint",
-		"test": "node --import=./registerSWC.js --test src/**/*.test.ts",
+		"test": "node --import=./registerSWC.js --enable-source-maps --test src/**/*.test.ts",
 		"_node": "node --env-file=.env --disable-proto=throw --disallow-code-generation-from-strings --experimental-transform-types"
 	},
 	"dependencies": {

backend/src/common/ttlMap.test.ts

@@ -0,0 +1,124 @@
+import { MINUTE, SECOND } from "#common/time.ts";
+import { TTLMap } from "#common/ttlMap.ts";
+import assert from "node:assert";
+import test, { suite } from "node:test";
+
+let time = 0;
+
+function mockTime<T>(callback: () => T): T {
+	// reset mocked value
+	time = 0;
+
+	const oldDateNow = Date.now;
+	Date.now = () => time;
+
+	try {
+		return callback();
+	} finally {
+		Date.now = oldDateNow;
+	}
+}
+
+function assertConsistentData<V>(map: TTLMap<string, V>, data: Record<string, V>): void {
+	assert.equal(map.size, Object.keys(data).length, "map size == data size");
+	assert.deepEqual([...map.keys()], Object.keys(data), "map keys == data keys");
+	assert.deepEqual([...map.values()], Object.values(data), "map values == data values");
+	assert.deepEqual([...map.entries()], Object.entries(data), "map entries == data entries");
+
+	const fromForEach: [string, V][] = [];
+	map.forEach((value, key) => fromForEach.push([key, value]));
+	assert.deepEqual(fromForEach, Object.entries(data), "forEach entries == data entries");
+
+	const fromForOf: [string, V][] = [];
+
+	for (const [key, value] of map)
+		fromForOf.push([key, value]);
+
+	for (const key in data)
+		assert.ok(map.has(key), `map.has('${key}')`);
+
+	assert.deepEqual(fromForOf, Object.entries(data), "for of entries == data entries");
+}
+
+function assertInternalData<V>(map: TTLMap<string, V>, data: Record<string, V>): void {
+	assert.deepEqual(
+		[...map["_map"].entries()].map(([key, [value]]) => [key, value]),
+		Object.entries(data)
+	);
+}
+
+suite("TTLMap", () => {
+	test("instant expiry", () => mockTime(() => {
+		const map: TTLMap<string, number> = new TTLMap(0);
+
+		map.set("a", 1);
+		map.set("b", 2);
+		map.set("c", 3);
+
+		assertConsistentData(map, {});
+		assertInternalData(map, { a: 1, b: 2, c: 3 });
+
+		map.cleanup();
+		assertConsistentData(map, {});
+		assertInternalData(map, {});
+	}));
+
+	test("staggered expiry", () => mockTime(() => {
+		const map: TTLMap<string, number> = new TTLMap(MINUTE);
+
+		map.set("a", 1);
+		assertConsistentData(map, { a: 1 });
+		assertInternalData(map, { a: 1 });
+		time += 20 * SECOND;
+
+		map.set("b", 2);
+		assertConsistentData(map, { a: 1, b: 2 });
+		assertInternalData(map, { a: 1, b: 2 });
+		time += 20 * SECOND;
+
+		map.set("c", 3);
+		assertConsistentData(map, { a: 1, b: 2, c: 3 });
+		assertInternalData(map, { a: 1, b: 2, c: 3 });
+		time += 20 * SECOND;
+
+		map.set("d", 4);
+		assertConsistentData(map, { b: 2, c: 3, d: 4 });
+		assertInternalData(map, { a: 1, b: 2, c: 3, d: 4 });
+		time += 20 * SECOND;
+
+		assertConsistentData(map, { c: 3, d: 4 });
+		assertInternalData(map, { a: 1, b: 2, c: 3, d: 4 });
+		map.cleanup();
+		assertInternalData(map, { c: 3, d: 4 });
+
+		time += 1 * MINUTE;
+		assertConsistentData(map, {});
+		assertInternalData(map, { c: 3, d: 4 });
+		map.cleanup();
+		assertConsistentData(map, {});
+		assertInternalData(map, {});
+	}));
+
+	test("has", () => mockTime(() => {
+		const map: TTLMap<string, null> = new TTLMap(0);
+		map.set("a", null);
+		assert.ok(!map.has("a"), "!map.has('a')");
+	}));
+
+	test("precision", () => mockTime(() => {
+		const map: TTLMap<string, number> = new TTLMap(SECOND);
+
+		map.set("a", 0);
+		time += 1;
+		map.set("b", 1);
+		time += SECOND - 2;
+
+		assertConsistentData(map, { a: 0, b: 1 });
+		time += 1;
+
+		assertConsistentData(map, { b: 1 });
+		time += 1;
+
+		assertConsistentData(map, {});
+	}));
+});

backend/src/common/ttlMap.ts

@@ -23,7 +23,7 @@ export class TTLMap<K, V> {
 	}
 
 	private _isExpired(now: number, date: number): boolean {
-		return (now - date) > this._ttl;
+		return (now - date) >= this._ttl;
 	}
 
 	get size(): number {
@@ -70,7 +70,7 @@ export class TTLMap<K, V> {
 			return false;
 
 		const [_, date] = this._map.get(key)!;
-		return this._isExpired(Date.now(), date);
+		return !this._isExpired(Date.now(), date);
 	}
 
 	set(key: K, value: V): this {
@@ -86,8 +86,12 @@ export class TTLMap<K, V> {
 				yield [key, value];
 	}
 
-	keys(): IterableIterator<K> {
-		return this._map.keys();
+	*keys(): IterableIterator<K> {
+		const now = Date.now();
+
+		for (const [key, [_, date]] of this._map)
+			if (!this._isExpired(now, date))
+				yield key;
 	}
 
 	*values(): IterableIterator<V> {