800 lines
37 KiB
TypeScript
800 lines
37 KiB
TypeScript
import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
|
||
import { MemoryRouter, Route, Routes, useLocation } from 'react-router-dom';
|
||
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
|
||
import { ChannelAccounts } from '@/pages/CloudAgents/ChannelAccounts';
|
||
import {
|
||
EMPTY_CLOUD_CONFIGURATION,
|
||
type CloudAgentDraft,
|
||
type CloudPendingOperation,
|
||
type CloudUserChannelAccount,
|
||
type CloudWechatBindState,
|
||
} from '../../shared/cloud-agents';
|
||
|
||
const api = vi.hoisted(() => ({
|
||
call: vi.fn(),
|
||
list: vi.fn(),
|
||
recovery: vi.fn(),
|
||
resolvePending: vi.fn(),
|
||
}));
|
||
vi.mock('@/lib/cloud-agents-api', () => ({ cloudAgentsApi: api }));
|
||
vi.mock('@/pages/CloudAgents/CloudWechatQr', () => ({
|
||
CloudWechatQr: () => <img alt="个人微信登录二维码" src="data:image/png;base64,test" />,
|
||
}));
|
||
const agentA: CloudAgentDraft = {
|
||
slug: 'ml-' + 'a'.repeat(32),
|
||
name: '写作助手',
|
||
purpose: '',
|
||
system_prompt: '',
|
||
published_version: 2,
|
||
draft_revision: 3,
|
||
updated_at: '',
|
||
configuration: EMPTY_CLOUD_CONFIGURATION,
|
||
enabled: true,
|
||
};
|
||
const agentB: CloudAgentDraft = {
|
||
...agentA,
|
||
slug: 'ml-' + 'b'.repeat(32),
|
||
name: '资料助手',
|
||
published_version: 4,
|
||
};
|
||
const legacy: CloudUserChannelAccount = {
|
||
id: 'wechat-legacy',
|
||
display_name: '原有微信',
|
||
binding_id: 'binding-legacy',
|
||
revision: 7,
|
||
enabled: true,
|
||
status: 'active',
|
||
health: 'connected',
|
||
blockers: [],
|
||
target_agent_slug: agentA.slug,
|
||
target_agent_name: agentA.name,
|
||
target_agent_published_version: 2,
|
||
sync_state: 'ready',
|
||
};
|
||
const spare: CloudUserChannelAccount = {
|
||
...legacy,
|
||
id: 'wechat-spare',
|
||
display_name: '备用微信',
|
||
revision: 2,
|
||
enabled: false,
|
||
status: 'paused',
|
||
health: 'login_required',
|
||
blockers: ['target_required'],
|
||
target_agent_slug: null,
|
||
target_agent_name: null,
|
||
target_agent_published_version: null,
|
||
};
|
||
let accounts: CloudUserChannelAccount[];
|
||
let agents: CloudAgentDraft[];
|
||
let pending: CloudPendingOperation[];
|
||
let qrStatus: CloudWechatBindState['status'];
|
||
let verifyStatus: CloudWechatBindState['status'];
|
||
const calls = (operation: string) => api.call.mock.calls.filter(([name]) => name === operation);
|
||
const writes = () =>
|
||
api.call.mock.calls.filter(
|
||
([name]) => !['channelAccounts', 'channelAccountWechatBindStatus'].includes(name)
|
||
);
|
||
function LocationProbe() {
|
||
const location = useLocation();
|
||
return <output data-testid="location-path">{location.pathname + location.search}</output>;
|
||
}
|
||
function renderPage(entry = '/cloud-agents/channels') {
|
||
return render(
|
||
<MemoryRouter initialEntries={[entry]}>
|
||
<Routes>
|
||
<Route path="/cloud-agents/channels" element={<ChannelAccounts />} />
|
||
<Route path="/cloud-agents" element={<div>智能体列表</div>} />
|
||
</Routes>
|
||
<LocationProbe />
|
||
</MemoryRouter>
|
||
);
|
||
}
|
||
async function card(name = legacy.display_name) {
|
||
return screen.findByRole('article', { name: name + '微信', exact: true });
|
||
}
|
||
async function chooseExisting(name = legacy.display_name) {
|
||
const current = await card(name);
|
||
fireEvent.click(within(current).getByRole('button', { name: /更换智能体|绑定智能体/ }));
|
||
return screen.getByRole('dialog', { name: '更换智能体', exact: true });
|
||
}
|
||
async function more(name = legacy.display_name) {
|
||
const current = await card(name);
|
||
fireEvent.click(within(current).getByRole('button', { name: '更多操作', exact: true }));
|
||
return current;
|
||
}
|
||
async function adding() {
|
||
fireEvent.click(await screen.findByRole('button', { name: '添加微信', exact: true }));
|
||
const dialog = screen.getByRole('dialog', { name: '添加微信', exact: true });
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentA.name }));
|
||
await act(async () =>
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '下一步：扫码连接', exact: true }))
|
||
);
|
||
return dialog;
|
||
}
|
||
function installMock() {
|
||
api.call.mockImplementation(async (operation: string, input: Record<string, unknown>) => {
|
||
if (operation === 'channelAccounts') return { items: accounts.map((item) => ({ ...item })) };
|
||
if (operation === 'createChannelAccount') {
|
||
const channel = {
|
||
...spare,
|
||
id: 'wechat-created',
|
||
display_name: String(input.display_name),
|
||
revision: 1,
|
||
};
|
||
accounts.push(channel);
|
||
return { channel: { ...channel } };
|
||
}
|
||
const account = accounts.find((item) => item.id === input.channel_account_id);
|
||
if (!account) throw new Error('Unknown fixture account');
|
||
if (operation === 'routeChannelAccount') {
|
||
const target = agents.find((item) => item.slug === input.target_agent_slug);
|
||
Object.assign(account, {
|
||
revision: account.revision + 1,
|
||
target_agent_slug: target?.slug ?? null,
|
||
target_agent_name: target?.name ?? null,
|
||
enabled: input.enabled,
|
||
blockers: input.enabled ? [] : ['binding_paused'],
|
||
});
|
||
return { channel: { ...account } };
|
||
}
|
||
if (operation === 'enableChannelAccount' || operation === 'pauseChannelAccount') {
|
||
const enabled = operation === 'enableChannelAccount';
|
||
Object.assign(account, {
|
||
revision: account.revision + 1,
|
||
enabled,
|
||
blockers: enabled ? [] : ['binding_paused'],
|
||
});
|
||
return { channel: { ...account } };
|
||
}
|
||
if (operation === 'unbindChannelAccount') {
|
||
Object.assign(account, {
|
||
revision: account.revision + 1,
|
||
health: 'login_required',
|
||
enabled: false,
|
||
target_agent_slug: null,
|
||
target_agent_name: null,
|
||
blockers: ['target_required'],
|
||
});
|
||
return { channel: { ...account }, unbound: true, disconnected: true };
|
||
}
|
||
if (
|
||
[
|
||
'channelAccountWechatBindStart',
|
||
'channelAccountWechatBindStatus',
|
||
'channelAccountWechatBindVerification',
|
||
].includes(operation)
|
||
) {
|
||
const status = operation === 'channelAccountWechatBindVerification' ? verifyStatus : qrStatus;
|
||
if (status === 'confirmed') account.health = 'connected';
|
||
return { session_key: 'qr-' + account.id, status, qrcode_url: 'https://login.example.test/qr' };
|
||
}
|
||
throw new Error('Unexpected fixture operation ' + operation);
|
||
});
|
||
}
|
||
beforeEach(() => {
|
||
vi.resetAllMocks();
|
||
accounts = [{ ...legacy }, { ...spare }];
|
||
agents = [agentA, agentB];
|
||
pending = [];
|
||
qrStatus = 'verification_required';
|
||
verifyStatus = 'pending';
|
||
api.list.mockImplementation(async () => ({ agents, next_cursor: null }));
|
||
api.recovery.mockImplementation(async () => ({ recent: null, pending }));
|
||
installMock();
|
||
});
|
||
afterEach(() => {
|
||
cleanup();
|
||
vi.useRealTimers();
|
||
});
|
||
|
||
it.each([
|
||
['none', []],
|
||
['drafts', [{ ...agentA, published_version: null }]],
|
||
['disabled', [{ ...agentA, enabled: false }]],
|
||
] satisfies [string, CloudAgentDraft[]][])(
|
||
'retains no-Agent guidance and makes no binding requests for %s Agents',
|
||
async (_name, unavailable) => {
|
||
agents = unavailable;
|
||
accounts = [];
|
||
renderPage();
|
||
expect(await screen.findByRole('heading', { name: '还没有可连接的智能体' })).toBeVisible();
|
||
expect(writes()).toEqual([]);
|
||
fireEvent.click(screen.getByRole('button', { name: '去我的智能体' }));
|
||
expect(await screen.findByText('智能体列表')).toBeVisible();
|
||
expect(screen.getByTestId('location-path')).toHaveTextContent('/cloud-agents?view=mine');
|
||
}
|
||
);
|
||
it('keeps one main action on each card and places pause/unbind in More', async () => {
|
||
renderPage();
|
||
const current = await card();
|
||
expect(within(current).getByText('使用中')).toBeVisible();
|
||
expect(within(current).getByText(agentA.name)).toBeVisible();
|
||
expect(within(current).getByRole('button', { name: '更换智能体' })).toBeVisible();
|
||
expect(within(current).queryByRole('button', { name: '解除微信绑定' })).not.toBeInTheDocument();
|
||
const menu = await more();
|
||
expect(within(menu).getByRole('button', { name: '暂停自动回复' })).toBeVisible();
|
||
expect(within(menu).getByRole('button', { name: '解除微信绑定' })).toBeVisible();
|
||
expect(screen.queryByText('断开微信连接')).not.toBeInTheDocument();
|
||
expect(screen.queryByText('活动记录')).not.toBeInTheDocument();
|
||
expect(writes()).toEqual([]);
|
||
});
|
||
it('uses one Agent-choice window and confirms a switch without a second dialog', async () => {
|
||
renderPage();
|
||
const dialog = await chooseExisting();
|
||
expect(within(dialog).getByRole('button', { name: '确认更换' })).toBeDisabled();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
expect(calls('routeChannelAccount')).toHaveLength(0);
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
|
||
expect(calls('routeChannelAccount')).toHaveLength(1);
|
||
expect(calls('routeChannelAccount')[0][1]).toMatchObject({
|
||
channel_account_id: legacy.id,
|
||
target_agent_slug: agentB.slug,
|
||
enabled: true,
|
||
expected_revision: 7,
|
||
});
|
||
expect(await screen.findByText('已更换智能体，微信连接和历史保留。')).toBeVisible();
|
||
expect(calls('channelAccountWechatBindStart')).toHaveLength(0);
|
||
});
|
||
it('switches a paused binding without enabling it', async () => {
|
||
accounts[0] = { ...legacy, enabled: false, blockers: ['binding_paused'] };
|
||
renderPage();
|
||
expect(await screen.findByText('已暂停')).toBeVisible();
|
||
const dialog = await chooseExisting();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
|
||
expect(accounts[0].enabled).toBe(false);
|
||
expect(calls('routeChannelAccount')[0][1]).toMatchObject({ enabled: false });
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('shows a rejected switch inside the still-open choice dialog and preserves the old binding', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'routeChannelAccount') throw new Error('渠道状态已变化');
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
const dialog = await chooseExisting();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('渠道状态已变化');
|
||
expect(within(dialog).getByRole('radio', { name: agentB.name })).toBeChecked();
|
||
expect(accounts[0].target_agent_slug).toBe(agentA.slug);
|
||
expect(screen.getAllByRole('dialog')).toHaveLength(1);
|
||
});
|
||
it('never overwrites a final read with a stale switch receipt', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'routeChannelAccount') {
|
||
await base(op, input);
|
||
return { channel: { ...legacy } };
|
||
}
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
const dialog = await chooseExisting();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
|
||
expect(within(await card()).getByText(agentB.name)).toBeVisible();
|
||
expect(within(await card()).getByText('使用中')).toBeVisible();
|
||
});
|
||
it('pauses and resumes with authoritative state, ignoring a stale receipt', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'pauseChannelAccount') {
|
||
await base(op, input);
|
||
return { channel: { ...legacy } };
|
||
}
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
fireEvent.click(within(await more()).getByRole('button', { name: '暂停自动回复' }));
|
||
expect(await screen.findByText('已暂停')).toBeVisible();
|
||
const menu = await more();
|
||
expect(within(menu).getByRole('button', { name: '恢复自动回复' })).toBeEnabled();
|
||
fireEvent.click(within(menu).getByRole('button', { name: '恢复自动回复' }));
|
||
expect(await screen.findByText('使用中')).toBeVisible();
|
||
expect(calls('enableChannelAccount')[0][1]).toMatchObject({ expected_revision: 8 });
|
||
expect(calls('routeChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('uses unified WeChat unbind after one explicit confirmation and preserves the account card', async () => {
|
||
renderPage();
|
||
fireEvent.click(within(await more()).getByRole('button', { name: '解除微信绑定' }));
|
||
const dialog = screen.getByRole('dialog', { name: '解除微信绑定' });
|
||
expect(within(dialog).getByText(/历史仍保留/)).toBeVisible();
|
||
expect(calls('unbindChannelAccount')).toHaveLength(0);
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认解除微信绑定' }));
|
||
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
|
||
expect(within(await card()).getByText('未绑定')).toBeVisible();
|
||
expect(within(await card()).getByRole('button', { name: '绑定智能体' })).toBeVisible();
|
||
expect(calls('unbindChannelAccount')[0][1]).toMatchObject({
|
||
channel_account_id: legacy.id,
|
||
expected_revision: 7,
|
||
});
|
||
expect(calls('disconnectChannelAccount')).toHaveLength(0);
|
||
expect(calls('routeChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('shows unbind errors in the current dialog and never reports success from an incomplete receipt', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) =>
|
||
op === 'unbindChannelAccount'
|
||
? { channel: { ...legacy }, unbound: false, disconnected: false }
|
||
: base(op, input)
|
||
);
|
||
renderPage();
|
||
fireEvent.click(within(await more()).getByRole('button', { name: '解除微信绑定' }));
|
||
const dialog = screen.getByRole('dialog', { name: '解除微信绑定' });
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认解除微信绑定' }));
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('解除结果还没有确认');
|
||
expect(within(dialog).getByRole('button', { name: '确认解除微信绑定' })).toBeDisabled();
|
||
expect(screen.queryByText('微信绑定已解除，历史仍保留。')).not.toBeInTheDocument();
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '取消' }));
|
||
expect(within(await card()).getByText('正在确认')).toBeVisible();
|
||
expect(within(await card()).getByRole('button', { name: '更换智能体' })).toBeDisabled();
|
||
});
|
||
it('does not enable a pending or verification-required QR', async () => {
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('img', { name: '个人微信登录二维码' })).toBeVisible();
|
||
expect(calls('createChannelAccount')).toHaveLength(1);
|
||
expect(calls('routeChannelAccount')[0][1]).toMatchObject({
|
||
target_agent_slug: agentA.slug,
|
||
enabled: false,
|
||
});
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
expect(within(dialog).queryByRole('button', { name: '完成绑定并启用' })).not.toBeInTheDocument();
|
||
fireEvent.change(within(dialog).getByLabelText('微信验证码'), { target: { value: '123456' } });
|
||
await act(async () => fireEvent.click(within(dialog).getByRole('button', { name: '提交验证码' })));
|
||
expect(await within(dialog).findByText('等待微信确认')).toBeVisible();
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('automatically enables once after genuine QR confirmation and final readback', async () => {
|
||
qrStatus = 'confirmed';
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('heading', { name: '微信绑定成功' })).toBeVisible();
|
||
expect(calls('enableChannelAccount')).toHaveLength(1);
|
||
expect(calls('enableChannelAccount')[0][1]).toMatchObject({ expected_revision: 2 });
|
||
expect(within(dialog).queryByRole('button', { name: '完成绑定并启用' })).not.toBeInTheDocument();
|
||
expect(calls('channelAccounts').length).toBeGreaterThanOrEqual(5);
|
||
});
|
||
it('a confirmed status without authoritative login cannot enable or claim success', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) =>
|
||
op === 'channelAccountWechatBindStart' ? { session_key: 'qr', status: 'confirmed' } : base(op, input)
|
||
);
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('微信还没有准备好');
|
||
expect(within(dialog).queryByRole('heading', { name: '微信绑定成功' })).not.toBeInTheDocument();
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
expect(within(dialog).getByRole('button', { name: '重试完成绑定' })).toBeEnabled();
|
||
});
|
||
it('a failed automatic enable offers explicit retry without an automatic loop', async () => {
|
||
qrStatus = 'confirmed';
|
||
const base = api.call.getMockImplementation()!;
|
||
let attempts = 0;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'enableChannelAccount' && ++attempts === 1) throw new Error('启用暂时失败');
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('启用暂时失败');
|
||
expect(calls('enableChannelAccount')).toHaveLength(1);
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '重试完成绑定' }));
|
||
expect(await within(dialog).findByRole('heading', { name: '微信绑定成功' })).toBeVisible();
|
||
expect(calls('enableChannelAccount')).toHaveLength(2);
|
||
expect(calls('enableChannelAccount')[0][1]).toEqual(calls('enableChannelAccount')[1][1]);
|
||
});
|
||
it('stale enable receipts cannot conceal a still-disabled authoritative account', async () => {
|
||
qrStatus = 'confirmed';
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) =>
|
||
op === 'enableChannelAccount'
|
||
? { channel: { ...accounts.find((item) => item.id === input.channel_account_id), enabled: true } }
|
||
: base(op, input)
|
||
);
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('操作结果还没有确认');
|
||
expect(within(dialog).queryByRole('heading', { name: '微信绑定成功' })).not.toBeInTheDocument();
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '稍后继续' }));
|
||
const current = await card('微信 3');
|
||
expect(within(current).getByText('正在确认')).toBeVisible();
|
||
expect(within(current).queryByText('使用中')).not.toBeInTheDocument();
|
||
});
|
||
it('does not enable a different Agent or an offline account after QR confirmation', async () => {
|
||
qrStatus = 'confirmed';
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
const result = await base(op, input);
|
||
if (op === 'channelAccountWechatBindStart')
|
||
accounts.find((item) => item.id === input.channel_account_id)!.target_agent_slug = agentB.slug;
|
||
return result;
|
||
});
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('绑定的智能体已发生变化');
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('never auto-enables or replays old paused records on page entry or refresh', async () => {
|
||
accounts[0] = { ...legacy, enabled: false, blockers: ['binding_paused'] };
|
||
renderPage();
|
||
await screen.findByText('已暂停');
|
||
fireEvent.click(screen.getByRole('button', { name: '刷新微信列表' }));
|
||
await waitFor(() => expect(calls('channelAccounts')).toHaveLength(2));
|
||
expect(writes()).toEqual([]);
|
||
});
|
||
it('reconnects an old paused binding while keeping automatic replies paused', async () => {
|
||
accounts[0] = { ...legacy, health: 'login_required', enabled: false, blockers: ['binding_paused'] };
|
||
qrStatus = 'confirmed';
|
||
renderPage();
|
||
const current = await card();
|
||
fireEvent.click(within(current).getByRole('button', { name: '重新扫码' }));
|
||
const dialog = screen.getByRole('dialog', { name: '重新连接微信' });
|
||
expect(await within(dialog).findByRole('heading', { name: '微信重新连接成功' })).toBeVisible();
|
||
expect(within(dialog).getByText('微信已连接，自动回复仍保持暂停。')).toBeVisible();
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
expect(calls('routeChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('stops polling after a QR confirmation and deduplicates activation', async () => {
|
||
renderPage();
|
||
await screen.findByRole('button', { name: '添加微信' });
|
||
vi.useFakeTimers({ shouldAdvanceTime: true });
|
||
const dialog = await adding();
|
||
await within(dialog).findByRole('img', { name: '个人微信登录二维码' });
|
||
qrStatus = 'confirmed';
|
||
await act(async () => {
|
||
await vi.advanceTimersByTimeAsync(2000);
|
||
});
|
||
expect(within(dialog).getByRole('heading', { name: '微信绑定成功' })).toBeVisible();
|
||
await act(async () => {
|
||
await vi.advanceTimersByTimeAsync(6000);
|
||
});
|
||
expect(calls('enableChannelAccount')).toHaveLength(1);
|
||
expect(calls('channelAccountWechatBindStatus')).toHaveLength(1);
|
||
});
|
||
it('does not create an enable request after unmount during the authoritative QR read', async () => {
|
||
qrStatus = 'confirmed';
|
||
const base = api.call.getMockImplementation()!;
|
||
let release: (() => void) | undefined;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'channelAccounts' && calls('channelAccountWechatBindStart').length)
|
||
await new Promise<void>((resolve) => {
|
||
release = resolve;
|
||
});
|
||
return base(op, input);
|
||
});
|
||
const view = renderPage();
|
||
await adding();
|
||
await waitFor(() => expect(release).toBeTypeOf('function'));
|
||
view.unmount();
|
||
await act(async () => release!());
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('closing a pending QR does not later enable it or leave polling alive', async () => {
|
||
renderPage();
|
||
const dialog = await adding();
|
||
await within(dialog).findByRole('img', { name: '个人微信登录二维码' });
|
||
vi.useFakeTimers();
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '稍后继续' }));
|
||
qrStatus = 'confirmed';
|
||
await act(async () => {
|
||
await vi.advanceTimersByTimeAsync(6000);
|
||
});
|
||
expect(calls('channelAccountWechatBindStatus')).toHaveLength(0);
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
});
|
||
it('retries an unsuccessful new route with the same operation, without creating another account', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
let attempts = 0;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'routeChannelAccount' && ++attempts === 1) throw new Error('绑定未完成');
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('绑定未完成');
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '下一步：扫码连接' }));
|
||
await within(dialog).findByRole('img', { name: '个人微信登录二维码' });
|
||
expect(calls('createChannelAccount')).toHaveLength(1);
|
||
expect(calls('routeChannelAccount')[0][1]).toEqual(calls('routeChannelAccount')[1][1]);
|
||
});
|
||
it('represents a pending operation honestly and prevents conflicting changes until recovery', async () => {
|
||
pending = [
|
||
{
|
||
id: 'unknown-pause',
|
||
operation: 'pauseChannelAccount',
|
||
input: { channel_account_id: legacy.id, expected_revision: 7, operation_id: 'original' },
|
||
created_at: '',
|
||
},
|
||
];
|
||
renderPage();
|
||
const current = await card();
|
||
expect(within(current).getByText('正在确认')).toBeVisible();
|
||
expect(within(current).getByRole('button', { name: '更换智能体' })).toBeDisabled();
|
||
expect(screen.getByRole('button', { name: '添加微信' })).toBeDisabled();
|
||
expect(writes()).toEqual([]);
|
||
pending = [];
|
||
accounts[0] = { ...legacy, enabled: false, blockers: ['binding_paused'] };
|
||
fireEvent.click(within(current).getByRole('button', { name: '刷新确认' }));
|
||
expect(await screen.findByText('已暂停')).toBeVisible();
|
||
expect(within(current).getByRole('button', { name: '更换智能体' })).toBeEnabled();
|
||
expect(writes()).toEqual([]);
|
||
});
|
||
it('does not paint local paused or degraded synchronization as usable', async () => {
|
||
accounts = [
|
||
{ ...legacy, enabled: false, desired_state: 'paused', blockers: ['binding_paused'] },
|
||
{
|
||
...spare,
|
||
target_agent_slug: agentA.slug,
|
||
health: 'connected',
|
||
enabled: true,
|
||
sync_state: 'degraded',
|
||
blockers: ['channel_sync_degraded'],
|
||
},
|
||
];
|
||
renderPage();
|
||
expect(await screen.findByText('已暂停')).toBeVisible();
|
||
expect(within(await card(spare.display_name)).getByText('正在确认')).toBeVisible();
|
||
expect(screen.queryByText('使用中')).not.toBeInTheDocument();
|
||
});
|
||
it('deep links open the single choice dialog and refresh preserves user choice', async () => {
|
||
renderPage('/cloud-agents/channels?account=' + legacy.id + '&target=' + agentB.slug);
|
||
const dialog = await screen.findByRole('dialog', { name: '更换智能体' });
|
||
expect(within(dialog).getByRole('radio', { name: agentB.name })).toBeChecked();
|
||
expect(screen.getByTestId('location-path')).not.toHaveTextContent('target=');
|
||
expect(writes()).toEqual([]);
|
||
});
|
||
it.each(['accounts', 'agents'])(
|
||
'keeps failed %s loading distinct from an empty list',
|
||
async (source) => {
|
||
if (source === 'accounts') api.call.mockRejectedValue(new Error('微信列表暂时不可用'));
|
||
else api.list.mockRejectedValue(new Error('智能体列表暂时不可用'));
|
||
renderPage();
|
||
expect(await screen.findByRole('alert')).toHaveTextContent('暂时不可用');
|
||
expect(screen.getByRole('button', { name: '添加微信' })).toBeDisabled();
|
||
expect(screen.queryByRole('heading', { name: '把你的智能体带到微信吧' })).not.toBeInTheDocument();
|
||
}
|
||
);
|
||
|
||
it('locks changing an inconsistent local paused route without preventing safe unbind', async () => {
|
||
accounts = [{ ...legacy, desired_state: 'paused', enabled: true }];
|
||
renderPage();
|
||
const current = await card();
|
||
expect(within(current).getByText('正在确认')).toBeVisible();
|
||
expect(within(current).queryByText('使用中')).not.toBeInTheDocument();
|
||
expect(within(current).getByRole('button', { name: '更换智能体' })).toBeDisabled();
|
||
fireEvent.click(within(current).getByRole('button', { name: '更多操作' }));
|
||
expect(within(current).getByRole('button', { name: '解除微信绑定' })).toBeEnabled();
|
||
});
|
||
|
||
it('loads all Agent pages and offers only published enabled targets', async () => {
|
||
api.list.mockImplementation(async (cursor) =>
|
||
cursor
|
||
? {
|
||
agents: [
|
||
agentB,
|
||
{ ...agentA, slug: 'ml-' + 'c'.repeat(32), name: '未发布', published_version: null },
|
||
],
|
||
next_cursor: null,
|
||
}
|
||
: { agents: [agentA], next_cursor: 'page-2' }
|
||
);
|
||
renderPage();
|
||
const dialog = await chooseExisting();
|
||
expect(within(dialog).getByRole('radio', { name: agentA.name })).toBeVisible();
|
||
expect(within(dialog).getByRole('radio', { name: agentB.name })).toBeVisible();
|
||
expect(within(dialog).queryByRole('radio', { name: '未发布' })).not.toBeInTheDocument();
|
||
expect(api.list).toHaveBeenNthCalledWith(2, 'page-2');
|
||
});
|
||
|
||
it('keeps existing cards removable when no available Agent remains', async () => {
|
||
agents = [];
|
||
renderPage();
|
||
const current = await more();
|
||
fireEvent.click(within(current).getByRole('button', { name: '解除微信绑定' }));
|
||
const dialog = screen.getByRole('dialog', { name: '解除微信绑定' });
|
||
expect(within(dialog).getByRole('button', { name: '确认解除微信绑定' })).toBeEnabled();
|
||
expect(writes()).toEqual([]);
|
||
});
|
||
|
||
it.each(['expired', 'failed'] as const)(
|
||
'offers an explicit QR refresh after %s without claiming success',
|
||
async (status) => {
|
||
qrStatus = status;
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('button', { name: '刷新二维码' })).toBeEnabled();
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
qrStatus = 'confirmed';
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '刷新二维码' }));
|
||
await within(dialog).findByRole('heading', { name: '微信绑定成功' });
|
||
expect(calls('channelAccountWechatBindStart')[1][1]).toMatchObject({ force: true });
|
||
expect(calls('enableChannelAccount')).toHaveLength(1);
|
||
}
|
||
);
|
||
|
||
it('continues an existing unfinished account without creating another account slot', async () => {
|
||
accounts = [{ ...spare, health: 'connected' }];
|
||
renderPage();
|
||
const dialog = await chooseExisting(spare.display_name);
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentA.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '下一步：扫码连接' }));
|
||
await within(dialog).findByRole('heading', { name: '微信绑定成功' });
|
||
expect(calls('createChannelAccount')).toHaveLength(0);
|
||
expect(calls('channelAccountWechatBindStart')).toHaveLength(0);
|
||
expect(calls('enableChannelAccount')).toHaveLength(1);
|
||
});
|
||
|
||
it('does not enable an offline Worker after confirmed QR login', async () => {
|
||
qrStatus = 'confirmed';
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
const result = await base(op, input);
|
||
if (op === 'channelAccountWechatBindStart')
|
||
accounts.find((item) => item.id === input.channel_account_id)!.blockers = ['worker_offline'];
|
||
return result;
|
||
});
|
||
renderPage();
|
||
const dialog = await adding();
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('微信还没有准备好');
|
||
expect(calls('enableChannelAccount')).toHaveLength(0);
|
||
});
|
||
|
||
it('recovers the original uncertain operation through the existing recovery control', async () => {
|
||
pending = [
|
||
{
|
||
id: 'original-unbind-record',
|
||
operation: 'unbindChannelAccount',
|
||
input: { channel_account_id: legacy.id, operation_id: 'original-op', expected_revision: 7 },
|
||
created_at: '2026-10-13T00:00:00Z',
|
||
},
|
||
];
|
||
api.resolvePending.mockImplementation(async (id) => {
|
||
expect(id).toBe('original-unbind-record');
|
||
Object.assign(accounts[0], { target_agent_slug: null, enabled: false, health: 'login_required' });
|
||
pending = [];
|
||
return { result: { unbound: true, disconnected: true }, operation: 'unbindChannelAccount' };
|
||
});
|
||
renderPage();
|
||
await card();
|
||
fireEvent.click(screen.getByRole('button', { name: '待处理记录（1）' }));
|
||
const recovery = screen.getByRole('dialog', { name: '待处理记录' });
|
||
fireEvent.click(within(recovery).getByRole('button', { name: '再试一次' }));
|
||
await within(recovery).findByText('解除微信绑定的结果已确认。');
|
||
fireEvent.click(within(recovery).getByRole('button', { name: '返回列表' }));
|
||
expect(within(await card()).getByText('未绑定')).toBeVisible();
|
||
expect(api.resolvePending).toHaveBeenCalledWith('original-unbind-record', false);
|
||
expect(writes()).toEqual([]);
|
||
});
|
||
|
||
it('retains an uncertain badge when final route synchronization is degraded', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
const result = await base(op, input);
|
||
if (op === 'routeChannelAccount') accounts[0].sync_state = 'degraded';
|
||
return result;
|
||
});
|
||
renderPage();
|
||
const dialog = await chooseExisting();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('操作结果还没有确认');
|
||
expect(screen.queryByText('已更换智能体，微信连接和历史保留。')).not.toBeInTheDocument();
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '关闭' }));
|
||
expect(within(await card()).getByText('正在确认')).toBeVisible();
|
||
});
|
||
|
||
it('ignores an older manual refresh that arrives after the final switch read', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
const original = accounts.map((account) => ({ ...account }));
|
||
let releaseRefresh: (() => void) | undefined;
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'channelAccounts' && calls('channelAccounts').length === 2) {
|
||
await new Promise<void>((resolve) => {
|
||
releaseRefresh = resolve;
|
||
});
|
||
return { items: original };
|
||
}
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
await card();
|
||
fireEvent.click(screen.getByRole('button', { name: '刷新微信列表' }));
|
||
await waitFor(() => expect(releaseRefresh).toBeTypeOf('function'));
|
||
const dialog = await chooseExisting();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
|
||
expect(within(await card()).getByText(agentB.name)).toBeVisible();
|
||
await act(async () => releaseRefresh!());
|
||
expect(within(await card()).getByText(agentB.name)).toBeVisible();
|
||
expect(within(await card()).queryByText(agentA.name)).not.toBeInTheDocument();
|
||
});
|
||
|
||
it('preserves owned cards and safe pause/unbind when the initial Agent listing fails', async () => {
|
||
api.list.mockRejectedValue(new Error('智能体列表暂时不可用'));
|
||
renderPage();
|
||
const current = await card();
|
||
expect(within(current).getByText(agentA.name)).toBeVisible();
|
||
expect(within(current).getByRole('button', { name: '更换智能体' })).toBeDisabled();
|
||
const menu = await more();
|
||
expect(within(menu).getByRole('button', { name: '暂停自动回复' })).toBeEnabled();
|
||
expect(within(menu).getByRole('button', { name: '解除微信绑定' })).toBeEnabled();
|
||
fireEvent.click(within(menu).getByRole('button', { name: '解除微信绑定' }));
|
||
const dialog = screen.getByRole('dialog', { name: '解除微信绑定' });
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认解除微信绑定' }));
|
||
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
|
||
expect(within(await card()).getByText('未绑定')).toBeVisible();
|
||
expect(calls('unbindChannelAccount')).toHaveLength(1);
|
||
expect(calls('routeChannelAccount')).toHaveLength(0);
|
||
});
|
||
|
||
it('does not let an older refresh erase a new uncertain operation and unlock the card', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
const original = accounts.map((account) => ({ ...account }));
|
||
let releaseRefresh: (() => void) | undefined;
|
||
api.recovery.mockImplementation(async () => ({ recent: null, pending: [...pending] }));
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'channelAccounts' && calls('channelAccounts').length === 2) {
|
||
await new Promise<void>((resolve) => {
|
||
releaseRefresh = resolve;
|
||
});
|
||
return { items: original };
|
||
}
|
||
if (op === 'routeChannelAccount') {
|
||
pending = [
|
||
{
|
||
id: 'new-uncertain-route',
|
||
operation: 'routeChannelAccount',
|
||
input: { ...input },
|
||
created_at: '2026-10-13T00:00:00Z',
|
||
},
|
||
];
|
||
throw new Error('还没有确认切换结果');
|
||
}
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
await card();
|
||
fireEvent.click(screen.getByRole('button', { name: '刷新微信列表' }));
|
||
await waitFor(() => expect(releaseRefresh).toBeTypeOf('function'));
|
||
const dialog = await chooseExisting();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('还没有确认切换结果');
|
||
await within(dialog).findByText('上次操作的结果还需要确认。请关闭窗口，处理页面上的恢复提醒。');
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '关闭' }));
|
||
expect(within(await card()).getByText('正在确认')).toBeVisible();
|
||
await act(async () => releaseRefresh!());
|
||
expect(within(await card()).getByText('正在确认')).toBeVisible();
|
||
expect(within(await card()).getByRole('button', { name: '更换智能体' })).toBeDisabled();
|
||
expect(screen.getByRole('button', { name: '待处理记录（1）' })).toBeVisible();
|
||
expect(calls('routeChannelAccount')).toHaveLength(1);
|
||
});
|
||
|
||
it('keeps an uncertain operation locked when its recovery read is also unavailable', async () => {
|
||
const base = api.call.getMockImplementation()!;
|
||
api.recovery
|
||
.mockResolvedValueOnce({ recent: null, pending: [] })
|
||
.mockRejectedValue(new Error('恢复状态暂时不可用'));
|
||
api.call.mockImplementation(async (op, input) => {
|
||
if (op === 'routeChannelAccount') throw new Error('服务器响应还没有收到');
|
||
return base(op, input);
|
||
});
|
||
renderPage();
|
||
const dialog = await chooseExisting();
|
||
fireEvent.click(within(dialog).getByRole('radio', { name: agentB.name }));
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '确认更换' }));
|
||
expect(await within(dialog).findByRole('alert')).toHaveTextContent('服务器响应还没有收到');
|
||
await waitFor(() => expect(within(dialog).getByRole('button', { name: '确认更换' })).toBeDisabled());
|
||
fireEvent.click(within(dialog).getByRole('button', { name: '关闭' }));
|
||
expect(within(await card()).getByText('正在确认')).toBeVisible();
|
||
expect(within(await card()).getByRole('button', { name: '更换智能体' })).toBeDisabled();
|
||
expect(calls('routeChannelAccount')).toHaveLength(1);
|
||
});
|