mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-21 23:50:45 +00:00
328 lines
12 KiB
TypeScript
328 lines
12 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import type { Workspace, WorkspaceNode } from "./models.ts";
|
|
import {
|
|
appendPaneToWorkspaceRoot,
|
|
cloneWorkspaceTree,
|
|
collectSessionIds,
|
|
createEmptyWorkspaceRoot,
|
|
insertPaneIntoWorkspace,
|
|
movePaneInWorkspace,
|
|
pruneWorkspaceNode,
|
|
reorderWorkspaceFocusSessionOrder,
|
|
resolveWorkspaceFocusSessionOrder,
|
|
setWorkspaceFocusedSessionId,
|
|
} from "./workspace.ts";
|
|
|
|
const root: WorkspaceNode = {
|
|
id: "split-1",
|
|
type: "split",
|
|
direction: "vertical",
|
|
children: [
|
|
{ id: "pane-1", type: "pane", sessionId: "s1" },
|
|
{ id: "pane-2", type: "pane", sessionId: "s2" },
|
|
{ id: "pane-3", type: "pane", sessionId: "s3" },
|
|
],
|
|
};
|
|
|
|
test("resolveWorkspaceFocusSessionOrder follows tree order when no saved order exists", () => {
|
|
assert.deepEqual(resolveWorkspaceFocusSessionOrder(root), ["s1", "s2", "s3"]);
|
|
});
|
|
|
|
test("resolveWorkspaceFocusSessionOrder drops stale ids and appends new panes", () => {
|
|
assert.deepEqual(
|
|
resolveWorkspaceFocusSessionOrder(root, ["stale", "s3", "s1"]),
|
|
["s3", "s1", "s2"],
|
|
);
|
|
});
|
|
|
|
test("reorderWorkspaceFocusSessionOrder moves a session before a target", () => {
|
|
assert.deepEqual(
|
|
reorderWorkspaceFocusSessionOrder(root, undefined, "s3", "s1", "before"),
|
|
["s3", "s1", "s2"],
|
|
);
|
|
});
|
|
|
|
test("reorderWorkspaceFocusSessionOrder moves a session after a target", () => {
|
|
assert.deepEqual(
|
|
reorderWorkspaceFocusSessionOrder(root, ["s1", "s2", "s3"], "s1", "s3", "after"),
|
|
["s2", "s3", "s1"],
|
|
);
|
|
});
|
|
|
|
test("appendPaneToWorkspaceRoot ignores an existing session pane", () => {
|
|
assert.equal(appendPaneToWorkspaceRoot(root, "s2"), root);
|
|
});
|
|
|
|
test("the first appended terminal fills an empty workspace without an empty sibling", () => {
|
|
for (const direction of ["vertical", "horizontal"] as const) {
|
|
const emptyRoot = createEmptyWorkspaceRoot();
|
|
const result = appendPaneToWorkspaceRoot(emptyRoot, "first-terminal", direction);
|
|
assert.equal(result.type, "pane", direction);
|
|
if (result.type !== "pane") continue;
|
|
assert.equal(result.sessionId, "first-terminal");
|
|
assert.deepEqual(collectSessionIds(result), ["first-terminal"]);
|
|
assert.deepEqual(collectSessionIds(emptyRoot), []);
|
|
}
|
|
});
|
|
|
|
test("the first inserted terminal fills an empty workspace for every drop edge", () => {
|
|
for (const hint of [
|
|
{ direction: "vertical", position: "left" },
|
|
{ direction: "vertical", position: "right" },
|
|
{ direction: "horizontal", position: "top" },
|
|
{ direction: "horizontal", position: "bottom" },
|
|
] as const) {
|
|
const result = insertPaneIntoWorkspace(createEmptyWorkspaceRoot(), "first-terminal", hint);
|
|
assert.equal(result.type, "pane", hint.position);
|
|
if (result.type !== "pane") continue;
|
|
assert.equal(result.sessionId, "first-terminal");
|
|
assert.deepEqual(collectSessionIds(result), ["first-terminal"]);
|
|
}
|
|
});
|
|
|
|
test("insertPaneIntoWorkspace ignores an existing session pane", () => {
|
|
assert.equal(
|
|
insertPaneIntoWorkspace(root, "s2", {
|
|
direction: "vertical",
|
|
position: "right",
|
|
targetSessionId: "s1",
|
|
}),
|
|
root,
|
|
);
|
|
});
|
|
|
|
const nestedRoot: WorkspaceNode = {
|
|
id: "split-root",
|
|
type: "split",
|
|
direction: "vertical",
|
|
sizes: [0.8, 0.2],
|
|
children: [
|
|
{ id: "pane-a", type: "pane", sessionId: "s1" },
|
|
{
|
|
id: "split-inner",
|
|
type: "split",
|
|
direction: "horizontal",
|
|
sizes: [0.5, 0.5],
|
|
children: [
|
|
{ id: "pane-b", type: "pane", sessionId: "s2" },
|
|
{ id: "pane-c", type: "pane", sessionId: "s3" },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
test("cloneWorkspaceTree remaps every sessionId and preserves direction/sizes", () => {
|
|
const map = new Map([["s1", "n1"], ["s2", "n2"], ["s3", "n3"]]);
|
|
const clone = cloneWorkspaceTree(nestedRoot, map);
|
|
|
|
assert.equal(clone.type, "split");
|
|
if (clone.type !== "split") return;
|
|
assert.equal(clone.direction, "vertical");
|
|
assert.deepEqual(clone.sizes, [0.8, 0.2]);
|
|
const inner = clone.children[1];
|
|
assert.equal(inner.type, "split");
|
|
if (inner.type !== "split") return;
|
|
assert.equal(inner.direction, "horizontal");
|
|
assert.deepEqual(inner.sizes, [0.5, 0.5]);
|
|
|
|
const collect = (n: WorkspaceNode): string[] =>
|
|
n.type === "pane" ? [n.sessionId] : n.children.flatMap(collect);
|
|
assert.deepEqual(collect(clone), ["n1", "n2", "n3"]);
|
|
});
|
|
|
|
test("cloneWorkspaceTree mints fresh node ids and does not mutate the source", () => {
|
|
const map = new Map([["s1", "n1"], ["s2", "n2"], ["s3", "n3"]]);
|
|
const clone = cloneWorkspaceTree(nestedRoot, map);
|
|
assert.notEqual(clone.id, nestedRoot.id);
|
|
assert.equal(nestedRoot.id, "split-root");
|
|
const collectSrc = (n: WorkspaceNode): string[] =>
|
|
n.type === "pane" ? [n.sessionId] : n.children.flatMap(collectSrc);
|
|
assert.deepEqual(collectSrc(nestedRoot), ["s1", "s2", "s3"]);
|
|
|
|
const collectIds = (n: WorkspaceNode): string[] =>
|
|
n.type === "pane" ? [n.id] : [n.id, ...n.children.flatMap(collectIds)];
|
|
const srcIds = new Set(collectIds(nestedRoot));
|
|
assert.ok(collectIds(clone).every(id => !srcIds.has(id)));
|
|
});
|
|
|
|
test("cloneWorkspaceTree uses pre-minted node ids when supplied", () => {
|
|
const clone = cloneWorkspaceTree(
|
|
nestedRoot,
|
|
new Map([["s1", "n1"], ["s2", "n2"], ["s3", "n3"]]),
|
|
new Map([["split-root", "new-root"], ["pane-a", "new-a"], ["split-inner", "new-inner"], ["pane-b", "new-b"], ["pane-c", "new-c"]]),
|
|
);
|
|
assert.equal(clone.id, "new-root");
|
|
if (clone.type !== "split") return;
|
|
assert.equal(clone.children[0].id, "new-a");
|
|
assert.equal(clone.children[1].id, "new-inner");
|
|
});
|
|
|
|
test("cloneWorkspaceTree keeps original sessionId when the map lacks it", () => {
|
|
const clone = cloneWorkspaceTree(
|
|
{ id: "p", type: "pane", sessionId: "s1" },
|
|
new Map(),
|
|
);
|
|
assert.equal(clone.type === "pane" && clone.sessionId, "s1");
|
|
});
|
|
|
|
test("setWorkspaceFocusedSessionId keeps the same array when focus is unchanged", () => {
|
|
const workspaces = [
|
|
{ id: "ws-1", title: "One", root, focusedSessionId: "s2" },
|
|
{ id: "ws-2", title: "Two", root, focusedSessionId: "s1" },
|
|
] as Workspace[];
|
|
// Pane click + focus capture both call the setter; neither may re-render the shell.
|
|
assert.equal(setWorkspaceFocusedSessionId(workspaces, "ws-1", "s2"), workspaces);
|
|
assert.equal(setWorkspaceFocusedSessionId(workspaces, "missing", "s3"), workspaces);
|
|
});
|
|
|
|
test("setWorkspaceFocusedSessionId replaces only the focused workspace", () => {
|
|
const workspaces = [
|
|
{ id: "ws-1", title: "One", root, focusedSessionId: "s2" },
|
|
{ id: "ws-2", title: "Two", root, focusedSessionId: "s1" },
|
|
] as Workspace[];
|
|
const next = setWorkspaceFocusedSessionId(workspaces, "ws-1", "s3");
|
|
assert.notEqual(next, workspaces);
|
|
assert.equal(next[0].focusedSessionId, "s3");
|
|
assert.equal(next[1], workspaces[1]);
|
|
assert.equal(workspaces[0].focusedSessionId, "s2", "input is not mutated");
|
|
});
|
|
|
|
// --- movePaneInWorkspace (#4037) ---
|
|
|
|
const collectPaneNodeIds = (n: WorkspaceNode): string[] =>
|
|
n.type === "pane" ? [n.id] : n.children.flatMap(collectPaneNodeIds);
|
|
|
|
const assertEverySplitSizesValid = (n: WorkspaceNode): void => {
|
|
if (n.type === "pane") return;
|
|
assert.equal(n.sizes?.length, n.children.length, "every split sizes its children");
|
|
for (const size of n.sizes ?? []) {
|
|
assert.ok(Number.isFinite(size) && size > 0, "sizes are positive finite numbers");
|
|
}
|
|
n.children.forEach(assertEverySplitSizesValid);
|
|
};
|
|
|
|
test("movePaneInWorkspace moves a pane to the left/right of a sibling", () => {
|
|
const left = movePaneInWorkspace(root, "s3", { direction: "vertical", position: "left", targetSessionId: "s1" });
|
|
assert.deepEqual(collectSessionIds(left), ["s3", "s1", "s2"]);
|
|
|
|
const right = movePaneInWorkspace(root, "s1", { direction: "vertical", position: "right", targetSessionId: "s2" });
|
|
assert.deepEqual(collectSessionIds(right), ["s2", "s1", "s3"]);
|
|
});
|
|
|
|
test("movePaneInWorkspace moves a pane above/below a sibling", () => {
|
|
const top = movePaneInWorkspace(root, "s3", { direction: "horizontal", position: "top", targetSessionId: "s1" });
|
|
assert.deepEqual(collectSessionIds(top), ["s3", "s1", "s2"]);
|
|
|
|
const bottom = movePaneInWorkspace(root, "s2", { direction: "horizontal", position: "bottom", targetSessionId: "s3" });
|
|
assert.deepEqual(collectSessionIds(bottom), ["s1", "s3", "s2"]);
|
|
});
|
|
|
|
test("movePaneInWorkspace rebalances sizes and keeps membership identical", () => {
|
|
const moved = movePaneInWorkspace(root, "s3", { direction: "vertical", position: "left", targetSessionId: "s1" });
|
|
assert.deepEqual(collectSessionIds(moved).sort(), collectSessionIds(root).sort(), "membership unchanged");
|
|
assertEverySplitSizesValid(moved);
|
|
});
|
|
|
|
test("movePaneInWorkspace keeps untouched pane node ids stable and does not mutate the source", () => {
|
|
const moved = movePaneInWorkspace(root, "s3", { direction: "vertical", position: "left", targetSessionId: "s1" });
|
|
const after = collectPaneNodeIds(moved);
|
|
for (const id of ["pane-1", "pane-2"]) {
|
|
assert.ok(after.includes(id), `untouched pane ${id} keeps its node id`);
|
|
}
|
|
assert.deepEqual(collectSessionIds(root), ["s1", "s2", "s3"], "source tree is not mutated");
|
|
assert.deepEqual(root.type === "split" ? root.children.map(c => c.id) : [], ["pane-1", "pane-2", "pane-3"]);
|
|
});
|
|
|
|
test("movePaneInWorkspace without a target wraps the pruned root (move to root split)", () => {
|
|
const moved = movePaneInWorkspace(root, "s2", { direction: "vertical", position: "right" });
|
|
assert.deepEqual(collectSessionIds(moved), ["s1", "s3", "s2"]);
|
|
assert.equal(moved.type, "split");
|
|
if (moved.type !== "split") return;
|
|
assert.equal(moved.children[1].type, "pane");
|
|
if (moved.children[1].type !== "pane") return;
|
|
assert.equal(moved.children[1].sessionId, "s2");
|
|
});
|
|
|
|
test("movePaneInWorkspace handles a target inside the source subtree", () => {
|
|
const subtreeRoot: WorkspaceNode = {
|
|
id: "split-root",
|
|
type: "split",
|
|
direction: "vertical",
|
|
sizes: [0.7, 0.3],
|
|
children: [
|
|
{
|
|
id: "split-inner",
|
|
type: "split",
|
|
direction: "horizontal",
|
|
sizes: [0.5, 0.5],
|
|
children: [
|
|
{ id: "pane-a", type: "pane", sessionId: "s1" },
|
|
{ id: "pane-b", type: "pane", sessionId: "s2" },
|
|
],
|
|
},
|
|
{ id: "pane-c", type: "pane", sessionId: "s3" },
|
|
],
|
|
};
|
|
|
|
// s1 leaves the inner split, which collapses onto s2; s1 then lands as a
|
|
// new sibling of s2.
|
|
const moved = movePaneInWorkspace(subtreeRoot, "s1", { direction: "vertical", position: "right", targetSessionId: "s2" });
|
|
assert.deepEqual(collectSessionIds(moved), ["s2", "s1", "s3"]);
|
|
assertEverySplitSizesValid(moved);
|
|
});
|
|
|
|
test("movePaneInWorkspace is a no-op when the pane drops onto itself", () => {
|
|
assert.equal(
|
|
movePaneInWorkspace(root, "s2", { direction: "vertical", position: "left", targetSessionId: "s2" }),
|
|
root,
|
|
);
|
|
});
|
|
|
|
test("movePaneInWorkspace is a no-op for a single-pane workspace", () => {
|
|
const single: WorkspaceNode = { id: "pane-only", type: "pane", sessionId: "s1" };
|
|
assert.equal(
|
|
movePaneInWorkspace(single, "s1", { direction: "vertical", position: "left", targetSessionId: "s1" }),
|
|
single,
|
|
);
|
|
// Also when the lone pane sits behind a collapsed split.
|
|
const wrapped: WorkspaceNode = {
|
|
id: "split-wrap",
|
|
type: "split",
|
|
direction: "vertical",
|
|
children: [{ id: "pane-only-2", type: "pane", sessionId: "s1" }],
|
|
sizes: [1],
|
|
};
|
|
assert.equal(
|
|
movePaneInWorkspace(wrapped, "s1", { direction: "vertical", position: "left" }),
|
|
wrapped,
|
|
);
|
|
});
|
|
|
|
test("movePaneInWorkspace is a no-op for an unknown session", () => {
|
|
assert.equal(
|
|
movePaneInWorkspace(root, "ghost", { direction: "vertical", position: "left", targetSessionId: "s1" }),
|
|
root,
|
|
);
|
|
});
|
|
|
|
test("movePaneInWorkspace keeps the source when its drop target closed during dragging", () => {
|
|
const hint = { direction: "vertical", position: "right", targetSessionId: "s2" } as const;
|
|
const afterTargetClosed = pruneWorkspaceNode(root, "s2");
|
|
assert.ok(afterTargetClosed);
|
|
assert.deepEqual(collectSessionIds(afterTargetClosed), ["s1", "s3"]);
|
|
|
|
const moved = movePaneInWorkspace(afterTargetClosed, "s1", hint);
|
|
assert.equal(moved, afterTargetClosed, "a stale drop must preserve the current tree");
|
|
assert.deepEqual(collectSessionIds(moved), ["s1", "s3"], "the dragged terminal remains present");
|
|
});
|
|
|
|
test("movePaneInWorkspace preserves the original root for a missing explicit target", () => {
|
|
const moved = movePaneInWorkspace(root, "s2", {
|
|
direction: "horizontal", position: "bottom", targetSessionId: "missing",
|
|
});
|
|
assert.equal(moved, root);
|
|
assert.deepEqual(collectSessionIds(moved), ["s1", "s2", "s3"]);
|
|
});
|