paseo/packages/app/src/hooks/use-sidebar-workspaces-list.test.ts

import { describe, expect, it } from 'vitest'
import {
  appendMissingOrderKeys,
  applyStoredOrdering,
  buildSidebarProjectsFromWorkspaces,
} from './use-sidebar-workspaces-list'
import type { WorkspaceDescriptor } from '@/stores/session-store'

interface OrderedItem {
  key: string
}

function item(key: string): OrderedItem {
  return { key }
}

function workspace(
  input: Pick<WorkspaceDescriptor, "id" | "projectId" | "name" | "status" | "activityAt"> &
    Partial<
      Pick<
        WorkspaceDescriptor,
        "projectDisplayName" | "projectRootPath" | "projectKind" | "workspaceKind"
      >
    >
): WorkspaceDescriptor {
  return {
    id: input.id,
    projectId: input.projectId,
    projectDisplayName: input.projectDisplayName ?? input.projectId,
    projectRootPath: input.projectRootPath ?? input.id,
    projectKind: input.projectKind ?? "git",
    workspaceKind: input.workspaceKind ?? "local_checkout",
    name: input.name,
    status: input.status,
    activityAt: input.activityAt,
    diffStat: null,
  }
}

describe('applyStoredOrdering', () => {
  it('keeps unknown items on the baseline while applying stored order', () => {
    const result = applyStoredOrdering({
      items: [item('new'), item('a'), item('b')],
      storedOrder: ['b', 'a'],
      getKey: (entry) => entry.key,
    })

    expect(result.map((entry) => entry.key)).toEqual(['new', 'b', 'a'])
  })

  it('ignores stale and duplicate stored keys', () => {
    const result = applyStoredOrdering({
      items: [item('x'), item('y')],
      storedOrder: ['missing', 'y', 'y', 'x'],
      getKey: (entry) => entry.key,
    })

    expect(result.map((entry) => entry.key)).toEqual(['y', 'x'])
  })

  it('returns baseline when there is no persisted order', () => {
    const baseline = [item('first'), item('second')]
    const result = applyStoredOrdering({
      items: baseline,
      storedOrder: [],
      getKey: (entry) => entry.key,
    })

    expect(result).toBe(baseline)
  })
})

describe('appendMissingOrderKeys', () => {
  it('appends unseen keys while preserving existing order', () => {
    const result = appendMissingOrderKeys({
      currentOrder: ['project-b', 'project-a'],
      visibleKeys: ['project-a', 'project-b', 'project-c'],
    })

    expect(result).toEqual(['project-b', 'project-a', 'project-c'])
  })

  it('returns the same array when there are no unseen keys', () => {
    const currentOrder = ['project-a', 'project-b']

    const result = appendMissingOrderKeys({
      currentOrder,
      visibleKeys: ['project-b', 'project-a'],
    })

    expect(result).toBe(currentOrder)
  })
})

