test: cover runtime meta failures

Author: roodboi

src/daemon/runtime-cache.ts

@@ -86,7 +86,22 @@ export interface RuntimeCache {
 
 export function createRuntimeCache(opts: {
   readonly onRefresh?: (snapshot: RuntimeSnapshot) => void;
+  readonly deps?: {
+    readonly readProjectsRegistry?: typeof readProjectsRegistry;
+    readonly buildProjectViews?: typeof buildProjectViews;
+    readonly serializeProjectView?: typeof serializeProjectView;
+    readonly resolveProjectMeta?: typeof resolveProjectMeta;
+  };
 }): RuntimeCache {
+  const deps = {
+    readProjectsRegistry:
+      opts.deps?.readProjectsRegistry ?? readProjectsRegistry,
+    buildProjectViews: opts.deps?.buildProjectViews ?? buildProjectViews,
+    serializeProjectView:
+      opts.deps?.serializeProjectView ?? serializeProjectView,
+    resolveProjectMeta: opts.deps?.resolveProjectMeta ?? resolveProjectMeta,
+  } as const;
+
   let snapshot: RuntimeSnapshot | null = null;
   let refreshTask: Promise<void> | null = null;
   let pending = false;
@@ -195,12 +210,12 @@ export function createRuntimeCache(opts: {
     if (!snapshot) {
       await refresh({ reason: "projects" });
     }
-    const registry = await readProjectsRegistry();
+    const registry = await deps.readProjectsRegistry();
     const runtime = filterRuntimeProjects({
       runtime: snapshot?.runtime ?? [],
       includeGlobal,
     });
-    const views = await buildProjectViews({
+    const views = await deps.buildProjectViews({
       registryProjects: registry.projects,
       runtime,
       runtimeOk: health.ok,
@@ -224,7 +239,7 @@ export function createRuntimeCache(opts: {
               return null;
             }
             try {
-              return await resolveProjectMeta({
+              return await deps.resolveProjectMeta({
                 projectName: reg.name,
                 repoRoot: reg.repoRoot,
                 projectDir: reg.projectDir,
@@ -249,7 +264,7 @@ export function createRuntimeCache(opts: {
       runtime_reset_at: runtimeMeta.lastResetAt,
       runtime_reset_count: runtimeMeta.resetCount,
       projects: views.map((view, i) => ({
-        ...serializeProjectView(view),
+        ...deps.serializeProjectView(view),
         ...(includeMeta ? { meta: metas[i] ?? null } : {}),
       })),
     };

tests/runtime-cache.test.ts

@@ -1,5 +1,8 @@
 import { beforeEach, expect, mock, test } from "bun:test";
 
+import { HACK_PROJECT_DIR_PRIMARY } from "../src/constants.ts";
+import type { ProjectView } from "../src/lib/project-views.ts";
+import type { RegisteredProject } from "../src/lib/projects-registry.ts";
 import type { RuntimeProject } from "../src/lib/runtime-projects.ts";
 
 const runtimeQueue: Array<{
@@ -109,6 +112,79 @@ test("runtime cache refresh records healthy snapshot", async () => {
   expect(autoRegisterCalls.length).toBe(1);
 });
 
+test("getProjectsPayload keeps working when resolveProjectMeta fails for one project", async () => {
+  const createdAt = new Date().toISOString();
+
+  const projects: RegisteredProject[] = [
+    {
+      id: "ok",
+      name: "ok",
+      repoRoot: "/tmp/ok",
+      projectDirName: HACK_PROJECT_DIR_PRIMARY,
+      projectDir: "/tmp/ok/.hack",
+      createdAt,
+    },
+    {
+      id: "bad",
+      name: "bad",
+      repoRoot: "/tmp/bad",
+      projectDirName: HACK_PROJECT_DIR_PRIMARY,
+      projectDir: "/tmp/bad/.hack",
+      createdAt,
+    },
+  ];
+
+  const makeView = (name: string): ProjectView => ({
+    name,
+    devHost: null,
+    repoRoot: null,
+    projectDir: null,
+    definedServices: null,
+    extensionsEnabled: null,
+    features: null,
+    serviceHosts: null,
+    runtimeConfigured: null,
+    runtimeStatus: "unknown",
+    runtime: null,
+    branchRuntime: [],
+    kind: "registered",
+    status: "unknown",
+  });
+
+  const cache = createRuntimeCache({
+    deps: {
+      readProjectsRegistry: async () => ({ version: 1, projects }),
+      buildProjectViews: async () => [makeView("ok"), makeView("bad")],
+      serializeProjectView: (view) => ({ name: view.name, kind: view.kind }),
+      resolveProjectMeta: async (opts) => {
+        if (opts.projectName === "bad") {
+          throw new Error("boom");
+        }
+        return { projectName: opts.projectName };
+      },
+    },
+  });
+
+  await cache.refresh({ reason: "test" });
+
+  const payload = await cache.getProjectsPayload({
+    filter: null,
+    includeGlobal: true,
+    includeUnregistered: true,
+    includeMeta: true,
+  });
+
+  expect(payload.projects.length).toBe(2);
+  expect(payload.projects[0]).toMatchObject({
+    name: "ok",
+    meta: { projectName: "ok" },
+  });
+  expect(payload.projects[1]).toMatchObject({
+    name: "bad",
+    meta: null,
+  });
+});
+
 test("runtime cache retains last runtime on failure", async () => {
   const runtime: RuntimeProject[] = [
     {