2179a61db9
Restore horizontal concurrency thumb drags on mobile by opting range inputs out of the pan-y ancestor lock. - Set touch-action:none on Engine Control menu and Command Center concurrency range inputs - Update geometry/touch contract test to assert none and reject pan-y - Add patch changeset for the mobile slider fix Files changed: .changeset/fn-7973-mobile-concurrency-sliders.md | 7 +++++++ packages/dashboard/app/components/EngineControlMenu.css | 5 ++++- .../app/components/__tests__/EngineControlMenu.test.tsx | 11 ++++++++--- .../app/components/command-center/CommandCenterControls.css | 5 ++++- 4 files changed, 23 insertions(+), 5 deletions(-) Fusion-Task-Id: FN-7973 Fusion-Task-Lineage: bf36e544-c24f-49ae-beae-b11707be9c79 Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
734 lines
30 KiB
TypeScript
734 lines
30 KiB
TypeScript
import { readFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
|
|
import { render, screen, fireEvent, waitFor, act, cleanup } from "@testing-library/react";
|
|
import { EngineControlMenu } from "../EngineControlMenu";
|
|
import { ConfirmDialogProvider } from "../../hooks/useConfirm";
|
|
|
|
const engineControlMenuCss = readFileSync(
|
|
join(process.cwd(), "app/components/EngineControlMenu.css"),
|
|
"utf8",
|
|
);
|
|
|
|
const commandCenterControlsCss = readFileSync(
|
|
join(process.cwd(), "app/components/command-center/CommandCenterControls.css"),
|
|
"utf8",
|
|
);
|
|
|
|
const defaultSettings = {
|
|
maxConcurrent: 2,
|
|
maxTriageConcurrent: 1,
|
|
maxWorktrees: 4,
|
|
globalPause: false,
|
|
enginePaused: false,
|
|
autoMerge: true,
|
|
experimentalFeatures: {},
|
|
};
|
|
|
|
const apiMocks = vi.hoisted(() => ({
|
|
fetchConfig: vi.fn(),
|
|
fetchSettings: vi.fn(),
|
|
updateSettings: vi.fn(),
|
|
updateGlobalSettings: vi.fn(),
|
|
}));
|
|
|
|
const legacyMocks = vi.hoisted(() => ({
|
|
fetchConfig: vi.fn(),
|
|
fetchSettings: vi.fn(),
|
|
updateSettings: vi.fn(),
|
|
fetchGlobalConcurrency: vi.fn(),
|
|
updateGlobalConcurrency: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("../../api", () => apiMocks);
|
|
vi.mock("../../api/legacy", () => legacyMocks);
|
|
vi.mock("../../versionCheck", () => ({
|
|
setAutoReloadEnabled: vi.fn(),
|
|
}));
|
|
|
|
async function openMenu(projectId: string | undefined = "proj_123") {
|
|
render(
|
|
<ConfirmDialogProvider>
|
|
<EngineControlMenu projectId={projectId} />
|
|
</ConfirmDialogProvider>,
|
|
);
|
|
fireEvent.click(screen.getByTestId("engine-control-menu-trigger"));
|
|
await screen.findByTestId("engine-control-menu");
|
|
}
|
|
|
|
function mockGlobalConcurrency(overrides: Partial<{
|
|
globalMaxConcurrent: number;
|
|
currentlyActive: number;
|
|
queuedCount: number;
|
|
projectsActive: Record<string, number>;
|
|
}> = {}) {
|
|
legacyMocks.fetchGlobalConcurrency.mockResolvedValue({
|
|
globalMaxConcurrent: 6,
|
|
currentlyActive: 3,
|
|
queuedCount: 0,
|
|
projectsActive: { proj_123: 2 },
|
|
...overrides,
|
|
});
|
|
}
|
|
|
|
// FNXC:EngineControls 2026-06-29-12:00: FN-7235 reproduces the footer mismatch by asserting running-count markers use the loaded cap (`current / cap`) rather than expanded slider-track coordinates; both global and project renderers must move 1 running agent above zero.
|
|
// FNXC:EngineControls 2026-06-29-13:25: Keep the footer marker guard aligned with the Command Center representative states: zero, one active, mid-track utilization, over-cap clamping, loading, and error.
|
|
function expectUseMarkerPct(testId: string, pct: string) {
|
|
expect(screen.getByTestId(testId).style.getPropertyValue("--use-pct")).toBe(pct);
|
|
}
|
|
|
|
function expectFooterUseOffset(testId: string, ratio: number) {
|
|
expect(screen.getByTestId(testId).style.getPropertyValue("--use-offset")).toBe(
|
|
`calc((var(--engine-control-range-thumb-size) / 2) + ((100% - var(--engine-control-range-thumb-size)) * ${ratio}))`,
|
|
);
|
|
}
|
|
|
|
function cssRule(css: string, selector: string) {
|
|
const escapedSelector = selector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
const match = css.match(new RegExp(`${escapedSelector}\\s*\\{([\\s\\S]*?)\\}`));
|
|
expect(match, `Expected CSS rule for ${selector}`).not.toBeNull();
|
|
return match?.[1] ?? "";
|
|
}
|
|
|
|
describe("EngineControlMenu", () => {
|
|
beforeEach(() => {
|
|
vi.useRealTimers();
|
|
apiMocks.fetchConfig.mockResolvedValue({ maxConcurrent: 2, rootDir: "/workspace/project" });
|
|
apiMocks.fetchSettings.mockResolvedValue({ ...defaultSettings });
|
|
apiMocks.updateSettings.mockResolvedValue({ ...defaultSettings });
|
|
apiMocks.updateGlobalSettings.mockResolvedValue({});
|
|
legacyMocks.fetchConfig.mockResolvedValue({ maxConcurrent: 2, rootDir: "/workspace/project" });
|
|
legacyMocks.fetchSettings.mockResolvedValue({ ...defaultSettings });
|
|
legacyMocks.updateSettings.mockResolvedValue({ ...defaultSettings });
|
|
mockGlobalConcurrency();
|
|
legacyMocks.updateGlobalConcurrency.mockResolvedValue({
|
|
globalMaxConcurrent: 6,
|
|
currentlyActive: 3,
|
|
queuedCount: 0,
|
|
projectsActive: { proj_123: 2 },
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.clearAllMocks();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
|
|
// FNXC:GlobalConcurrencyControls 2026-07-15-00:00: FN-7973 requires touch-action:none on both concurrency slider surfaces because the mobile pan-y ancestor lock otherwise steals horizontal native thumb drags.
|
|
it("matches the Command Center slider geometry and mobile touch contract for footer current-use markers", () => {
|
|
const footerWrap = cssRule(engineControlMenuCss, ".engine-control-menu__range-wrap");
|
|
const footerRange = cssRule(engineControlMenuCss, ".engine-control-menu__range");
|
|
const footerMarker = cssRule(engineControlMenuCss, ".engine-control-menu__use-marker");
|
|
const commandWrap = cssRule(commandCenterControlsCss, ".cc-controls-range-wrap");
|
|
const commandTouchSliderRule = commandCenterControlsCss.match(/\.cc-controls-slider input\[type="range"\],\n\.cc-controls-touch-slider\s*\{([\s\S]*?)\}/)?.[1] ?? "";
|
|
const commandMarker = cssRule(commandCenterControlsCss, ".cc-controls-use-marker");
|
|
|
|
expect(footerWrap).toContain("--engine-control-range-thumb-size: var(--space-md);");
|
|
expect(commandWrap).toContain("--cc-controls-range-thumb-size: var(--space-md);");
|
|
expect(footerWrap).toContain("position: relative;");
|
|
expect(footerWrap).toContain("display: flex;");
|
|
expect(footerWrap).toContain("align-items: center;");
|
|
expect(footerRange).toContain("inline-size: 100%;");
|
|
expect(footerRange).toContain("min-block-size: var(--space-xl);");
|
|
expect(footerRange).toContain("accent-color: var(--accent);");
|
|
expect(footerRange).toContain("touch-action: none;");
|
|
expect(footerRange).not.toContain("touch-action: pan-y;");
|
|
expect(commandTouchSliderRule).toContain("inline-size: 100%;");
|
|
expect(commandTouchSliderRule).toContain("min-block-size: var(--space-xl);");
|
|
expect(commandTouchSliderRule).toContain("accent-color: var(--accent);");
|
|
expect(commandTouchSliderRule).toContain("touch-action: none;");
|
|
expect(commandTouchSliderRule).not.toContain("touch-action: pan-y;");
|
|
for (const declaration of ["position: absolute;", "inset-block-start: 50%;", "inset-inline-start: var(--use-offset, var(--use-pct));", "transform: translate(-50%, -50%);", "pointer-events: none;"]) {
|
|
expect(footerMarker).toContain(declaration);
|
|
expect(commandMarker).toContain(declaration);
|
|
}
|
|
expect(engineControlMenuCss).toContain("@media (max-width: 768px)");
|
|
expect(engineControlMenuCss).toContain("--engine-control-range-thumb-size: var(--space-xl);");
|
|
});
|
|
|
|
it("renders an explicit close button when opened", async () => {
|
|
await openMenu();
|
|
|
|
expect(screen.getByTestId("engine-control-menu-close")).toBeInTheDocument();
|
|
expect(screen.getByLabelText(/close engine controls/i)).toBeInTheDocument();
|
|
});
|
|
|
|
it("closes the menu when the explicit close button is clicked", async () => {
|
|
await openMenu();
|
|
|
|
fireEvent.click(screen.getByTestId("engine-control-menu-close"));
|
|
|
|
await waitFor(() => expect(screen.queryByTestId("engine-control-menu")).not.toBeInTheDocument());
|
|
});
|
|
|
|
it("reverts pending project concurrency changes when the explicit close button is clicked", async () => {
|
|
await openMenu();
|
|
|
|
const maxConcurrent = await screen.findByLabelText(/max concurrent tasks/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "7" } });
|
|
fireEvent.click(screen.getByTestId("engine-control-menu-close"));
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(legacyMocks.updateSettings).not.toHaveBeenCalled();
|
|
expect(screen.queryByTestId("engine-control-menu")).not.toBeInTheDocument();
|
|
});
|
|
|
|
it("keeps the close button available when concurrency settings fail to load", async () => {
|
|
legacyMocks.fetchSettings.mockRejectedValue(new Error("settings unavailable"));
|
|
await openMenu();
|
|
|
|
expect(await screen.findByRole("alert")).toHaveTextContent("settings unavailable");
|
|
expect(screen.getByTestId("engine-control-menu-close")).toBeInTheDocument();
|
|
});
|
|
|
|
it("stops and starts the global AI engine via settings", async () => {
|
|
apiMocks.fetchSettings.mockResolvedValue({ ...defaultSettings, globalPause: false });
|
|
await openMenu();
|
|
|
|
fireEvent.click(screen.getByTestId("engine-control-stop-btn"));
|
|
|
|
await waitFor(() => expect(apiMocks.updateSettings).toHaveBeenCalledWith(
|
|
{ globalPause: true, globalPauseReason: "manual" },
|
|
"proj_123",
|
|
));
|
|
});
|
|
|
|
it("starts the global AI engine when currently stopped", async () => {
|
|
apiMocks.fetchSettings.mockResolvedValue({ ...defaultSettings, globalPause: true });
|
|
await openMenu();
|
|
|
|
await waitFor(() => expect(screen.getByTestId("engine-control-stop-btn")).toHaveTextContent(/start ai engine/i));
|
|
fireEvent.click(screen.getByTestId("engine-control-stop-btn"));
|
|
|
|
await waitFor(() => expect(apiMocks.updateSettings).toHaveBeenCalledWith(
|
|
{ globalPause: false, globalPauseReason: undefined },
|
|
"proj_123",
|
|
));
|
|
});
|
|
|
|
it("pauses and resumes triage, and disables triage while globally stopped", async () => {
|
|
apiMocks.fetchSettings.mockResolvedValue({ ...defaultSettings, enginePaused: false });
|
|
await openMenu();
|
|
|
|
fireEvent.click(screen.getByTestId("engine-control-pause-triage-btn"));
|
|
|
|
await waitFor(() => expect(apiMocks.updateSettings).toHaveBeenCalledWith({ enginePaused: true }, "proj_123"));
|
|
|
|
vi.clearAllMocks();
|
|
apiMocks.fetchConfig.mockResolvedValue({ maxConcurrent: 2, rootDir: "/workspace/project" });
|
|
apiMocks.fetchSettings.mockResolvedValue({ ...defaultSettings, globalPause: true, enginePaused: true });
|
|
legacyMocks.fetchConfig.mockResolvedValue({ maxConcurrent: 2, rootDir: "/workspace/project" });
|
|
legacyMocks.fetchSettings.mockResolvedValue({ ...defaultSettings });
|
|
render(
|
|
<ConfirmDialogProvider>
|
|
<EngineControlMenu projectId="proj_123" />
|
|
</ConfirmDialogProvider>,
|
|
);
|
|
fireEvent.click(screen.getAllByTestId("engine-control-menu-trigger")[1]);
|
|
|
|
await waitFor(() => expect(screen.getAllByTestId("engine-control-pause-triage-btn")).toHaveLength(2));
|
|
const pauseButton = screen.getAllByTestId("engine-control-pause-triage-btn")[1];
|
|
await waitFor(() => expect(pauseButton).toBeDisabled());
|
|
expect(pauseButton).toHaveTextContent(/resume scheduling/i);
|
|
});
|
|
|
|
it("cancels a confirmed project concurrency edit by reverting to persisted values without saving", async () => {
|
|
await openMenu();
|
|
|
|
const maxConcurrent = await screen.findByLabelText(/max concurrent tasks/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "7" } });
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
|
|
expect(screen.getByRole("dialog", { name: /confirm concurrency change/i })).toHaveTextContent("Max concurrent tasks from 2 to 7");
|
|
vi.useRealTimers();
|
|
fireEvent.click(screen.getByRole("button", { name: /cancel/i }));
|
|
|
|
await waitFor(() => expect(screen.queryByRole("dialog", { name: /confirm concurrency change/i })).not.toBeInTheDocument());
|
|
await waitFor(() => expect(maxConcurrent).toHaveValue("2"));
|
|
expect(legacyMocks.updateSettings).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not silently save project concurrency edits on Escape or outside dismissal", async () => {
|
|
await openMenu();
|
|
const maxConcurrent = await screen.findByLabelText(/max concurrent tasks/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "7" } });
|
|
fireEvent.keyDown(document, { key: "Escape" });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(legacyMocks.updateSettings).not.toHaveBeenCalled();
|
|
expect(screen.queryByTestId("engine-control-menu")).not.toBeInTheDocument();
|
|
|
|
vi.useRealTimers();
|
|
cleanup();
|
|
legacyMocks.updateSettings.mockClear();
|
|
await openMenu();
|
|
const reopenedMaxConcurrent = await screen.findByLabelText(/max concurrent tasks/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(reopenedMaxConcurrent, { target: { value: "8" } });
|
|
fireEvent.mouseDown(document.body);
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
|
|
expect(legacyMocks.updateSettings).not.toHaveBeenCalled();
|
|
expect(screen.queryByTestId("engine-control-menu")).not.toBeInTheDocument();
|
|
});
|
|
|
|
it("confirms debounced concurrency and worktree slider changes before persisting and refreshing settings", async () => {
|
|
legacyMocks.fetchSettings.mockResolvedValue({
|
|
...defaultSettings,
|
|
maxConcurrent: 60,
|
|
maxTriageConcurrent: 70,
|
|
maxWorktrees: 80,
|
|
});
|
|
await openMenu();
|
|
|
|
const maxConcurrent = await screen.findByLabelText(/max concurrent tasks/i);
|
|
const maxTriage = screen.getByLabelText(/max triage concurrent/i);
|
|
const maxWorktrees = screen.getByLabelText(/max worktrees/i);
|
|
|
|
vi.useFakeTimers();
|
|
|
|
expect(maxConcurrent).toHaveAttribute("max", "60");
|
|
expect(maxConcurrent).toHaveValue("60");
|
|
expect(maxTriage).toHaveAttribute("max", "70");
|
|
expect(maxTriage).toHaveValue("70");
|
|
expect(maxWorktrees).toHaveAttribute("max", "80");
|
|
expect(maxWorktrees).toHaveValue("80");
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "9" } });
|
|
fireEvent.change(maxTriage, { target: { value: "4" } });
|
|
fireEvent.change(maxWorktrees, { target: { value: "8" } });
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
|
|
expect(screen.getByRole("dialog", { name: /confirm concurrency change/i })).toHaveTextContent("Max concurrent tasks from 60 to 9");
|
|
expect(screen.getByRole("dialog", { name: /confirm concurrency change/i })).toHaveTextContent("Max triage concurrent from 70 to 4");
|
|
expect(screen.getByRole("dialog", { name: /confirm concurrency change/i })).toHaveTextContent("Max worktrees from 80 to 8");
|
|
expect(legacyMocks.updateSettings).not.toHaveBeenCalled();
|
|
|
|
vi.useRealTimers();
|
|
const saveButton = screen.getByRole("button", { name: /save change/i });
|
|
fireEvent.mouseDown(saveButton);
|
|
fireEvent.click(saveButton);
|
|
|
|
await waitFor(() => expect(legacyMocks.updateSettings).toHaveBeenCalledWith(
|
|
{ maxConcurrent: 9, maxTriageConcurrent: 4, maxWorktrees: 8 },
|
|
"proj_123",
|
|
));
|
|
expect(apiMocks.fetchSettings).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("uses a 50 max for all in-range concurrency sliders", async () => {
|
|
legacyMocks.fetchSettings.mockResolvedValue({
|
|
...defaultSettings,
|
|
maxConcurrent: 12,
|
|
maxTriageConcurrent: 3,
|
|
maxWorktrees: 25,
|
|
});
|
|
await openMenu();
|
|
|
|
expect(await screen.findByLabelText(/max concurrent tasks/i)).toHaveAttribute("max", "50");
|
|
expect(screen.getByLabelText(/max triage concurrent/i)).toHaveAttribute("max", "50");
|
|
expect(screen.getByLabelText(/max worktrees/i)).toHaveAttribute("max", "50");
|
|
});
|
|
|
|
it("confirms footer global cap edits before writing through the shared hook", async () => {
|
|
await openMenu();
|
|
|
|
const globalMaxConcurrent = await screen.findByLabelText(/maximum concurrent agents across all projects/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(globalMaxConcurrent, { target: { value: "9" } });
|
|
|
|
expect(globalMaxConcurrent).toHaveValue("9");
|
|
expect(globalMaxConcurrent.closest("label")).toHaveTextContent("9");
|
|
expect(legacyMocks.updateGlobalConcurrency).not.toHaveBeenCalled();
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
|
|
const dialog = screen.getByRole("dialog", { name: /confirm concurrency change/i });
|
|
expect(dialog).toHaveTextContent("Change Global Max Concurrent from 6 to 9?");
|
|
expect(screen.getByRole("button", { name: /save change/i })).toBeInTheDocument();
|
|
expect(screen.getByRole("button", { name: /cancel/i })).toBeInTheDocument();
|
|
expect(globalMaxConcurrent).toBeDisabled();
|
|
|
|
await act(async () => {
|
|
fireEvent.click(screen.getByRole("button", { name: /save change/i }));
|
|
await Promise.resolve();
|
|
});
|
|
expect(screen.queryByRole("dialog", { name: /confirm concurrency change/i })).not.toBeInTheDocument();
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
await Promise.resolve();
|
|
});
|
|
|
|
expect(legacyMocks.updateGlobalConcurrency).toHaveBeenCalledWith({ globalMaxConcurrent: 9 });
|
|
});
|
|
|
|
it("prevents duplicate footer confirmation dialogs while a concurrency confirmation is open", async () => {
|
|
await openMenu();
|
|
|
|
const maxConcurrent = await screen.findByLabelText(/max concurrent tasks/i);
|
|
const globalMaxConcurrent = screen.getByLabelText(/maximum concurrent agents across all projects/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "7" } });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(screen.getAllByRole("dialog", { name: /confirm concurrency change/i })).toHaveLength(1);
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "8" } });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(screen.getAllByRole("dialog", { name: /confirm concurrency change/i })).toHaveLength(1);
|
|
vi.useRealTimers();
|
|
fireEvent.click(screen.getByRole("button", { name: /cancel/i }));
|
|
await waitFor(() => expect(screen.queryByRole("dialog", { name: /confirm concurrency change/i })).not.toBeInTheDocument());
|
|
|
|
vi.useFakeTimers();
|
|
fireEvent.change(globalMaxConcurrent, { target: { value: "9" } });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(screen.getAllByRole("dialog", { name: /confirm concurrency change/i })).toHaveLength(1);
|
|
fireEvent.change(globalMaxConcurrent, { target: { value: "10" } });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(screen.getAllByRole("dialog", { name: /confirm concurrency change/i })).toHaveLength(1);
|
|
expect(legacyMocks.updateSettings).not.toHaveBeenCalled();
|
|
expect(legacyMocks.updateGlobalConcurrency).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("flushes already-confirmed global cap saves when the footer closes", async () => {
|
|
await openMenu();
|
|
|
|
const globalMaxConcurrent = await screen.findByLabelText(/maximum concurrent agents across all projects/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(globalMaxConcurrent, { target: { value: "9" } });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
await act(async () => {
|
|
fireEvent.click(screen.getByRole("button", { name: /save change/i }));
|
|
await Promise.resolve();
|
|
});
|
|
|
|
fireEvent.click(screen.getByTestId("engine-control-menu-close"));
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
await Promise.resolve();
|
|
});
|
|
|
|
expect(screen.queryByTestId("engine-control-menu")).not.toBeInTheDocument();
|
|
expect(legacyMocks.updateGlobalConcurrency).toHaveBeenCalledWith({ globalMaxConcurrent: 9 });
|
|
});
|
|
|
|
it("cancels footer global cap edits without triggering a global write", async () => {
|
|
await openMenu();
|
|
|
|
const globalMaxConcurrent = await screen.findByLabelText(/maximum concurrent agents across all projects/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(globalMaxConcurrent, { target: { value: "8" } });
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
|
|
expect(screen.getByRole("dialog", { name: /confirm concurrency change/i })).toHaveTextContent("Global Max Concurrent from 6 to 8");
|
|
vi.useRealTimers();
|
|
fireEvent.click(screen.getByRole("button", { name: /cancel/i }));
|
|
|
|
await waitFor(() => expect(screen.queryByRole("dialog", { name: /confirm concurrency change/i })).not.toBeInTheDocument());
|
|
await waitFor(() => expect(globalMaxConcurrent).toHaveValue("6"));
|
|
expect(legacyMocks.updateGlobalConcurrency).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not prompt or write when a footer global cap edit matches the persisted value", async () => {
|
|
await openMenu();
|
|
|
|
const globalMaxConcurrent = await screen.findByLabelText(/maximum concurrent agents across all projects/i);
|
|
vi.useFakeTimers();
|
|
|
|
fireEvent.change(globalMaxConcurrent, { target: { value: "6" } });
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
|
|
expect(screen.queryByRole("dialog", { name: /confirm concurrency change/i })).not.toBeInTheDocument();
|
|
expect(legacyMocks.updateGlobalConcurrency).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("keeps loading and error global cap states disabled so they cannot prompt", async () => {
|
|
let resolveGlobalConcurrency!: (value: {
|
|
globalMaxConcurrent: number;
|
|
currentlyActive: number;
|
|
queuedCount: number;
|
|
projectsActive: Record<string, number>;
|
|
}) => void;
|
|
legacyMocks.fetchGlobalConcurrency.mockReturnValue(new Promise((resolve) => {
|
|
resolveGlobalConcurrency = resolve;
|
|
}));
|
|
|
|
await openMenu();
|
|
|
|
const loadingGlobalMaxConcurrent = await screen.findByLabelText(/maximum concurrent agents across all projects/i);
|
|
// FNXC:GlobalConcurrencyControls 2026-07-15-00:00: FN-7973 restores native touch dragging only for enabled ranges; loading caps remain disabled no-ops.
|
|
expect(loadingGlobalMaxConcurrent).toHaveAttribute("disabled");
|
|
expect(loadingGlobalMaxConcurrent).toBeDisabled();
|
|
|
|
vi.useFakeTimers();
|
|
fireEvent.change(loadingGlobalMaxConcurrent, { target: { value: "7" } });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(screen.queryByRole("dialog", { name: /confirm concurrency change/i })).not.toBeInTheDocument();
|
|
expect(legacyMocks.updateGlobalConcurrency).not.toHaveBeenCalled();
|
|
|
|
await act(async () => {
|
|
resolveGlobalConcurrency({
|
|
globalMaxConcurrent: 6,
|
|
currentlyActive: 3,
|
|
queuedCount: 0,
|
|
projectsActive: { proj_123: 2 },
|
|
});
|
|
});
|
|
|
|
vi.useRealTimers();
|
|
cleanup();
|
|
legacyMocks.updateGlobalConcurrency.mockClear();
|
|
legacyMocks.fetchGlobalConcurrency.mockRejectedValue(new Error("global concurrency unavailable"));
|
|
|
|
await openMenu();
|
|
|
|
const errorGlobalMaxConcurrent = await screen.findByLabelText(/maximum concurrent agents across all projects/i);
|
|
await screen.findByRole("alert");
|
|
expect(errorGlobalMaxConcurrent).toBeDisabled();
|
|
|
|
vi.useFakeTimers();
|
|
fireEvent.change(errorGlobalMaxConcurrent, { target: { value: "7" } });
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
expect(screen.queryByRole("dialog", { name: /confirm concurrency change/i })).not.toBeInTheDocument();
|
|
expect(legacyMocks.updateGlobalConcurrency).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("renders running counts and current-use markers with clamped absolute utilization", async () => {
|
|
legacyMocks.fetchSettings.mockResolvedValue({
|
|
...defaultSettings,
|
|
maxConcurrent: 50,
|
|
});
|
|
mockGlobalConcurrency({
|
|
globalMaxConcurrent: 40,
|
|
currentlyActive: 40,
|
|
projectsActive: { proj_123: 90 },
|
|
});
|
|
|
|
await openMenu();
|
|
|
|
expect(await screen.findByTestId("engine-control-global-running")).toHaveTextContent("40 running (all projects)");
|
|
expect(screen.getByTestId("engine-control-project-running")).toHaveTextContent("90 running (this project)");
|
|
expect(screen.getByTestId("engine-control-global-use-marker")).toHaveStyle({ "--use-pct": "100%" });
|
|
expect(screen.getByTestId("engine-control-project-use-marker")).toHaveStyle({ "--use-pct": "100%" });
|
|
});
|
|
|
|
it("positions current-use markers by absolute utilization instead of slider-coordinate math", async () => {
|
|
legacyMocks.fetchSettings.mockResolvedValue({
|
|
...defaultSettings,
|
|
maxConcurrent: 50,
|
|
});
|
|
mockGlobalConcurrency({
|
|
globalMaxConcurrent: 50,
|
|
currentlyActive: 17,
|
|
projectsActive: { proj_123: 17 },
|
|
});
|
|
|
|
await openMenu();
|
|
|
|
await screen.findByTestId("engine-control-global-use-marker");
|
|
expectUseMarkerPct("engine-control-global-use-marker", "34%");
|
|
expectUseMarkerPct("engine-control-project-use-marker", "34%");
|
|
expect(screen.getByTestId("engine-control-global-use-marker").style.getPropertyValue("--use-pct")).not.toBe(`${((17 - 1) / (50 - 1)) * 100}%`);
|
|
expect(screen.getByTestId("engine-control-project-use-marker").style.getPropertyValue("--use-pct")).not.toBe(`${((17 - 1) / (50 - 1)) * 100}%`);
|
|
expect(screen.queryAllByTestId(/engine-control-.*-use-marker/)).toHaveLength(2);
|
|
});
|
|
|
|
it("positions mid-track footer markers using absolute utilization", async () => {
|
|
legacyMocks.fetchSettings.mockResolvedValue({
|
|
...defaultSettings,
|
|
maxConcurrent: 10,
|
|
});
|
|
mockGlobalConcurrency({
|
|
globalMaxConcurrent: 10,
|
|
currentlyActive: 6,
|
|
projectsActive: { proj_123: 6 },
|
|
});
|
|
|
|
await openMenu();
|
|
|
|
await screen.findByTestId("engine-control-global-use-marker");
|
|
expectUseMarkerPct("engine-control-global-use-marker", "18.75%");
|
|
expectUseMarkerPct("engine-control-project-use-marker", "12%");
|
|
});
|
|
|
|
it("keeps one active agent visibly above zero on both footer markers", async () => {
|
|
legacyMocks.fetchSettings.mockResolvedValue({
|
|
...defaultSettings,
|
|
maxConcurrent: 10,
|
|
});
|
|
mockGlobalConcurrency({
|
|
globalMaxConcurrent: 10,
|
|
currentlyActive: 1,
|
|
projectsActive: { proj_123: 1 },
|
|
});
|
|
|
|
await openMenu();
|
|
|
|
await screen.findByTestId("engine-control-global-use-marker");
|
|
expectUseMarkerPct("engine-control-global-use-marker", "3.125%");
|
|
expectUseMarkerPct("engine-control-project-use-marker", "2%");
|
|
expect(screen.getByTestId("engine-control-global-use-marker").style.getPropertyValue("--use-pct")).not.toBe("0%");
|
|
expect(screen.getByTestId("engine-control-project-use-marker").style.getPropertyValue("--use-pct")).not.toBe("0%");
|
|
});
|
|
|
|
it("positions zero running at the start of both footer markers", async () => {
|
|
mockGlobalConcurrency({
|
|
globalMaxConcurrent: 6,
|
|
currentlyActive: 0,
|
|
projectsActive: {},
|
|
});
|
|
|
|
await openMenu(undefined);
|
|
|
|
expect(await screen.findByTestId("engine-control-global-running")).toHaveTextContent("0 running (all projects)");
|
|
expect(screen.getByTestId("engine-control-project-running")).toHaveTextContent("0 running (this project)");
|
|
expect(screen.getByTestId("engine-control-global-use-marker")).toHaveStyle({ "--use-pct": "0%" });
|
|
expect(screen.getByTestId("engine-control-project-use-marker")).toHaveStyle({ "--use-pct": "0%" });
|
|
expectFooterUseOffset("engine-control-global-use-marker", 0);
|
|
expectFooterUseOffset("engine-control-project-use-marker", 0);
|
|
});
|
|
|
|
it("recomputes footer project marker positions from the visible pending cap", async () => {
|
|
legacyMocks.fetchSettings.mockResolvedValue({
|
|
...defaultSettings,
|
|
maxConcurrent: 60,
|
|
});
|
|
mockGlobalConcurrency({
|
|
globalMaxConcurrent: 48,
|
|
currentlyActive: 16,
|
|
projectsActive: { proj_123: 30 },
|
|
});
|
|
|
|
await openMenu();
|
|
|
|
await screen.findByLabelText(/maximum concurrent agents across all projects/i);
|
|
const maxConcurrent = screen.getByLabelText(/max concurrent tasks/i);
|
|
vi.useFakeTimers();
|
|
|
|
expectUseMarkerPct("engine-control-global-use-marker", `${(16 / 48) * 100}%`);
|
|
expectUseMarkerPct("engine-control-project-use-marker", "50%");
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "50" } });
|
|
|
|
expectUseMarkerPct("engine-control-global-use-marker", `${(16 / 48) * 100}%`);
|
|
expectUseMarkerPct("engine-control-project-use-marker", "60%");
|
|
expectFooterUseOffset("engine-control-global-use-marker", 16 / 48);
|
|
expectFooterUseOffset("engine-control-project-use-marker", 30 / 50);
|
|
});
|
|
|
|
it("suppresses footer running counts and markers while utilization is loading", async () => {
|
|
let resolveGlobalConcurrency!: (value: {
|
|
globalMaxConcurrent: number;
|
|
currentlyActive: number;
|
|
queuedCount: number;
|
|
projectsActive: Record<string, number>;
|
|
}) => void;
|
|
legacyMocks.fetchGlobalConcurrency.mockReturnValue(new Promise((resolve) => {
|
|
resolveGlobalConcurrency = resolve;
|
|
}));
|
|
|
|
await openMenu();
|
|
|
|
expect(screen.queryByTestId("engine-control-global-running")).not.toBeInTheDocument();
|
|
expect(screen.queryByTestId("engine-control-project-running")).not.toBeInTheDocument();
|
|
expect(screen.queryByTestId("engine-control-global-use-marker")).not.toBeInTheDocument();
|
|
expect(screen.queryByTestId("engine-control-project-use-marker")).not.toBeInTheDocument();
|
|
|
|
await act(async () => {
|
|
resolveGlobalConcurrency({
|
|
globalMaxConcurrent: 6,
|
|
currentlyActive: 3,
|
|
queuedCount: 0,
|
|
projectsActive: { proj_123: 2 },
|
|
});
|
|
});
|
|
});
|
|
|
|
it("suppresses footer running counts and markers when utilization fails", async () => {
|
|
legacyMocks.fetchGlobalConcurrency.mockRejectedValue(new Error("global concurrency unavailable"));
|
|
|
|
await openMenu();
|
|
|
|
await screen.findByRole("alert");
|
|
expect(screen.queryByTestId("engine-control-global-running")).not.toBeInTheDocument();
|
|
expect(screen.queryByTestId("engine-control-project-running")).not.toBeInTheDocument();
|
|
expect(screen.queryByTestId("engine-control-global-use-marker")).not.toBeInTheDocument();
|
|
expect(screen.queryByTestId("engine-control-project-use-marker")).not.toBeInTheDocument();
|
|
});
|
|
|
|
it("persists a slider value of 50 after confirmation", async () => {
|
|
await openMenu();
|
|
|
|
const maxConcurrent = await screen.findByLabelText(/max concurrent tasks/i);
|
|
vi.useFakeTimers();
|
|
|
|
expect(maxConcurrent).toHaveAttribute("max", "50");
|
|
|
|
fireEvent.change(maxConcurrent, { target: { value: "50" } });
|
|
|
|
await act(async () => {
|
|
await vi.advanceTimersByTimeAsync(500);
|
|
});
|
|
vi.useRealTimers();
|
|
fireEvent.click(screen.getByRole("button", { name: /save change/i }));
|
|
|
|
await waitFor(() => expect(legacyMocks.updateSettings).toHaveBeenCalledWith(
|
|
{ maxConcurrent: 50, maxTriageConcurrent: 1, maxWorktrees: 4 },
|
|
"proj_123",
|
|
));
|
|
});
|
|
|
|
it("renders a load error state without crashing", async () => {
|
|
legacyMocks.fetchSettings.mockRejectedValue(new Error("settings unavailable"));
|
|
await openMenu();
|
|
|
|
expect(await screen.findByRole("alert")).toHaveTextContent("settings unavailable");
|
|
});
|
|
});
|