root/fusion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(FN-000): stabilize failing tests and trim slow waits

Browse Source
This commit is contained in:
gsxdsm
2026-04-23 23:11:58 -07:00
parent 9bf2981b22
commit 6feb697041
8 changed files with 210 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
packages/cli/src/__tests__/bundle-output-helpers.ts
View File

@@ -1,5 +1,5 @@
import { execSync } from "node:child_process";
import { readFileSync } from "node:fs";
import { execFileSync, execSync } from "node:child_process";
import { existsSync, readFileSync } from "node:fs";
import { join } from "node:path";
export const cliRoot = join(__dirname, "..", "..");
@@ -10,6 +10,16 @@ export const clientIndexPath = join(cliRoot, "dist", "client", "index.html");
export const dashboardClientStubMarker = "Dashboard assets not built";
function runBuildCommand(command: string, cwd: string) {
const npmExecPath = process.env.npm_execpath;
if (npmExecPath) {
execFileSync(process.execPath, [npmExecPath, ...command.split(" ")], {
cwd,
stdio: "pipe",
timeout: 240_000,
});
return;
}
execSync(command, {
cwd,
stdio: "pipe",
@@ -17,11 +27,23 @@ function runBuildCommand(command: string, cwd: string) {
});
}
function hasBuiltDashboardAssets(): boolean {
if (!existsSync(bundlePath) || !existsSync(clientIndexPath)) {
return false;
}
return !readFileSync(clientIndexPath, "utf-8").includes(dashboardClientStubMarker);
}
/**
* This suite verifies real copied dashboard client assets in CLI dist output.
* It must build those assets explicitly instead of skip-gating on ambient dist/.
*/
export function buildCliWithRealDashboardAssets() {
if (hasBuiltDashboardAssets()) {
return;
}
runBuildCommand("pnpm --filter @fusion/dashboard build:client", workspaceRoot);
runBuildCommand("pnpm build", cliRoot);
}

2
packages/cli/src/commands/__tests__/dashboard.test.ts
View File

@@ -486,7 +486,7 @@ describe("runDashboard — AuthStorage & ModelRegistry wiring", () => {
await runDashboard(0, {});
expect(mockDiscoverAndLoadExtensions).toHaveBeenCalledWith(
[],
[expect.stringContaining("packages/pi-claude-cli/index.ts")],
expect.any(String),
expect.stringContaining(".fusion/disabled-auto-extension-discovery"),
);

10
packages/core/src/__tests__/plugin-hot-reload.test.ts
View File

@@ -390,16 +390,14 @@ describe("PluginLoader Hot-Reload", () => {
});
it("should remove plugin on total failure (reload + rollback both fail)", async () => {
await pluginLoader.loadPlugin("hot-reload-test");
// Create plugin with hanging onLoad
const manifest = makeManifest({ id: "hot-reload-test", name: "Hot Reload Test", version: "1.0.0" });
await writePluginModule(tmpDir, "plugin.js", manifest, {
onUnload: `async () => { throw new Error("unload error"); }`,
onLoad: `async () => { throw new Error("load error"); }`,
onLoad: `((() => { let count = 0; return async () => { count += 1; if (count > 1) throw new Error("rollback load error"); }; })())`,
});
// Modify for reload
await pluginLoader.loadPlugin("hot-reload-test");
// Modify for reload with a new failing implementation.
const newManifest = makeManifest({ id: "hot-reload-test", name: "Hot Reload Test", version: "2.0.0" });
await writePluginModule(tmpDir, "plugin.js", newManifest, {
onLoad: `async () => { throw new Error("new load error"); }`,

58
packages/core/src/plugin-loader.ts
View File

@@ -9,7 +9,9 @@
* - Error isolation (plugin crashes don't crash the loader)
*/
import { isAbsolute, resolve } from "node:path";
import { copyFile, unlink } from "node:fs/promises";
import { isAbsolute, parse, resolve } from "node:path";
import { pathToFileURL } from "node:url";
import { EventEmitter } from "node:events";
import type { TaskStore } from "./store.js";
import { PluginStore } from "./plugin-store.js";
@@ -85,6 +87,9 @@ export class PluginLoader extends EventEmitter<{
/** Cache of dynamically imported modules */
private loadedModules: Map<string, unknown> = new Map();
/** Monotonic counter for deterministic cache-busting import URLs */
private importNonce = 0;
constructor(private options: PluginLoaderOptions) {
super();
}
@@ -266,19 +271,39 @@ export class PluginLoader extends EventEmitter<{
return this.loadedModules.get(path)!;
}
// Dynamic import - use cache-busting for reload scenarios
let mod: unknown;
let importPath = path;
let tempPath: string | null = null;
if (bypassCache) {
// Use a query parameter for cache differentiation.
// Vite/Vitest's module resolver treats hash fragments as part of the
// filesystem path in some environments (causing ERR_MODULE_NOT_FOUND).
const bustedPath = `${path}?t=${Date.now()}`;
mod = await import(bustedPath);
} else {
mod = await import(path);
const parsed = parse(path);
tempPath = resolve(
parsed.dir,
`${parsed.name}.fusion-import-${process.pid}-${++this.importNonce}${parsed.ext || ".js"}`,
);
await copyFile(path, tempPath);
importPath = tempPath;
}
const fileUrl = pathToFileURL(importPath);
// Dynamic import - use a unique search param for reload scenarios.
// Using file: URLs avoids Vite/Vitest resolver edge cases with bare
// absolute filesystem paths plus query params.
if (bypassCache) {
fileUrl.searchParams.set("t", `${Date.now()}-${this.importNonce}`);
}
try {
const mod = await import(fileUrl.href);
this.loadedModules.set(path, mod);
return mod;
} finally {
if (tempPath) {
void unlink(tempPath).catch(() => {
// Best-effort cleanup; a stale temp import file is non-fatal.
});
}
}
this.loadedModules.set(path, mod);
return mod;
}
/**
@@ -389,7 +414,6 @@ export class PluginLoader extends EventEmitter<{
await this.options.pluginStore.updatePluginState(pluginId, "started");
log.warn(`Rollback successful for ${pluginId}`);
throw err; // Still throw the original error
} catch (rollbackErr) {
// Rollback also failed - remove plugin and set error state
log.error(
@@ -416,6 +440,8 @@ export class PluginLoader extends EventEmitter<{
throw err; // Throw original error
}
throw err;
}
}
@@ -589,7 +615,11 @@ export class PluginLoader extends EventEmitter<{
try {
// Call onUnload hook
await this.safeCallHook(plugin, "onUnload", []);
await this.withTimeout(
this.safeCallHook(plugin, "onUnload", []),
5000,
`onUnload timeout for ${pluginId}`,
);
} catch (err) {
log.error(`Error in onUnload for ${pluginId}:`, err);
}

18
packages/core/src/store.test.ts
View File

@@ -8049,9 +8049,10 @@ Task with acceptance criteria
expect(mockOnSummarize).toHaveBeenCalledWith(longDescription);
// 3. Wait for async summarization and verify title was set
await new Promise((resolve) => setTimeout(resolve, 10));
const updatedTask = await store.getTask(task.id);
expect(updatedTask.title).toBe("AI Title From Saturation Test");
await vi.waitFor(async () => {
const updatedTask = await store.getTask(task.id);
expect(updatedTask.title).toBe("AI Title From Saturation Test");
});
// Reset maxConcurrent to normal value
await store.updateSettings({ maxConcurrent: 2 });
@@ -8061,11 +8062,9 @@ Task with acceptance criteria
// Simulate a slow/stalled onSummarize callback to prove there's no
// semaphore that would block task creation. The core store has no
// dependency on any concurrency limiter.
const slowOnSummarize = vi.fn().mockImplementation(async () => {
// Simulate a very slow AI response
await new Promise((resolve) => setTimeout(resolve, 1000));
return "Slow AI Title";
});
const slowOnSummarize = vi.fn().mockImplementation(
async () => new Promise<string>(() => {}),
);
const taskPromise = store.createTask(
{ description: "a".repeat(201) },
@@ -8281,9 +8280,6 @@ Task with acceptance criteria
// Create a task to trigger the poll cycle
await store.createTask({ description: "fast poll test" });
// Wait for poll interval
await new Promise((resolve) => setTimeout(resolve, 1100));
// Manually call checkForChanges - should be fast
await storeAny.checkForChanges();

39
packages/dashboard/app/components/__tests__/App.test.tsx
View File

@@ -2146,11 +2146,7 @@ describe("App search query propagation to remote mode", () => {
await waitFor(() => {
expect(fetchSettings).toHaveBeenCalled();
});
// Wait for initial load to complete
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 300));
expect(screen.getByTestId("desktop-header-search-btn")).toBeInTheDocument();
});
// At this point, searchQuery should be passed to useRemoteNodeData
@@ -2204,11 +2200,7 @@ describe("App search query propagation to remote mode", () => {
await waitFor(() => {
expect(fetchSettings).toHaveBeenCalled();
});
// Wait for initial load to complete
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 300));
expect(screen.getByTestId("desktop-header-search-btn")).toBeInTheDocument();
});
// Click the search toggle button to open search
@@ -2246,14 +2238,7 @@ describe("App onboarding reopen", () => {
render(<App />);
await waitFor(() => {
expect(fetchSettings).toHaveBeenCalled();
});
// Wait for initial load
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 300));
});
await waitForAppShell();
// Onboarding modal should NOT be open
expect(screen.queryByText("Set Up AI")).toBeNull();
@@ -2294,14 +2279,7 @@ describe("App onboarding reopen", () => {
render(<App />);
await waitFor(() => {
expect(fetchSettings).toHaveBeenCalled();
});
// Wait for initial load
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 300));
});
await waitForAppShell();
// Onboarding should NOT be open initially
expect(screen.queryByText("Set Up AI")).toBeNull();
@@ -2361,14 +2339,7 @@ describe("App onboarding reopen", () => {
render(<App />);
await waitFor(() => {
expect(fetchSettings).toHaveBeenCalled();
});
// Wait for initial load
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 300));
});
await waitForAppShell();
// Open Settings via header
const settingsBtn = screen.getByRole("button", { name: /settings/i });

240
packages/dashboard/src/__tests__/dev-server-routes.test.ts
View File

@@ -1,10 +1,12 @@
// @vitest-environment node
import express from "express";
import http from "node:http";
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import os from "node:os";
import { join } from "node:path";
import type { AddressInfo } from "node:net";
import type { Socket } from "node:net";
import { PassThrough } from "node:stream";
import { afterEach, describe, expect, it, vi } from "vitest";
import { request } from "../test-request.js";
import {
@@ -36,19 +38,65 @@ async function waitFor(predicate: () => boolean, timeoutMs = 4_000): Promise<voi
}
}
async function withHttpServer<T>(app: express.Express, fn: (baseUrl: string) => Promise<T>): Promise<T> {
const server = await new Promise<import("node:http").Server>((resolve) => {
const started = app.listen(0, "127.0.0.1", () => resolve(started));
});
class MockSocket extends PassThrough {
public writable = true;
public readable = true;
public remoteAddress = "127.0.0.1";
public encrypted = false;
const address = server.address() as AddressInfo;
const baseUrl = `http://127.0.0.1:${address.port}`;
try {
return await fn(baseUrl);
} finally {
await new Promise<void>((resolve) => server.close(() => resolve()));
setTimeout(): this {
return this;
}
setNoDelay(): this {
return this;
}
setKeepAlive(): this {
return this;
}
destroySoon(): void {
this.destroy();
}
}
async function openSseStream(app: express.Express, path: string) {
const socket = new MockSocket();
const req = new http.IncomingMessage(socket as unknown as Socket);
const res = new http.ServerResponse(req);
const chunks: Buffer[] = [];
req.method = "GET";
req.url = path;
req.httpVersion = "1.1";
req.headers = { host: "127.0.0.1" };
res.assignSocket(socket as unknown as Socket);
const originalWrite = res.write.bind(res);
res.write = ((chunk: string | Buffer, encoding?: BufferEncoding | ((error?: Error | null) => void), cb?: (error?: Error | null) => void) => {
chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, typeof encoding === "string" ? encoding : undefined));
return originalWrite(chunk as never, encoding as never, cb);
}) as typeof res.write;
app(req, res);
await new Promise((resolve) => process.nextTick(resolve));
req.complete = true;
req.emit("end");
return {
status: res.statusCode,
headers: res.getHeaders(),
readText() {
return Buffer.concat(chunks).toString("utf8");
},
close() {
req.emit("close");
res.emit("close");
socket.destroy();
},
};
}
describe("createDevServerRouter", () => {
@@ -353,22 +401,16 @@ describe("createDevServerRouter", () => {
const app = buildApp(root);
await withHttpServer(app, async (baseUrl) => {
const response = await fetch(`${baseUrl}/api/dev-server/logs/stream`);
expect(response.status).toBe(200);
expect(response.headers.get("content-type")).toContain("text/event-stream");
const stream = await openSseStream(app, "/api/dev-server/logs/stream");
expect(stream.status).toBe(200);
expect(String(stream.headers["content-type"])).toContain("text/event-stream");
const reader = response.body?.getReader();
expect(reader).toBeDefined();
const firstChunk = await reader?.read();
const chunkText = new TextDecoder().decode(firstChunk?.value ?? new Uint8Array());
const chunkText = stream.readText();
expect(chunkText).toContain(": connected");
expect(chunkText).toContain("event: history");
expect(chunkText).toContain("history line");
expect(chunkText).toContain(": connected");
expect(chunkText).toContain("event: history");
expect(chunkText).toContain("history line");
await reader?.cancel();
});
stream.close();
});
it("SSE stream receives new log events when process outputs", async () => {
@@ -376,40 +418,24 @@ describe("createDevServerRouter", () => {
tempDirs.push(root);
const app = buildApp(root);
await withHttpServer(app, async (baseUrl) => {
const streamResponse = await fetch(`${baseUrl}/api/dev-server/logs/stream`);
const reader = streamResponse.body?.getReader();
expect(reader).toBeDefined();
const stream = await openSseStream(app, "/api/dev-server/logs/stream");
await waitFor(() => getActiveProcessManagers().length > 0);
const manager = getActiveProcessManagers()[0];
expect(manager).toBeDefined();
const startResponse = await fetch(`${baseUrl}/api/dev-server/start`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
command: "node -e \"console.log('stream-line'); setInterval(() => {}, 1000)\"",
cwd: root,
}),
});
expect(startResponse.status).toBe(200);
let buffered = "";
const start = Date.now();
while (!buffered.includes("stream-line")) {
if (Date.now() - start > 5_000) {
throw new Error(`Timed out waiting for stream line. Current payload: ${buffered}`);
}
const chunk = await reader?.read();
if (!chunk || chunk.done) {
break;
}
buffered += new TextDecoder().decode(chunk.value);
}
expect(buffered).toContain("event: log");
expect(buffered).toContain("stream-line");
await fetch(`${baseUrl}/api/dev-server/stop`, { method: "POST" });
await reader?.cancel();
manager.emit("output", {
line: "stream-line",
stream: "stdout",
timestamp: new Date().toISOString(),
});
await waitFor(() => stream.readText().includes("stream-line"));
const buffered = stream.readText();
expect(buffered).toContain("event: log");
expect(buffered).toContain("stream-line");
stream.close();
});
it("SSE stream forwards url-detected events with the documented payload", async () => {
@@ -417,52 +443,35 @@ describe("createDevServerRouter", () => {
tempDirs.push(root);
const app = buildApp(root);
await withHttpServer(app, async (baseUrl) => {
const streamResponse = await fetch(`${baseUrl}/api/dev-server/logs/stream`);
const reader = streamResponse.body?.getReader();
expect(reader).toBeDefined();
const stream = await openSseStream(app, "/api/dev-server/logs/stream");
await waitFor(() => getActiveProcessManagers().length > 0);
const manager = getActiveProcessManagers()[0];
expect(manager).toBeDefined();
const startResponse = await fetch(`${baseUrl}/api/dev-server/start`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
command: "node -e \"console.log('detected at http://localhost:5173/'); setInterval(() => {}, 1000)\"",
cwd: root,
}),
});
expect(startResponse.status).toBe(200);
let buffered = "";
const startedAt = Date.now();
while (!buffered.includes("event: dev-server:url-detected")) {
if (Date.now() - startedAt > 5_000) {
throw new Error(`Timed out waiting for url-detected event. Current payload: ${buffered}`);
}
const chunk = await reader?.read();
if (!chunk || chunk.done) {
break;
}
buffered += new TextDecoder().decode(chunk.value);
}
expect(buffered).toContain("event: dev-server:url-detected");
const payloadMatch = buffered.match(/event: dev-server:url-detected\ndata: (.+)/);
expect(payloadMatch).toBeTruthy();
const payload = JSON.parse(payloadMatch?.[1] ?? "{}");
expect(payload).toMatchObject({
url: "http://localhost:5173",
port: 5173,
source: "generic-url",
});
expect(typeof payload.detectedAt).toBe("string");
expect(Number.isNaN(Date.parse(payload.detectedAt))).toBe(false);
expect(Object.keys(payload).sort()).toEqual(["detectedAt", "port", "source", "url"]);
await fetch(`${baseUrl}/api/dev-server/stop`, { method: "POST" });
await reader?.cancel();
manager.emit("url-detected", {
url: "http://localhost:5173",
port: 5173,
source: "generic-url",
detectedAt: new Date().toISOString(),
});
await waitFor(() => stream.readText().includes("event: dev-server:url-detected"));
const buffered = stream.readText();
expect(buffered).toContain("event: dev-server:url-detected");
const payloadMatch = buffered.match(/event: dev-server:url-detected\ndata: (.+)/);
expect(payloadMatch).toBeTruthy();
const payload = JSON.parse(payloadMatch?.[1] ?? "{}");
expect(payload).toMatchObject({
url: "http://localhost:5173",
port: 5173,
source: "generic-url",
});
expect(typeof payload.detectedAt).toBe("string");
expect(Number.isNaN(Date.parse(payload.detectedAt))).toBe(false);
expect(Object.keys(payload).sort()).toEqual(["detectedAt", "port", "source", "url"]);
stream.close();
});
it("SSE stream cleans up listeners on client disconnect", async () => {
@@ -470,24 +479,21 @@ describe("createDevServerRouter", () => {
tempDirs.push(root);
const app = buildApp(root);
await withHttpServer(app, async (baseUrl) => {
const response = await fetch(`${baseUrl}/api/dev-server/logs/stream`);
const reader = response.body?.getReader();
expect(reader).toBeDefined();
const stream = await openSseStream(app, "/api/dev-server/logs/stream");
await waitFor(() => getActiveProcessManagers().length > 0);
await waitFor(() => {
const manager = getActiveProcessManagers()[0];
return (manager?.listenerCount("output") ?? 0) > 0
&& (manager?.listenerCount("url-detected") ?? 0) > 0;
});
await waitFor(() => {
const manager = getActiveProcessManagers()[0];
return (manager?.listenerCount("output") ?? 0) > 0
&& (manager?.listenerCount("url-detected") ?? 0) > 0;
});
await reader?.cancel();
stream.close();
await waitFor(() => {
const manager = getActiveProcessManagers()[0];
return (manager?.listenerCount("output") ?? 0) === 0
&& (manager?.listenerCount("url-detected") ?? 0) === 0;
});
await waitFor(() => {
const manager = getActiveProcessManagers()[0];
return (manager?.listenerCount("output") ?? 0) === 0
&& (manager?.listenerCount("url-detected") ?? 0) === 0;
});
});
});

4
packages/dashboard/src/routes.test.ts
View File

@@ -14976,7 +14976,7 @@ describe("POST /workflow-step-templates/:id/create", () => {
const created = {
id: "WS-002",
name: "QA Check",
description: "Run tests and verify they pass, check for obvious bugs",
description: "Run lint, tests, and typecheck; verify they pass and check for obvious bugs",
prompt: expect.stringContaining("QA tester"),
enabled: true,
createdAt: "2026-01-01",
@@ -14994,7 +14994,7 @@ describe("POST /workflow-step-templates/:id/create", () => {
expect(store.createWorkflowStep).toHaveBeenCalledWith({
templateId: "qa-check",
name: "QA Check",
description: "Run tests and verify they pass, check for obvious bugs",
description: "Run lint, tests, and typecheck; verify they pass and check for obvious bugs",
prompt: expect.stringContaining("QA tester"),
toolMode: "coding",
enabled: true,