mirror of
https://github.com/getpaseo/paseo.git
synced 2026-07-29 12:01:31 +00:00
90e0a0e353
* feat(app): add workspaces to command center * fix(app): scale down command center typography * fix(app): avoid workspace theme subscription * fix(app): theme command center bottom sheet * fix(app): tighten command center workspace results
596 lines
18 KiB
TypeScript
596 lines
18 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import type { ProjectPlacementPayload } from "@getpaseo/protocol/messages";
|
|
import type { WorkspaceDescriptor } from "@/stores/session-store";
|
|
import { buildProjects } from "./projects";
|
|
|
|
function placement(input: {
|
|
projectKey: string;
|
|
projectName: string;
|
|
cwd: string;
|
|
remoteUrl: string | null;
|
|
mainRepoRoot?: string | null;
|
|
}): ProjectPlacementPayload {
|
|
return {
|
|
projectKey: input.projectKey,
|
|
projectName: input.projectName,
|
|
checkout: {
|
|
cwd: input.cwd,
|
|
isGit: true,
|
|
currentBranch: "main",
|
|
remoteUrl: input.remoteUrl,
|
|
worktreeRoot: input.cwd,
|
|
isPaseoOwnedWorktree: false,
|
|
mainRepoRoot: input.mainRepoRoot ?? null,
|
|
},
|
|
};
|
|
}
|
|
|
|
function workspace(input: {
|
|
id: string;
|
|
repoRoot: string;
|
|
project?: ProjectPlacementPayload;
|
|
projectId?: string;
|
|
projectName?: string;
|
|
remoteUrl?: string | null;
|
|
currentBranch?: string;
|
|
archivingAt?: string | null;
|
|
}): WorkspaceDescriptor {
|
|
return {
|
|
id: input.id,
|
|
projectId: input.projectId ?? input.project?.projectKey ?? input.repoRoot,
|
|
projectDisplayName: input.projectName ?? input.project?.projectName ?? "Project",
|
|
projectRootPath: input.repoRoot,
|
|
workspaceDirectory: input.repoRoot,
|
|
projectKind: "git",
|
|
workspaceKind: "local_checkout",
|
|
name: input.id,
|
|
status: "done",
|
|
archivingAt: input.archivingAt ?? null,
|
|
statusEnteredAt: null,
|
|
diffStat: null,
|
|
scripts: [],
|
|
gitRuntime: {
|
|
currentBranch: input.currentBranch ?? "main",
|
|
remoteUrl: input.remoteUrl ?? input.project?.checkout.remoteUrl ?? null,
|
|
isPaseoOwnedWorktree: false,
|
|
isDirty: false,
|
|
aheadBehind: null,
|
|
aheadOfOrigin: null,
|
|
behindOfOrigin: null,
|
|
},
|
|
githubRuntime: null,
|
|
project: input.project,
|
|
};
|
|
}
|
|
|
|
describe("buildProjects", () => {
|
|
it("normalizes detached and blank branches out of workspace summaries", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({ id: "detached", repoRoot: "/repo/app", currentBranch: "HEAD" }),
|
|
workspace({ id: "blank", repoRoot: "/repo/app", currentBranch: " " }),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects[0]?.hosts[0]?.workspaces).toMatchObject([
|
|
{ id: "detached", currentBranch: null },
|
|
{ id: "blank", currentBranch: null },
|
|
]);
|
|
});
|
|
|
|
it("carries active archive state into workspace summaries", () => {
|
|
const archivingAt = "2026-07-15T18:00:00.000Z";
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({ id: "archiving", repoRoot: "/repo/app", archivingAt }),
|
|
workspace({ id: "active", repoRoot: "/repo/app" }),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects[0]?.hosts[0]?.workspaces).toMatchObject([
|
|
{ id: "archiving", archivingAt },
|
|
{ id: "active" },
|
|
]);
|
|
expect(result.projects[0]?.hosts[0]?.workspaces[1]).not.toHaveProperty("archivingAt");
|
|
});
|
|
|
|
it("groups two daemons with the same GitHub project key into one project with one host entry per daemon", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "main",
|
|
repoRoot: "/repo/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/app",
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "feature-a",
|
|
repoRoot: "/repo/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/app/feature-a",
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "feature-b",
|
|
repoRoot: "/repo/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/app/feature-b",
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
{
|
|
serverId: "laptop",
|
|
serverName: "Laptop",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "main",
|
|
repoRoot: "/work/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/work/app",
|
|
remoteUrl: "git@github.com:acme/app.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "feature",
|
|
repoRoot: "/work/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/work/app/feature",
|
|
remoteUrl: "git@github.com:acme/app.git",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects).toHaveLength(1);
|
|
const summary = result.projects[0];
|
|
expect(summary?.projectKey).toBe("remote:github.com/acme/app");
|
|
expect(summary?.projectName).toBe("acme/app");
|
|
expect(summary?.hostCount).toBe(2);
|
|
expect(summary?.onlineHostCount).toBe(2);
|
|
expect(summary?.totalWorkspaceCount).toBe(5);
|
|
expect(summary?.githubUrl).toBe("https://github.com/acme/app");
|
|
expect(summary?.hosts).toHaveLength(2);
|
|
const local = summary?.hosts.find((host) => host.serverId === "local");
|
|
const laptop = summary?.hosts.find((host) => host.serverId === "laptop");
|
|
expect(local?.workspaceCount).toBe(3);
|
|
expect(laptop?.workspaceCount).toBe(2);
|
|
expect(local?.workspaces.map((entry) => entry.id)).toEqual(["main", "feature-a", "feature-b"]);
|
|
expect(laptop?.workspaces.map((entry) => entry.id)).toEqual(["main", "feature"]);
|
|
});
|
|
|
|
it("collapses five workspaces on one host into a single host entry whose workspaceCount is five", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: Array.from({ length: 5 }, (_, index) =>
|
|
workspace({
|
|
id: `ws-${index}`,
|
|
repoRoot: "/repo/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: `/repo/app/ws-${index}`,
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
}),
|
|
}),
|
|
),
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects).toHaveLength(1);
|
|
expect(result.projects[0]?.hosts).toHaveLength(1);
|
|
expect(result.projects[0]?.hosts[0]?.workspaceCount).toBe(5);
|
|
expect(result.projects[0]?.totalWorkspaceCount).toBe(5);
|
|
expect(result.projects[0]?.hostCount).toBe(1);
|
|
});
|
|
|
|
it("prefers placement mainRepoRoot for the host repoRoot and falls back to projectRootPath when placement is absent", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "main",
|
|
repoRoot: "/worktrees/app/main",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/worktrees/app/main",
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
mainRepoRoot: "/repo/app",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
{
|
|
serverId: "legacy",
|
|
serverName: "Legacy",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "legacy",
|
|
repoRoot: "/repo/legacy",
|
|
projectId: "legacy-project",
|
|
projectName: "Legacy",
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
const acme = result.projects.find(
|
|
(project) => project.projectKey === "remote:github.com/acme/app",
|
|
);
|
|
const legacy = result.projects.find((project) => project.projectKey === "legacy-project");
|
|
|
|
expect(acme?.hosts[0]?.repoRoot).toBe("/repo/app");
|
|
expect(legacy?.hosts[0]?.repoRoot).toBe("/repo/legacy");
|
|
});
|
|
|
|
it("derives githubUrl only when projectKey matches remote:github.com/{owner}/{repo}", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "github",
|
|
repoRoot: "/repo/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/app",
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "local",
|
|
repoRoot: "/repo/local",
|
|
project: placement({
|
|
projectKey: "/repo/local",
|
|
projectName: "local",
|
|
cwd: "/repo/local",
|
|
remoteUrl: null,
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
const github = result.projects.find(
|
|
(project) => project.projectKey === "remote:github.com/acme/app",
|
|
);
|
|
const local = result.projects.find((project) => project.projectKey === "/repo/local");
|
|
|
|
expect(github?.githubUrl).toBe("https://github.com/acme/app");
|
|
expect(local?.githubUrl).toBeUndefined();
|
|
});
|
|
|
|
it("totals hostCount across all hosts and counts only online ones in onlineHostCount", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "online",
|
|
serverName: "Online",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "ws",
|
|
repoRoot: "/repo/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/app",
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
{
|
|
serverId: "offline",
|
|
serverName: "Offline",
|
|
isOnline: false,
|
|
workspaces: [
|
|
workspace({
|
|
id: "ws",
|
|
repoRoot: "/repo/app",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/app",
|
|
remoteUrl: "https://github.com/acme/app.git",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects).toHaveLength(1);
|
|
expect(result.projects[0]?.hostCount).toBe(2);
|
|
expect(result.projects[0]?.onlineHostCount).toBe(1);
|
|
expect(result.projects[0]?.hosts.find((host) => host.serverId === "online")?.isOnline).toBe(
|
|
true,
|
|
);
|
|
expect(result.projects[0]?.hosts.find((host) => host.serverId === "offline")?.isOnline).toBe(
|
|
false,
|
|
);
|
|
});
|
|
|
|
it("does not merge fallback repo-root-keyed projects with different roots", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "one",
|
|
repoRoot: "/repo/one",
|
|
project: placement({
|
|
projectKey: "/repo/one",
|
|
projectName: "one",
|
|
cwd: "/repo/one",
|
|
remoteUrl: null,
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "two",
|
|
repoRoot: "/repo/two",
|
|
project: placement({
|
|
projectKey: "/repo/two",
|
|
projectName: "two",
|
|
cwd: "/repo/two",
|
|
remoteUrl: null,
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects.map((project) => project.projectKey)).toEqual([
|
|
"/repo/one",
|
|
"/repo/two",
|
|
]);
|
|
});
|
|
|
|
it("includes GitHub, GitLab, Bitbucket and local projects together, sorted by name", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "github",
|
|
repoRoot: "/repo/github",
|
|
project: placement({
|
|
projectKey: "remote:github.com/acme/web",
|
|
projectName: "acme/web",
|
|
cwd: "/repo/github",
|
|
remoteUrl: "https://github.com/acme/web.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "gitlab",
|
|
repoRoot: "/repo/gitlab",
|
|
project: placement({
|
|
projectKey: "remote:gitlab.com/acme/api",
|
|
projectName: "acme/api",
|
|
cwd: "/repo/gitlab",
|
|
remoteUrl: "https://gitlab.com/acme/api.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "bitbucket",
|
|
repoRoot: "/repo/bitbucket",
|
|
project: placement({
|
|
projectKey: "remote:bitbucket.org/acme/cli",
|
|
projectName: "acme/cli",
|
|
cwd: "/repo/bitbucket",
|
|
remoteUrl: "https://bitbucket.org/acme/cli.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "local",
|
|
repoRoot: "/repo/local",
|
|
project: placement({
|
|
projectKey: "/repo/local",
|
|
projectName: "local",
|
|
cwd: "/repo/local",
|
|
remoteUrl: null,
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects.map((project) => project.projectKey)).toEqual([
|
|
"remote:gitlab.com/acme/api",
|
|
"remote:bitbucket.org/acme/cli",
|
|
"remote:github.com/acme/web",
|
|
"/repo/local",
|
|
]);
|
|
});
|
|
|
|
it("renders a non-GitHub remote project on its own when no other projects are present", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "gitlab",
|
|
repoRoot: "/repo/gitlab",
|
|
project: placement({
|
|
projectKey: "remote:gitlab.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/gitlab",
|
|
remoteUrl: "https://gitlab.com/acme/app.git",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects).toHaveLength(1);
|
|
expect(result.projects[0]?.projectKey).toBe("remote:gitlab.com/acme/app");
|
|
expect(result.projects[0]?.projectName).toBe("acme/app");
|
|
expect(result.projects[0]?.githubUrl).toBeUndefined();
|
|
});
|
|
|
|
it("groups two workspaces sharing a non-GitHub remote into one project with workspaceCount two", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "main",
|
|
repoRoot: "/repo/gitlab",
|
|
project: placement({
|
|
projectKey: "remote:gitlab.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/gitlab",
|
|
remoteUrl: "https://gitlab.com/acme/app.git",
|
|
}),
|
|
}),
|
|
workspace({
|
|
id: "feature",
|
|
repoRoot: "/repo/gitlab",
|
|
project: placement({
|
|
projectKey: "remote:gitlab.com/acme/app",
|
|
projectName: "acme/app",
|
|
cwd: "/repo/gitlab/feature",
|
|
remoteUrl: "https://gitlab.com/acme/app.git",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects).toHaveLength(1);
|
|
expect(result.projects[0]?.hosts).toHaveLength(1);
|
|
expect(result.projects[0]?.hosts[0]?.workspaceCount).toBe(2);
|
|
});
|
|
|
|
it("falls back conservatively for mixed-version daemons whose descriptors lack project", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "old-daemon",
|
|
serverName: "Old daemon",
|
|
isOnline: true,
|
|
workspaces: [
|
|
workspace({
|
|
id: "legacy",
|
|
repoRoot: "/repo/legacy",
|
|
projectId: "legacy-project",
|
|
projectName: "Legacy",
|
|
remoteUrl: "https://gitlab.com/acme/legacy.git",
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects).toHaveLength(1);
|
|
const summary = result.projects[0];
|
|
expect(summary?.projectKey).toBe("legacy-project");
|
|
expect(summary?.projectName).toBe("Legacy");
|
|
expect(summary?.githubUrl).toBeUndefined();
|
|
expect(summary?.hosts).toHaveLength(1);
|
|
expect(summary?.hosts[0]?.repoRoot).toBe("/repo/legacy");
|
|
expect(summary?.hosts[0]?.workspaceCount).toBe(1);
|
|
});
|
|
|
|
it("surfaces a project with no workspaces yet and gives its host an editable repoRoot", () => {
|
|
const result = buildProjects({
|
|
hosts: [
|
|
{
|
|
serverId: "local",
|
|
serverName: "Local",
|
|
isOnline: true,
|
|
workspaces: [],
|
|
emptyProjects: [
|
|
{
|
|
projectId: "/repo/fresh",
|
|
projectDisplayName: "fresh",
|
|
projectCustomName: null,
|
|
projectRootPath: "/repo/fresh",
|
|
projectKind: "git",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(result.projects).toHaveLength(1);
|
|
const summary = result.projects[0];
|
|
expect(summary?.projectKey).toBe("/repo/fresh");
|
|
expect(summary?.totalWorkspaceCount).toBe(0);
|
|
expect(summary?.hosts).toHaveLength(1);
|
|
// repoRoot must be non-empty or the project settings screen treats the host
|
|
// as non-editable and shows its empty state.
|
|
expect(summary?.hosts[0]?.repoRoot).toBe("/repo/fresh");
|
|
expect(summary?.hosts[0]?.workspaceCount).toBe(0);
|
|
});
|
|
});
|