Self-hosted, plugin-based server management.
TypeScript dockerhomelabpluginsrdpremote-desktopself-hostedserver-managementsftpsshterminaltermixvnc
import { describe, expect, it } from "vitest";
import { buildHostTree } from "../../sidebar/build-host-tree.js";
import type { SSHHostWithStatus } from "@/main-axios";
import type { Host, HostFolder } from "@/types/ui-types";
function isFolder(item: Host | HostFolder): item is HostFolder {
return "children" in item;
}
type RawHostOverrides = {
id: number;
name?: string;
folder?: string;
/** Arrives as a number over the wire; sshHostToHost stringifies it. */
parentHostId?: number;
};
function rawHost(overrides: RawHostOverrides): SSHHostWithStatus {
return {
ip: "10.0.0.1",
port: 22,
username: "root",
authType: "password",
status: "unknown",
name: `host-${overrides.id}`,
...overrides,
} as unknown as SSHHostWithStatus;
}
describe("buildHostTree", () => {
it("places hosts with no folder or parent at root", () => {
const tree = buildHostTree([rawHost({ id: 1 }), rawHost({ id: 2 })]);
expect(tree.children).toHaveLength(2);
expect(tree.children.every((c) => !isFolder(c))).toBe(true);
});
it("nests a host under its parent via parentHostId, not as a folder wrapper", () => {
const tree = buildHostTree([
rawHost({ id: 1, name: "Zeus" }),
rawHost({ id: 2, name: "vm1", parentHostId: 1 }),
]);
expect(tree.children).toHaveLength(1);
const zeus = tree.children[0];
expect(isFolder(zeus)).toBe(false);
if (isFolder(zeus)) throw new Error("unreachable");
expect(zeus.name).toBe("Zeus");
expect(zeus.childHosts).toHaveLength(1);
expect(zeus.childHosts?.[0].name).toBe("vm1");
});
it("supports unlimited nesting depth", () => {
const tree = buildHostTree([
rawHost({ id: 1, name: "root-host" }),
rawHost({ id: 2, name: "child", parentHostId: 1 }),
rawHost({ id: 3, name: "grandchild", parentHostId: 2 }),
]);
const root = tree.children[0];
if (isFolder(root)) throw new Error("unreachable");
const child = root.childHosts?.[0];
expect(child?.name).toBe("child");
expect(child?.childHosts?.[0].name).toBe("grandchild");
});
it("falls back to root placement when the parent host is missing", () => {
const tree = buildHostTree([
rawHost({ id: 2, name: "orphan", parentHostId: 999 }),
]);
expect(tree.children).toHaveLength(1);
expect(tree.children[0].name).toBe("orphan");
});
it("falls back to root placement rather than looping on a cyclic parent chain", () => {
// Defensive case: stale/synced data where two hosts point at each other.
const tree = buildHostTree([
rawHost({ id: 1, name: "a", parentHostId: 2 }),
rawHost({ id: 2, name: "b", parentHostId: 1 }),
]);
// Neither host should vanish or cause an infinite loop -- both land at root.
expect(tree.children).toHaveLength(2);
});
it("prefers parentHostId nesting over folder placement", () => {
const tree = buildHostTree([
rawHost({ id: 1, name: "Zeus" }),
rawHost({
id: 2,
name: "vm1",
parentHostId: 1,
folder: "Production",
}),
]);
// The sub-host does not also appear under a "Production" folder node.
expect(tree.children).toHaveLength(1);
const zeus = tree.children[0];
if (isFolder(zeus)) throw new Error("unreachable");
expect(zeus.childHosts?.[0].name).toBe("vm1");
});
it("still places hosts by folder path when no parentHostId is set", () => {
const tree = buildHostTree([
rawHost({ id: 1, name: "web1", folder: "Production / Web" }),
]);
expect(tree.children).toHaveLength(1);
expect(isFolder(tree.children[0])).toBe(true);
});
});
describe("buildHostTree folder metadata", () => {
it("copies sortOrder onto the folder so manual sort can order folders", () => {
const tree = buildHostTree(
[rawHost({ id: 1, folder: "Prod" }), rawHost({ id: 2, folder: "Dev" })],
new Map([
["Prod", { sortOrder: 2000 }],
["Dev", { sortOrder: 1000 }],
]),
);
const folders = tree.children.filter(isFolder);
expect(folders.map((f) => [f.name, f.sortOrder])).toEqual(
expect.arrayContaining([
["Prod", 2000],
["Dev", 1000],
]),
);
});
it("leaves sortOrder null when the folder has no metadata row", () => {
const tree = buildHostTree([rawHost({ id: 1, folder: "Prod" })]);
expect(tree.children.filter(isFolder)[0].sortOrder).toBeNull();
});
});