Fix demo rating average calculation and add tests

package.json

@@ -7,6 +7,7 @@
     "build": "next build",
     "prestart": "node scripts/prepare-standalone.mjs",
     "start": "node .next/standalone/server.js",
+    "test": "node --test tests/*.test.mjs",
     "lint": "eslint",
     "typecheck": "tsc --noEmit"
   },

src/lib/tools.ts

@@ -11,6 +11,7 @@ type NewTool = Omit<
 type DemoState = {
   tools: SupplyChainTool[];
   ratings: Map<string, number>;
+  ratingSums: Map<string, number>;
 };
 
 declare global {
@@ -122,6 +123,7 @@ function getDemoState(): DemoState {
   globalThis.__chainkitDemoState ??= {
     tools: demoTools.map((tool) => ({ ...tool })),
     ratings: new Map(),
+    ratingSums: new Map(),
   };
   return globalThis.__chainkitDemoState;
 }
@@ -319,11 +321,12 @@ export async function rateTool(toolId: string, voterId: string, rating: number)
 
     const key = `${toolId}:${voterId}`;
     const previousRating = state.ratings.get(key);
-    const total = tool.averageRating * tool.ratingCount;
+    const total = state.ratingSums.get(toolId) ?? tool.averageRating * tool.ratingCount;
     const nextCount = tool.ratingCount + (previousRating === undefined ? 1 : 0);
     const nextTotal = total - (previousRating ?? 0) + rating;
     state.ratings.set(key, rating);
-    tool.averageRating = Number((nextTotal / nextCount).toFixed(1));
+    state.ratingSums.set(toolId, nextTotal);
+    tool.averageRating = nextTotal / nextCount;
     tool.ratingCount = nextCount;
     return tool;
   }

tests/demo-ratings.test.mjs

@@ -0,0 +1,137 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createServer } from "node:net";
+import { fileURLToPath } from "node:url";
+import { after, before, test } from "node:test";
+
+const projectRoot = fileURLToPath(new URL("..", import.meta.url));
+let server;
+let serverOutput = "";
+let baseUrl;
+
+async function getAvailablePort() {
+  const socket = createServer();
+  socket.listen(0, "127.0.0.1");
+  await once(socket, "listening");
+  const address = socket.address();
+  assert(address && typeof address === "object");
+  const { port } = address;
+  socket.close();
+  await once(socket, "close");
+  return port;
+}
+
+async function waitForServer() {
+  const deadline = Date.now() + 30_000;
+  while (Date.now() < deadline) {
+    if (server.exitCode !== null) {
+      throw new Error(`Next.js exited before becoming ready.\n${serverOutput}`);
+    }
+    try {
+      const response = await fetch(`${baseUrl}/api/tools`);
+      if (response.status === 405) return;
+    } catch {
+      // The server is still starting.
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Timed out waiting for Next.js.\n${serverOutput}`);
+}
+
+async function createTool(label) {
+  const response = await fetch(`${baseUrl}/api/tools`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      name: `Rating test ${label}`,
+      summary: "Temporary tool used by the demo rating integration tests.",
+      category: "Planning",
+      repoUrl: `https://github.com/chainkit-test/${label}`,
+      websiteUrl: "",
+      submittedBy: "Automated test",
+    }),
+  });
+  assert.equal(response.status, 201);
+  const body = await response.json();
+  return body.tool;
+}
+
+async function rateTool(toolId, voterId, rating) {
+  const response = await fetch(`${baseUrl}/api/ratings`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ toolId, voterId, rating }),
+  });
+  assert.equal(response.status, 200);
+  return response.json();
+}
+
+before(async () => {
+  const port = await getAvailablePort();
+  baseUrl = `http://127.0.0.1:${port}`;
+  server = spawn(
+    process.execPath,
+    ["node_modules/next/dist/bin/next", "dev", "--hostname", "127.0.0.1", "--port", String(port)],
+    {
+      cwd: projectRoot,
+      env: {
+        ...process.env,
+        BIGQUERY_PROJECT_ID: "",
+        BIGQUERY_DATASET: "",
+        NEXT_TELEMETRY_DISABLED: "1",
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+  server.stdout.on("data", (chunk) => { serverOutput += chunk; });
+  server.stderr.on("data", (chunk) => { serverOutput += chunk; });
+  await waitForServer();
+});
+
+after(async () => {
+  if (!server || server.exitCode !== null) return;
+  server.kill("SIGTERM");
+  await once(server, "exit");
+});
+
+test("records a new rating", async () => {
+  const tool = await createTool("new-rating");
+  const aggregate = await rateTool(tool.id, "00000000-0000-4000-8000-000000000001", 4);
+
+  assert.deepEqual(aggregate, { averageRating: 4, ratingCount: 1 });
+});
+
+test("updates an existing voter without increasing the count", async () => {
+  const tool = await createTool("updated-rating");
+  const voterId = "00000000-0000-4000-8000-000000000002";
+
+  await rateTool(tool.id, voterId, 5);
+  const aggregate = await rateTool(tool.id, voterId, 2);
+
+  assert.deepEqual(aggregate, { averageRating: 2, ratingCount: 1 });
+});
+
+test("counts ratings from distinct voters", async () => {
+  const tool = await createTool("rating-count");
+
+  await rateTool(tool.id, "00000000-0000-4000-8000-000000000003", 5);
+  const aggregate = await rateTool(tool.id, "00000000-0000-4000-8000-000000000004", 3);
+
+  assert.deepEqual(aggregate, { averageRating: 4, ratingCount: 2 });
+});
+
+test("keeps the unrounded average for ratings 2, 1, 1, 1", async () => {
+  const tool = await createTool("rounding-regression");
+  const ratings = [2, 1, 1, 1];
+  let aggregate;
+
+  for (const [index, rating] of ratings.entries()) {
+    const voterId = `00000000-0000-4000-8000-${String(index + 5).padStart(12, "0")}`;
+    aggregate = await rateTool(tool.id, voterId, rating);
+  }
+
+  assert.equal(aggregate.averageRating, 1.25);
+  assert.equal(aggregate.averageRating.toFixed(1), "1.3");
+  assert.equal(aggregate.ratingCount, 4);
+});