From c9307762316951a3b80e0ba7a2133096b55186b8 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:26:52 +0800 Subject: [PATCH] Import apps/android/tests/workspace-tree.test.ts --- apps/android/tests/workspace-tree.test.ts | 378 ++++++++++++++++++++++ 1 file changed, 378 insertions(+) create mode 100644 apps/android/tests/workspace-tree.test.ts diff --git a/apps/android/tests/workspace-tree.test.ts b/apps/android/tests/workspace-tree.test.ts new file mode 100644 index 0000000..042464e --- /dev/null +++ b/apps/android/tests/workspace-tree.test.ts @@ -0,0 +1,378 @@ +import { describe, expect, it } from 'vitest' +import { + applyManualOrder, + buildTreeSections, + buildWorkspaceTreeParents, + folderPath, + getWorkspaceAncestors, + owningParentFolder, + reorderSessionIds, + resolveSearchHitAncestors, + type WorkspaceItemLike, +} from '../src/lib/workspace-tree' +import type { RemoteSession } from '../src/types' + +describe('workspace-tree utilities', () => { + describe('folderPath', () => { + it('normalizes backslashes to forward slashes on Windows paths', () => { + expect(folderPath('C:\\Users\\dev\\project')).toBe('C:/Users/dev/project') + expect(folderPath('D:\\repo\\sub\\')).toBe('D:/repo/sub') + }) + + it('strips trailing slashes but preserves single root slash', () => { + expect(folderPath('/home/user/app/')).toBe('/home/user/app') + expect(folderPath('/home/user/app///')).toBe('/home/user/app') + expect(folderPath('/')).toBe('') + expect(folderPath('')).toBe('') + }) + }) + + describe('owningParentFolder', () => { + it('finds the nearest registered ancestor workspace path', () => { + const registered = [ + '/home/user/repo', + '/home/user/repo/apps', + '/home/user/repo/apps/web', + ] + expect(owningParentFolder('/home/user/repo/apps/android', registered)).toBe('/home/user/repo/apps') + expect(owningParentFolder('/home/user/repo/apps/web', registered)).toBe('/home/user/repo/apps') + expect(owningParentFolder('/home/user/repo/docs', registered)).toBe('/home/user/repo') + expect(owningParentFolder('/home/user/other', registered)).toBeUndefined() + }) + + it('enforces directory boundary matching so partial segment matches are rejected', () => { + const registered = ['/home/user/repo'] + expect(owningParentFolder('/home/user/report', registered)).toBeUndefined() + expect(owningParentFolder('/home/user/repo-fork', registered)).toBeUndefined() + expect(owningParentFolder('/home/user/repo/sub', registered)).toBe('/home/user/repo') + }) + + it('handles Windows drive paths with mixed separators', () => { + const registered = ['C:\\Projects\\MyApp', 'C:\\Projects\\MyApp\\modules'] + expect(owningParentFolder('C:/Projects/MyApp/modules/core', registered)).toBe('C:\\Projects\\MyApp\\modules') + expect(owningParentFolder('C:\\Projects\\MyApp\\readme.md', registered)).toBe('C:\\Projects\\MyApp') + }) + }) + + describe('buildWorkspaceTreeParents & getWorkspaceAncestors', () => { + const workspaces: WorkspaceItemLike[] = [ + { workspaceId: 'root', title: 'Root', path: '/workspace', sessionIds: ['s1'] }, + { workspaceId: 'pkgA', title: 'Package A', path: '/workspace/packages/a', sessionIds: ['s2'] }, + { workspaceId: 'pkgB', title: 'Package B', path: '/workspace/packages/b', sessionIds: ['s3'] }, + { workspaceId: 'pkgA_sub', title: 'A Sub', path: '/workspace/packages/a/sub', sessionIds: ['s4'] }, + { workspaceId: 'independent', title: 'Independent', path: '/other/path', sessionIds: ['s5'] }, + ] + + it('builds parent relationships correctly', () => { + const parents = buildWorkspaceTreeParents(workspaces) + expect(parents.get('root')).toBeUndefined() + expect(parents.get('pkgA')).toBe('root') + expect(parents.get('pkgB')).toBe('root') + expect(parents.get('pkgA_sub')).toBe('pkgA') + expect(parents.get('independent')).toBeUndefined() + }) + + it('computes ancestors from nearest to root', () => { + const parents = buildWorkspaceTreeParents(workspaces) + expect(getWorkspaceAncestors('pkgA_sub', parents)).toEqual(['pkgA', 'root']) + expect(getWorkspaceAncestors('pkgA', parents)).toEqual(['root']) + expect(getWorkspaceAncestors('root', parents)).toEqual([]) + expect(getWorkspaceAncestors('independent', parents)).toEqual([]) + }) + + it('resolves search hit ancestors to expand all parents of matching workspaces', () => { + const parents = buildWorkspaceTreeParents(workspaces) + const expanded = resolveSearchHitAncestors(['pkgA_sub'], parents) + expect(expanded.has('pkgA_sub')).toBe(true) + expect(expanded.has('pkgA')).toBe(true) + expect(expanded.has('root')).toBe(true) + expect(expanded.has('pkgB')).toBe(false) + expect(expanded.has('independent')).toBe(false) + }) + }) + + describe('applyManualOrder', () => { + const makeSession = (id: string, updatedAt: number): RemoteSession => ({ + sessionId: id, + title: `Session ${id}`, + updatedAt, + backend: 'harness', + running: false, + blank: false, + }) + + it('reorders sessions according to saved manual positions', () => { + const sessions = [ + makeSession('s1', 100), + makeSession('s2', 200), + makeSession('s3', 300), + ] + const savedOrder = ['s3', 's1', 's2'] + const reordered = applyManualOrder(sessions, savedOrder) + expect(reordered.map(s => s.sessionId)).toEqual(['s3', 's1', 's2']) + }) + + it('preserves existing saved positions and appends newly created sessions at the end', () => { + const sessions = [ + makeSession('s1', 100), + makeSession('s2', 200), + makeSession('s3', 300), + makeSession('s4_new', 400), + ] + const savedOrder = ['s2', 's1', 's3'] + const reordered = applyManualOrder(sessions, savedOrder) + expect(reordered.map(s => s.sessionId)).toEqual(['s2', 's1', 's3', 's4_new']) + }) + + it('returns original list if saved order is empty or undefined', () => { + const sessions = [makeSession('s1', 100), makeSession('s2', 200)] + expect(applyManualOrder(sessions, undefined).map(s => s.sessionId)).toEqual(['s1', 's2']) + expect(applyManualOrder(sessions, []).map(s => s.sessionId)).toEqual(['s1', 's2']) + }) + }) + + describe('reorderSessionIds', () => { + const list = ['s1', 's2', 's3', 's4', 's5'] + + it('moves an item forward/downward (after target) and shifts intermediate items left', () => { + // Dragging s1 down to s2 inserts s1 after s2 + expect(reorderSessionIds(list, 's1', 's2', 'after')).toEqual(['s2', 's1', 's3', 's4', 's5']) + // Dragging s1 down to s3 inserts s1 after s3 + expect(reorderSessionIds(list, 's1', 's3', 'after')).toEqual(['s2', 's3', 's1', 's4', 's5']) + }) + + it('moves an item backward/upward (before target) and shifts intermediate items right', () => { + // Dragging s4 up to s2 inserts s4 before s2 + expect(reorderSessionIds(list, 's4', 's2', 'before')).toEqual(['s1', 's4', 's2', 's3', 's5']) + // Dragging s5 up to s1 inserts s5 before s1 + expect(reorderSessionIds(list, 's5', 's1', 'before')).toEqual(['s5', 's1', 's2', 's3', 's4']) + }) + + it('preserves hidden/archived sessions in their relative positions during reordering', () => { + const withArchived = ['s1', 'archived1', 's2', 's3'] + // Moving s3 up to s1 inserts s3 before s1 while archived1 stays right after s1 + expect(reorderSessionIds(withArchived, 's3', 's1', 'before')).toEqual(['s3', 's1', 'archived1', 's2']) + // Moving s1 down to s2 inserts s1 after s2 while archived1 stays ahead + expect(reorderSessionIds(withArchived, 's1', 's2', 'after')).toEqual(['archived1', 's2', 's1', 's3']) + }) + + it('preserves order if source and target are the same or not found', () => { + expect(reorderSessionIds(list, 's2', 's2')).toEqual(list) + expect(reorderSessionIds(list, 'missing', 's2')).toEqual(list) + }) + }) + + describe('buildTreeSections', () => { + const makeSession = (id: string, updatedAt: number): RemoteSession => ({ + sessionId: id, + title: `Session ${id}`, + updatedAt, + backend: 'harness', + running: false, + blank: false, + }) + + const rootWs: WorkspaceItemLike = { + workspaceId: 'root', + title: 'Root Project', + path: '/home/project', + sessionIds: ['r1', 'r2'], + } + const childWs: WorkspaceItemLike = { + workspaceId: 'child', + title: 'Child Module', + path: '/home/project/module', + sessionIds: ['c1'], + } + const grandchildWs: WorkspaceItemLike = { + workspaceId: 'grandchild', + title: 'Grandchild App', + path: '/home/project/module/app', + sessionIds: ['gc1'], + } + + const sessions = [ + makeSession('gc1', 400), + makeSession('c1', 300), + makeSession('r2', 200), + makeSession('r1', 100), + ] + + it('displays sub-workspaces before parent workspace own sessions', () => { + const sections = buildTreeSections({ + backend: 'harness', + wsList: [rootWs, childWs], + filteredSessions: sessions, + backendWorkspaces: [rootWs, childWs], + expandedWorkspaces: {}, + visibleCounts: {}, + manualOrders: {}, + orderBy: 'updated', + searchQuery: '', + partitionPinned: items => [...items], + }) + + // Section 0: Root header (data empty, child comes first, no show-more footer) + expect(sections[0]).toMatchObject({ + id: 'workspace:harness:root', + title: 'Root Project', + depth: 0, + expanded: true, + data: [], + hasMoreFooter: false, + }) + // Section 1: Child module header + sessions (child comes before parent's own sessions) + expect(sections[1]).toMatchObject({ + id: 'workspace:harness:child', + title: 'Child Module', + depth: 1, + expanded: true, + hasMoreFooter: true, + }) + expect(sections[1]!.data.map(s => s.sessionId)).toEqual(['c1']) + + // Section 2: Parent root workspace own sessions bucket + expect(sections[2]).toMatchObject({ + id: 'workspace-sessions:harness:root', + title: '', + depth: 0, + hasMoreFooter: true, + }) + expect(sections[2]!.data.map(s => s.sessionId)).toEqual(['r2', 'r1']) + }) + + it('handles 3-level hierarchy (root -> child -> grandchild) with correct depths', () => { + const sections = buildTreeSections({ + backend: 'harness', + wsList: [rootWs, childWs, grandchildWs], + filteredSessions: sessions, + backendWorkspaces: [rootWs, childWs, grandchildWs], + expandedWorkspaces: {}, + visibleCounts: {}, + manualOrders: {}, + orderBy: 'updated', + searchQuery: '', + partitionPinned: items => [...items], + }) + + expect(sections.map(s => ({ id: s.id, depth: s.depth }))).toEqual([ + { id: 'workspace:harness:root', depth: 0 }, + { id: 'workspace:harness:child', depth: 1 }, + { id: 'workspace:harness:grandchild', depth: 2 }, + { id: 'workspace-sessions:harness:child', depth: 1 }, + { id: 'workspace-sessions:harness:root', depth: 0 }, + ]) + }) + + it('collapses all descendants when parent workspace is folded', () => { + const sections = buildTreeSections({ + backend: 'harness', + wsList: [rootWs, childWs, grandchildWs], + filteredSessions: sessions, + backendWorkspaces: [rootWs, childWs, grandchildWs], + expandedWorkspaces: { 'workspace:harness:root': false }, + visibleCounts: {}, + manualOrders: {}, + orderBy: 'updated', + searchQuery: '', + partitionPinned: items => [...items], + }) + + expect(sections).toHaveLength(1) + expect(sections[0]).toMatchObject({ + id: 'workspace:harness:root', + expanded: false, + data: [], + }) + }) + + it('collapses child workspace while keeping parent workspace own sessions visible', () => { + const sections = buildTreeSections({ + backend: 'harness', + wsList: [rootWs, childWs], + filteredSessions: sessions, + backendWorkspaces: [rootWs, childWs], + expandedWorkspaces: { 'workspace:harness:child': false }, + visibleCounts: {}, + manualOrders: {}, + orderBy: 'updated', + searchQuery: '', + partitionPinned: items => [...items], + }) + + expect(sections).toHaveLength(3) + expect(sections[0]).toMatchObject({ id: 'workspace:harness:root', expanded: true }) + expect(sections[1]).toMatchObject({ id: 'workspace:harness:child', expanded: false, data: [] }) + expect(sections[2]).toMatchObject({ + id: 'workspace-sessions:harness:root', + data: [expect.objectContaining({ sessionId: 'r2' }), expect.objectContaining({ sessionId: 'r1' })], + }) + }) + + it('force expands all ancestors when a search query matches a nested workspace session', () => { + // Both root and child are explicitly set to collapsed (false) + const sections = buildTreeSections({ + backend: 'harness', + wsList: [rootWs, childWs], + filteredSessions: [makeSession('c1', 300)], // only c1 matches + backendWorkspaces: [rootWs, childWs], + expandedWorkspaces: { + 'workspace:harness:root': false, + 'workspace:harness:child': false, + }, + visibleCounts: {}, + manualOrders: {}, + orderBy: 'updated', + searchQuery: 'Session c1', + partitionPinned: items => [...items], + }) + + // Both root and child must be force-expanded because c1 matched + expect(sections[0]).toMatchObject({ id: 'workspace:harness:root', expanded: true }) + expect(sections[1]).toMatchObject({ id: 'workspace:harness:child', expanded: true }) + expect(sections[1]!.data.map(s => s.sessionId)).toEqual(['c1']) + }) + + it('applies manual reordering within the workspace section when orderBy is manual', () => { + const sections = buildTreeSections({ + backend: 'harness', + wsList: [rootWs], + filteredSessions: [makeSession('r2', 200), makeSession('r1', 100)], + backendWorkspaces: [rootWs], + expandedWorkspaces: {}, + visibleCounts: {}, + manualOrders: { 'workspace:harness:root': ['r1', 'r2'] }, // r1 placed before r2 + orderBy: 'manual', + searchQuery: '', + partitionPinned: items => [...items], + }) + + expect(sections[0]!.data.map(s => s.sessionId)).toEqual(['r1', 'r2']) + }) + + it('integrates with real partitionPinned so pinned sessions lead in tree sections', () => { + const pinnedSessionIds = ['r1'] + const partitionPinned = (items: RemoteSession[]) => { + const pinned = items.filter(s => pinnedSessionIds.includes(s.sessionId)) + const ordinary = items.filter(s => !pinnedSessionIds.includes(s.sessionId)) + return [...pinned, ...ordinary] + } + + const sections = buildTreeSections({ + backend: 'harness', + wsList: [rootWs], + filteredSessions: [makeSession('r2', 200), makeSession('r1', 100)], + backendWorkspaces: [rootWs], + expandedWorkspaces: {}, + visibleCounts: {}, + manualOrders: {}, + orderBy: 'updated', + searchQuery: '', + partitionPinned, + }) + + // r1 is pinned, so even though r2 has higher updatedAt (200 vs 100), r1 leads + expect(sections[0]!.data.map(s => s.sessionId)).toEqual(['r1', 'r2']) + }) + }) +})