mirror of
https://github.com/eigent-ai/eigent.git
synced 2026-08-27 17:41:56 +00:00
384 lines
11 KiB
TypeScript
384 lines
11 KiB
TypeScript
// ========= Copyright 2025-2026 @ Eigent.ai All Rights Reserved. =========
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ========= Copyright 2025-2026 @ Eigent.ai All Rights Reserved. =========
|
|
|
|
import { SessionActivityPanel } from '@/components/Session/SidePanel/components/ActivityPanel';
|
|
import {
|
|
act,
|
|
fireEvent,
|
|
render,
|
|
screen,
|
|
waitFor,
|
|
} from '@testing-library/react';
|
|
import type { ReactNode } from 'react';
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
const mocks = vi.hoisted(() => ({
|
|
activeProjectId: 'project-1' as string,
|
|
chatStore: {} as any,
|
|
hydration: {} as any,
|
|
projectId: 'project-1' as string | null,
|
|
projectFiles: [] as any[],
|
|
projectOutputResolver: vi.fn(),
|
|
spaceState: {
|
|
projectIdIndex: {
|
|
'project-1': 'space-1',
|
|
'project-2': 'space-2',
|
|
} as Record<string, string>,
|
|
spaces: {
|
|
'space-1': { rootPath: '/workspace/space-one' },
|
|
'space-2': { rootPath: '/workspace/space-two' },
|
|
} as Record<string, { rootPath: string }>,
|
|
},
|
|
overviews: {} as Record<string, any>,
|
|
selectFile: vi.fn(),
|
|
setScrollToTurnRequest: vi.fn(),
|
|
requestTaskBoxFocus: vi.fn(),
|
|
openFilePreview: vi.fn(),
|
|
openBrowserPreview: vi.fn(),
|
|
}));
|
|
|
|
vi.mock('@/api/connectors', () => ({
|
|
fetchConnectedProviders: vi.fn().mockResolvedValue([]),
|
|
}));
|
|
|
|
vi.mock('@/client/platform', () => ({ isWeb: () => false }));
|
|
|
|
vi.mock('@/hooks/useChatStoreAdapter', () => ({
|
|
default: () => ({ chatStore: mocks.chatStore }),
|
|
}));
|
|
|
|
vi.mock('@/hooks/useProjectEventRuntime', () => ({
|
|
useProjectEventRuntime: () => ({
|
|
projectId: mocks.projectId,
|
|
snapshot: null,
|
|
hydration: mocks.hydration,
|
|
}),
|
|
}));
|
|
|
|
vi.mock('@/hooks/useProjectSessionOverview', () => ({
|
|
useProjectSessionOverview: (projectId: string | null) =>
|
|
(projectId && mocks.overviews[projectId]) || {
|
|
currentRun: null,
|
|
historicalRuns: [],
|
|
runs: [],
|
|
},
|
|
}));
|
|
|
|
vi.mock('@/host', () => ({
|
|
useHost: () => ({ electronAPI: { selectFile: mocks.selectFile } }),
|
|
}));
|
|
|
|
vi.mock('@/store/projectRuntimeStore', () => ({
|
|
useProjectRuntimeStore: () => ({
|
|
activeProjectId: mocks.activeProjectId,
|
|
}),
|
|
}));
|
|
|
|
vi.mock('@/store/skillsStore', () => ({
|
|
useSkillsStore: (selector: (state: { skills: never[] }) => unknown) =>
|
|
selector({ skills: [] }),
|
|
}));
|
|
|
|
vi.mock('@/store/spaceStore', () => ({
|
|
useSpaceStore: (selector: (state: typeof mocks.spaceState) => unknown) =>
|
|
selector(mocks.spaceState),
|
|
}));
|
|
|
|
vi.mock('@/store/pageTabStore', () => ({
|
|
usePageTabStore: (selector: (state: Record<string, unknown>) => unknown) =>
|
|
selector({
|
|
requestTaskBoxFocus: mocks.requestTaskBoxFocus,
|
|
setScrollToTurnRequest: mocks.setScrollToTurnRequest,
|
|
openFilePreview: mocks.openFilePreview,
|
|
openBrowserPreview: mocks.openBrowserPreview,
|
|
}),
|
|
}));
|
|
|
|
vi.mock(
|
|
'@/components/Session/SidePanel/sections/useProjectOutputFiles',
|
|
() => ({
|
|
useProjectOutputFiles: (...args: unknown[]) => {
|
|
mocks.projectOutputResolver(...args);
|
|
return mocks.projectFiles;
|
|
},
|
|
})
|
|
);
|
|
|
|
vi.mock('@/components/ui/tooltip', () => ({
|
|
TooltipSimple: ({ children }: { children: ReactNode }) => children,
|
|
}));
|
|
|
|
vi.mock('@/components/Session/SidePanel/components/AccordionBox', () => ({
|
|
SidePanelAccordionBox: ({
|
|
title,
|
|
headerAction,
|
|
children,
|
|
}: {
|
|
title: string;
|
|
headerAction?: ReactNode;
|
|
children: ReactNode | ((state: { open: boolean }) => ReactNode);
|
|
}) => (
|
|
<section>
|
|
<h2>{title}</h2>
|
|
{headerAction}
|
|
{typeof children === 'function' ? children({ open: true }) : children}
|
|
</section>
|
|
),
|
|
}));
|
|
|
|
vi.mock('@/components/Session/SidePanel/sections/primitives', () => ({
|
|
CountPill: ({ count }: { count: number }) => <span>{count}</span>,
|
|
EarlierItems: ({ children }: { children: ReactNode }) => children,
|
|
ProgressCircle: () => null,
|
|
SidePanelListRow: ({
|
|
children,
|
|
onClick,
|
|
trailing,
|
|
}: {
|
|
children: ReactNode;
|
|
onClick?: () => void;
|
|
trailing?: ReactNode;
|
|
}) =>
|
|
onClick ? (
|
|
<button onClick={onClick}>
|
|
{children}
|
|
{trailing}
|
|
</button>
|
|
) : (
|
|
<div>
|
|
{children}
|
|
{trailing}
|
|
</div>
|
|
),
|
|
}));
|
|
|
|
vi.mock(
|
|
'@/components/Session/SidePanel/sections/SessionSidePanelDialogs',
|
|
() => ({
|
|
AgentInformationDialog: ({ agent }: { agent: any }) =>
|
|
agent ? <div data-testid="agent-dialog">{agent.name}</div> : null,
|
|
ToolCallsDialog: ({ item }: { item: any }) =>
|
|
item ? <div data-testid="tool-dialog">{item.label}</div> : null,
|
|
})
|
|
);
|
|
|
|
function chatStore(taskId: string | null) {
|
|
return {
|
|
activeTaskId: taskId,
|
|
tasks: taskId ? { [taskId]: { attaches: [] } } : {},
|
|
setAttaches: vi.fn(),
|
|
};
|
|
}
|
|
|
|
function overview(runId: string, withAgent = false) {
|
|
const run = {
|
|
runId,
|
|
taskId: runId,
|
|
status: 'running',
|
|
createdAt: 1_000,
|
|
updatedAt: 1_000,
|
|
isCurrent: true,
|
|
nodes: withAgent
|
|
? [
|
|
{
|
|
id: 'agent-1',
|
|
eventId: 'agent-1',
|
|
eventType: 'agent.started',
|
|
projectId: 'project-1',
|
|
runId,
|
|
runSequence: 1,
|
|
cloudCursor: 1,
|
|
createdAt: new Date(1_000).toISOString(),
|
|
legacyStep: null,
|
|
kind: 'activity',
|
|
activityType: 'agent',
|
|
status: 'running',
|
|
title: 'Agent One',
|
|
agentId: 'agent-1',
|
|
agentName: 'Agent One',
|
|
},
|
|
]
|
|
: [],
|
|
};
|
|
return { currentRun: run, historicalRuns: [], runs: [run] };
|
|
}
|
|
|
|
describe('SessionActivityPanel project scope', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
mocks.projectId = 'project-1';
|
|
mocks.activeProjectId = 'project-1';
|
|
mocks.chatStore = chatStore(null);
|
|
mocks.projectFiles = [];
|
|
mocks.hydration = {
|
|
status: 'ready',
|
|
errorCode: null,
|
|
eventsTruncated: false,
|
|
retry: vi.fn(),
|
|
};
|
|
mocks.overviews = {
|
|
'project-1': { currentRun: null, historicalRuns: [], runs: [] },
|
|
'project-2': { currentRun: null, historicalRuns: [], runs: [] },
|
|
};
|
|
});
|
|
|
|
it('keeps an empty Files section visible and fails closed without a composer target', async () => {
|
|
render(<SessionActivityPanel scope="latest" />);
|
|
await act(async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 40));
|
|
});
|
|
|
|
expect(screen.getByRole('heading', { name: 'Files' })).toBeInTheDocument();
|
|
expect(screen.getByText('No output files yet.')).toBeInTheDocument();
|
|
expect(screen.getByRole('button', { name: /Attach files/ })).toBeDisabled();
|
|
});
|
|
|
|
it('resolves SidePanel files against the Space that owns the Project', async () => {
|
|
render(<SessionActivityPanel scope="latest" />);
|
|
await act(async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 40));
|
|
});
|
|
|
|
expect(mocks.projectOutputResolver).toHaveBeenCalledWith(
|
|
'project-1',
|
|
undefined,
|
|
null,
|
|
'/workspace/space-one',
|
|
[]
|
|
);
|
|
});
|
|
|
|
it('shows unsupported history as degraded and exposes manual retry', async () => {
|
|
mocks.hydration = {
|
|
status: 'error',
|
|
errorCode: 'unsupported',
|
|
eventsTruncated: false,
|
|
retry: vi.fn(),
|
|
};
|
|
|
|
render(<SessionActivityPanel scope="latest" />);
|
|
await act(async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 40));
|
|
});
|
|
|
|
expect(screen.getByRole('alert')).toHaveTextContent(
|
|
'This backend does not support session history yet.'
|
|
);
|
|
fireEvent.click(screen.getByRole('button', { name: 'Try again' }));
|
|
expect(mocks.hydration.retry).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('keeps an artifact noninteractive until the workspace resolver matches it', async () => {
|
|
mocks.chatStore = chatStore('run-1');
|
|
const scopedOverview = overview('run-1');
|
|
scopedOverview.currentRun.nodes = [
|
|
{
|
|
id: 'artifact-1',
|
|
eventId: 'artifact-1',
|
|
eventType: 'artifact.created',
|
|
projectId: 'project-1',
|
|
runId: 'run-1',
|
|
runSequence: 1,
|
|
cloudCursor: 1,
|
|
createdAt: new Date(1_000).toISOString(),
|
|
legacyStep: null,
|
|
kind: 'artifact',
|
|
operation: 'created',
|
|
path: 'outputs/report.md',
|
|
relativePath: 'outputs/report.md',
|
|
name: 'report.md',
|
|
},
|
|
];
|
|
mocks.overviews['project-1'] = scopedOverview;
|
|
|
|
const { rerender } = render(<SessionActivityPanel scope="latest" />);
|
|
await act(async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 40));
|
|
});
|
|
|
|
expect(screen.getByText('Preview unavailable')).toBeInTheDocument();
|
|
expect(
|
|
screen.queryByRole('button', { name: /report\.md/ })
|
|
).not.toBeInTheDocument();
|
|
|
|
mocks.projectFiles = [
|
|
{
|
|
name: 'report.md',
|
|
type: 'md',
|
|
path: '/workspace/outputs/report.md',
|
|
relativePath: 'outputs/report.md',
|
|
},
|
|
];
|
|
rerender(<SessionActivityPanel scope="latest" />);
|
|
|
|
fireEvent.click(await screen.findByRole('button', { name: /report\.md/ }));
|
|
expect(mocks.openFilePreview).toHaveBeenCalledWith(
|
|
expect.objectContaining({ path: '/workspace/outputs/report.md' })
|
|
);
|
|
});
|
|
|
|
it('does not attach a delayed picker result after switching Projects', async () => {
|
|
let resolvePicker!: (value: unknown) => void;
|
|
mocks.chatStore = chatStore('run-1');
|
|
const oldStore = mocks.chatStore;
|
|
mocks.overviews['project-1'] = overview('run-1');
|
|
mocks.selectFile.mockReturnValue(
|
|
new Promise((resolve) => {
|
|
resolvePicker = resolve;
|
|
})
|
|
);
|
|
|
|
const { rerender } = render(<SessionActivityPanel scope="latest" />);
|
|
await act(async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 40));
|
|
});
|
|
fireEvent.click(screen.getByRole('button', { name: /Attach files/ }));
|
|
expect(mocks.selectFile).toHaveBeenCalledTimes(1);
|
|
|
|
mocks.projectId = 'project-2';
|
|
mocks.activeProjectId = 'project-2';
|
|
mocks.chatStore = chatStore('run-2');
|
|
const newStore = mocks.chatStore;
|
|
mocks.overviews['project-2'] = overview('run-2');
|
|
rerender(<SessionActivityPanel scope="latest" />);
|
|
|
|
await act(async () => {
|
|
resolvePicker({
|
|
success: true,
|
|
files: [{ fileName: 'late.txt', filePath: '/late.txt' }],
|
|
});
|
|
await Promise.resolve();
|
|
});
|
|
expect(oldStore.setAttaches).not.toHaveBeenCalled();
|
|
expect(newStore.setAttaches).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('closes an Agent dialog when the Project incarnation changes', async () => {
|
|
mocks.chatStore = chatStore('run-1');
|
|
mocks.overviews['project-1'] = overview('run-1', true);
|
|
const { rerender } = render(<SessionActivityPanel scope="latest" />);
|
|
|
|
fireEvent.click(await screen.findByRole('button', { name: 'Agent One' }));
|
|
expect(screen.getByTestId('agent-dialog')).toHaveTextContent('Agent One');
|
|
|
|
mocks.projectId = 'project-2';
|
|
mocks.activeProjectId = 'project-2';
|
|
mocks.chatStore = chatStore(null);
|
|
rerender(<SessionActivityPanel scope="latest" />);
|
|
|
|
await waitFor(() =>
|
|
expect(screen.queryByTestId('agent-dialog')).not.toBeInTheDocument()
|
|
);
|
|
});
|
|
});
|