describe('buildSidebarProjectsFromWorkspaces', () => {
  it('uses workspace descriptor name and status directly', () => {
    const workspaces: WorkspaceDescriptor[] = [
      workspace({
        id: '/repo/main',
        projectId: 'project-1',
        name: 'feat/hard-cut',
        status: 'failed',
        activityAt: new Date('2026-01-01T00:00:00.000Z'),
      }),
    ]

    const projects = buildSidebarProjectsFromWorkspaces({
      serverId: 'srv',
      workspaces,
      projectOrder: [],
      workspaceOrderByScope: {},
    })

    expect(projects).toHaveLength(1)
    expect(projects[0]?.statusBucket).toBe('failed')
    expect(projects[0]?.workspaces[0]?.name).toBe('feat/hard-cut')
    expect(projects[0]?.workspaces[0]?.statusBucket).toBe('failed')
  })

  it('preserves stored project order even when activity changes', () => {
    const initialWorkspaces: WorkspaceDescriptor[] = [
      workspace({
        id: '/repo/b',
        projectId: 'project-b',
        name: 'feat/b',
        status: 'running',
        activityAt: new Date('2026-01-02T00:00:00.000Z'),
      }),
      workspace({
        id: '/repo/a',
        projectId: 'project-a',
        name: 'feat/a',
        status: 'running',
        activityAt: new Date('2026-01-01T00:00:00.000Z'),
      }),
    ]

    const seededOrder = appendMissingOrderKeys({
      currentOrder: [],
      visibleKeys: buildSidebarProjectsFromWorkspaces({
        serverId: 'srv',
        workspaces: initialWorkspaces,
        projectOrder: [],
        workspaceOrderByScope: {},
      }).map((project) => project.projectKey),
    })

    const updatedProjects = buildSidebarProjectsFromWorkspaces({
      serverId: 'srv',
      workspaces: [
        workspace({
          id: '/repo/b',
          projectId: 'project-b',
          name: 'feat/b',
          status: 'running',
          activityAt: new Date('2026-01-02T00:00:00.000Z'),
        }),
        workspace({
          id: '/repo/a',
          projectId: 'project-a',
          name: 'feat/a',
          status: 'running',
          activityAt: new Date('2026-01-03T00:00:00.000Z'),
        }),
      ],
      projectOrder: seededOrder,
      workspaceOrderByScope: {},
    })

    expect(updatedProjects.map((project) => project.projectKey)).toEqual(['project-b', 'project-a'])
  })

  it('appends new projects after the stored project order', () => {
    const projects = buildSidebarProjectsFromWorkspaces({
      serverId: 'srv',
      workspaces: [
        workspace({
          id: '/repo/c',
          projectId: 'project-c',
          name: 'feat/c',
          status: 'running',
          activityAt: new Date('2026-01-04T00:00:00.000Z'),
        }),
        workspace({
          id: '/repo/b',
          projectId: 'project-b',
          name: 'feat/b',
          status: 'running',
          activityAt: new Date('2026-01-02T00:00:00.000Z'),
        }),
        workspace({
          id: '/repo/a',
          projectId: 'project-a',
          name: 'feat/a',
          status: 'running',
          activityAt: new Date('2026-01-01T00:00:00.000Z'),
        }),
      ],
      projectOrder: ['project-b', 'project-a', 'project-c'],
      workspaceOrderByScope: {},
    })

    expect(projects.map((project) => project.projectKey)).toEqual(['project-b', 'project-a', 'project-c'])
  })

  it('preserves stored workspace order when workspace activity changes', () => {
    const initialProjects = buildSidebarProjectsFromWorkspaces({
      serverId: 'srv',
      workspaces: [
        workspace({
          id: '/repo/main',
          projectId: 'project-1',
          name: 'main',
          status: 'running',
          activityAt: new Date('2026-01-02T00:00:00.000Z'),
        }),
        workspace({
          id: '/repo/feature',
          projectId: 'project-1',
          name: 'feature',
          status: 'running',
          activityAt: new Date('2026-01-01T00:00:00.000Z'),
        }),
      ],
      projectOrder: ['project-1'],
      workspaceOrderByScope: {},
    })

    const seededWorkspaceOrder = appendMissingOrderKeys({
      currentOrder: [],
      visibleKeys: initialProjects[0]?.workspaces.map((workspace) => workspace.workspaceKey) ?? [],
    })

    const projects = buildSidebarProjectsFromWorkspaces({
      serverId: 'srv',
      workspaces: [
        workspace({
          id: '/repo/main',
          projectId: 'project-1',
          name: 'main',
          status: 'running',
          activityAt: new Date('2026-01-02T00:00:00.000Z'),
        }),
        workspace({
          id: '/repo/feature',
          projectId: 'project-1',
          name: 'feature',
          status: 'running',
          activityAt: new Date('2026-01-03T00:00:00.000Z'),
        }),
      ],
      projectOrder: ['project-1'],
      workspaceOrderByScope: {
        'srv::project-1': seededWorkspaceOrder,
      },
    })

    expect(projects[0]?.workspaces.map((workspace) => workspace.workspaceId)).toEqual([
      '/repo/main',
      '/repo/feature',
    ])
  })
})