1118 lines
36 KiB
TypeScript
1118 lines
36 KiB
TypeScript
jest.mock('@/common', () => {
|
|
const actualCommon = jest.requireActual('@/common');
|
|
return {
|
|
...actualCommon,
|
|
ToolsService: actualCommon.ToolsService,
|
|
ensureSnowflakeId: jest.fn(),
|
|
setDictDecodeCache: jest.fn(),
|
|
throwVbenError: (message: string) => {
|
|
throw new Error(message);
|
|
},
|
|
};
|
|
});
|
|
|
|
import { ConfigService } from '@nestjs/config';
|
|
import { ToolsService } from '@/common';
|
|
import { QqbotAccountService } from '@/qqbot/account/qqbot-account.service';
|
|
import { QqbotNapcatLoginService } from '@/qqbot/account/qqbot-napcat-login.service';
|
|
import { QqbotNapcatContainerService } from '@/qqbot/napcat/qqbot-napcat-container.service';
|
|
|
|
describe('QqbotNapcatLoginService', () => {
|
|
const toolsService = new ToolsService();
|
|
const service = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
{} as QqbotAccountService,
|
|
{} as QqbotNapcatContainerService,
|
|
toolsService,
|
|
);
|
|
|
|
beforeEach(() => {
|
|
(service as any).sessions.clear();
|
|
(service as any).sessionEventLogs.clear();
|
|
(service as any).sessionEventListeners.clear();
|
|
jest.restoreAllMocks();
|
|
});
|
|
|
|
it('uses qrcode returned by NapCat refresh endpoint', async () => {
|
|
(service as any).sessions.set('session-1', {
|
|
containerId: 'container-1',
|
|
containerName: 'napcat-1',
|
|
createdAt: Date.now(),
|
|
expiresAt: Date.now() + 60_000,
|
|
id: 'session-1',
|
|
mode: 'refresh',
|
|
qrcode: 'old-qrcode',
|
|
status: 'pending',
|
|
webuiPort: 6100,
|
|
});
|
|
jest
|
|
.spyOn(service as any, 'getSessionContainer')
|
|
.mockResolvedValue({ id: 'container-1' });
|
|
jest.spyOn(service as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: false,
|
|
});
|
|
jest
|
|
.spyOn(service as any, 'callRefreshQrcode')
|
|
.mockResolvedValue('new-qrcode-image');
|
|
const getQrcode = jest.spyOn(service as any, 'getQrcode');
|
|
|
|
const result = await service.refreshQrcode('session-1');
|
|
|
|
expect(result.qrcode).toBe('new-qrcode-image');
|
|
expect(getQrcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('reuses the existing account container when refreshing login', async () => {
|
|
const account = {
|
|
id: 'account-1',
|
|
selfId: '10001',
|
|
};
|
|
const existingContainer = {
|
|
id: 'container-current',
|
|
name: 'napcat-10001',
|
|
};
|
|
const accountService = {
|
|
findById: jest.fn().mockResolvedValue(account),
|
|
findByIdWithNapcatLoginSecret: jest.fn().mockResolvedValue(account),
|
|
getNapcatLoginPassword: jest.fn().mockReturnValue('qq-password'),
|
|
};
|
|
const containerService = {
|
|
prepareAccountContainer: jest.fn().mockResolvedValue(existingContainer),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
accountService as unknown as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const startScan = jest
|
|
.spyOn(refreshService as any, 'startScan')
|
|
.mockResolvedValue({ sessionId: 'session-refresh' });
|
|
|
|
await refreshService.startRefresh('account-1');
|
|
|
|
expect(accountService.findByIdWithNapcatLoginSecret).toHaveBeenCalledWith(
|
|
'account-1',
|
|
);
|
|
expect(accountService.getNapcatLoginPassword).toHaveBeenCalledWith(account);
|
|
expect(containerService.prepareAccountContainer).toHaveBeenCalledWith(
|
|
account,
|
|
);
|
|
expect(startScan).toHaveBeenCalledWith(
|
|
{
|
|
accountId: 'account-1',
|
|
expectedSelfId: '10001',
|
|
forceRelogin: true,
|
|
loginPassword: 'qq-password',
|
|
mode: 'refresh',
|
|
},
|
|
existingContainer,
|
|
);
|
|
});
|
|
|
|
it('returns refresh login scan immediately while trying quick login in background', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-current',
|
|
name: 'napcat-10001',
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
{} as QqbotAccountService,
|
|
{} as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest
|
|
.spyOn(refreshService as any, 'cleanupSessions')
|
|
.mockResolvedValue(undefined);
|
|
const prepareReloginQrcode = jest
|
|
.spyOn(refreshService as any, 'prepareReloginQrcode')
|
|
.mockResolvedValue(undefined);
|
|
|
|
const result = await (refreshService as any).startScan(
|
|
{
|
|
accountId: 'account-1',
|
|
expectedSelfId: '10001',
|
|
forceRelogin: true,
|
|
mode: 'refresh',
|
|
},
|
|
container,
|
|
);
|
|
|
|
expect(result.status).toBe('pending');
|
|
expect(result.qrcode).toBeUndefined();
|
|
expect(result.errorMessage).toBe('NapCat 正在尝试快速登录，请稍后');
|
|
expect(prepareReloginQrcode).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
errorMessage: 'NapCat 正在尝试快速登录，请稍后',
|
|
status: 'pending',
|
|
}),
|
|
container,
|
|
undefined,
|
|
undefined,
|
|
);
|
|
});
|
|
|
|
it('uses NapCat -q quick login before generating qrcode for refresh login', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-quick',
|
|
name: 'napcat-10001',
|
|
};
|
|
const accountService = {
|
|
ensureScannedAccount: jest.fn().mockResolvedValue('account-1'),
|
|
};
|
|
const containerService = {
|
|
bindAccount: jest.fn().mockResolvedValue(undefined),
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValue({ changed: false, ok: true }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
accountService as unknown as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest.spyOn(refreshService as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: true,
|
|
});
|
|
jest.spyOn(refreshService as any, 'getLoginInfo').mockResolvedValue({
|
|
nickname: 'Kwi',
|
|
online: true,
|
|
uin: '10001',
|
|
});
|
|
const refreshQrcode = jest
|
|
.spyOn(refreshService as any, 'refreshOrGetQrcode')
|
|
.mockResolvedValue('fallback-qrcode');
|
|
|
|
await (refreshService as any).prepareReloginQrcode(session, container);
|
|
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenCalledWith(
|
|
container,
|
|
{
|
|
clearLoginPassword: true,
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(containerService.restartRuntimeContainer).toHaveBeenCalledWith(
|
|
container,
|
|
);
|
|
expect(containerService.resetRuntimeLoginState).not.toHaveBeenCalled();
|
|
expect(refreshQrcode).not.toHaveBeenCalled();
|
|
expect(accountService.ensureScannedAccount).toHaveBeenCalledWith({
|
|
accountId: 'account-1',
|
|
name: 'Kwi',
|
|
selfId: '10001',
|
|
});
|
|
expect(containerService.bindAccount).toHaveBeenCalledWith(
|
|
'account-1',
|
|
'container-quick',
|
|
);
|
|
expect(session.status).toBe('success');
|
|
const events = (refreshService as any).sessionEventLogs.get(session.id);
|
|
expect(events).toEqual(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({ step: 'quick-login-start' }),
|
|
expect.objectContaining({
|
|
message: '快速登录成功',
|
|
step: 'login-success',
|
|
}),
|
|
]),
|
|
);
|
|
});
|
|
|
|
it('does not complete quick login when runtime password env cleanup fails', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-quick-cleanup-failed',
|
|
name: 'napcat-10001',
|
|
};
|
|
const accountService = {
|
|
ensureScannedAccount: jest.fn().mockResolvedValue('account-1'),
|
|
};
|
|
const containerService = {
|
|
bindAccount: jest.fn().mockResolvedValue(undefined),
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValue({ changed: false, ok: false }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
accountService as unknown as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest.spyOn(refreshService as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: true,
|
|
});
|
|
jest.spyOn(refreshService as any, 'getLoginInfo').mockResolvedValue({
|
|
nickname: 'Kwi',
|
|
online: true,
|
|
uin: '10001',
|
|
});
|
|
|
|
await (refreshService as any).prepareReloginQrcode(session, container);
|
|
|
|
expect(accountService.ensureScannedAccount).not.toHaveBeenCalled();
|
|
expect(containerService.bindAccount).not.toHaveBeenCalled();
|
|
expect(session.status).toBe('error');
|
|
expect(session.errorMessage).toBe(
|
|
'NapCat 快速登录前运行态密码清理失败，请重试更新登录',
|
|
);
|
|
const steps = (
|
|
(refreshService as any).sessionEventLogs.get(session.id) ?? []
|
|
).map((event: { step: string }) => event.step);
|
|
expect(steps).toContain('quick-login-cleanup');
|
|
expect(steps).not.toContain('login-success');
|
|
});
|
|
|
|
it('falls back to fresh qrcode when NapCat -q quick login fails', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-fallback',
|
|
name: 'napcat-10001',
|
|
};
|
|
const containerService = {
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValue({ changed: false, ok: true }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
{} as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest.spyOn(refreshService as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: false,
|
|
loginError: '快速登录未成功',
|
|
});
|
|
jest
|
|
.spyOn(refreshService as any, 'refreshOrGetQrcode')
|
|
.mockResolvedValue('fallback-qrcode');
|
|
|
|
await (refreshService as any).prepareReloginQrcode(session, container);
|
|
|
|
expect(containerService.restartRuntimeContainer).toHaveBeenCalledWith(
|
|
container,
|
|
);
|
|
expect(containerService.resetRuntimeLoginState).toHaveBeenCalledWith(
|
|
container,
|
|
expect.any(Function),
|
|
);
|
|
expect(
|
|
containerService.restartRuntimeContainer.mock.invocationCallOrder[0],
|
|
).toBeLessThan(
|
|
containerService.resetRuntimeLoginState.mock.invocationCallOrder[0],
|
|
);
|
|
expect(session.qrcode).toBe('fallback-qrcode');
|
|
const steps = (
|
|
(refreshService as any).sessionEventLogs.get(session.id) ?? []
|
|
).map((event: { step: string }) => event.step);
|
|
expect(steps.indexOf('quick-login-start')).toBeLessThan(
|
|
steps.indexOf('quick-login-fallback'),
|
|
);
|
|
expect(steps.indexOf('quick-login-fallback')).toBeLessThan(
|
|
steps.indexOf('relogin-reset-start'),
|
|
);
|
|
});
|
|
|
|
it('tries password login after quick login fails and before qrcode fallback', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-password',
|
|
name: 'napcat-10001',
|
|
};
|
|
const accountService = {
|
|
ensureScannedAccount: jest.fn().mockResolvedValue('account-1'),
|
|
};
|
|
const containerService = {
|
|
bindAccount: jest.fn().mockResolvedValue(undefined),
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValue({ changed: true, ok: true }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
accountService as unknown as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest
|
|
.spyOn(refreshService as any, 'getLoginStatus')
|
|
.mockResolvedValueOnce({
|
|
isLogin: false,
|
|
loginError: '快速登录未找到历史会话',
|
|
})
|
|
.mockResolvedValueOnce({
|
|
isLogin: true,
|
|
});
|
|
jest.spyOn(refreshService as any, 'getLoginInfo').mockResolvedValue({
|
|
nickname: 'Kwi',
|
|
online: true,
|
|
uin: '10001',
|
|
});
|
|
const refreshQrcode = jest
|
|
.spyOn(refreshService as any, 'refreshOrGetQrcode')
|
|
.mockResolvedValue('fallback-qrcode');
|
|
|
|
await (refreshService as any).prepareReloginQrcode(
|
|
session,
|
|
container,
|
|
'qq-password',
|
|
);
|
|
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenCalledWith(
|
|
container,
|
|
{
|
|
clearLoginPassword: true,
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenCalledWith(
|
|
container,
|
|
{
|
|
loginPassword: 'qq-password',
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenCalledWith(
|
|
container,
|
|
{
|
|
clearLoginPassword: true,
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenNthCalledWith(
|
|
3,
|
|
container,
|
|
{
|
|
clearLoginPassword: true,
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(containerService.resetRuntimeLoginState).not.toHaveBeenCalled();
|
|
expect(refreshQrcode).not.toHaveBeenCalled();
|
|
expect(accountService.ensureScannedAccount).toHaveBeenCalledWith({
|
|
accountId: 'account-1',
|
|
name: 'Kwi',
|
|
selfId: '10001',
|
|
});
|
|
expect(session.status).toBe('success');
|
|
const steps = (
|
|
(refreshService as any).sessionEventLogs.get(session.id) ?? []
|
|
).map((event: { step: string }) => event.step);
|
|
expect(steps).toEqual(
|
|
expect.arrayContaining([
|
|
'quick-login-start',
|
|
'quick-login-fallback',
|
|
'password-login-start',
|
|
'password-login-wait',
|
|
'login-success',
|
|
]),
|
|
);
|
|
expect(steps.indexOf('quick-login-fallback')).toBeLessThan(
|
|
steps.indexOf('password-login-start'),
|
|
);
|
|
expect(steps.indexOf('password-login-start')).toBeLessThan(
|
|
steps.indexOf('login-success'),
|
|
);
|
|
});
|
|
|
|
it('uses password before qrcode without historical NapCat session', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
hasExistingPrimaryBinding: false,
|
|
id: 'container-new',
|
|
name: 'napcat-10001',
|
|
};
|
|
const accountService = {
|
|
ensureScannedAccount: jest.fn().mockResolvedValue('account-1'),
|
|
};
|
|
const containerService = {
|
|
bindAccount: jest.fn().mockResolvedValue(undefined),
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValue({ changed: true, ok: true }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
accountService as unknown as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest.spyOn(refreshService as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: true,
|
|
});
|
|
jest.spyOn(refreshService as any, 'getLoginInfo').mockResolvedValue({
|
|
nickname: 'Kwi',
|
|
online: true,
|
|
uin: '10001',
|
|
});
|
|
const refreshQrcode = jest
|
|
.spyOn(refreshService as any, 'refreshOrGetQrcode')
|
|
.mockResolvedValue('fallback-qrcode');
|
|
|
|
await (refreshService as any).prepareReloginQrcode(
|
|
session,
|
|
container,
|
|
'qq-password',
|
|
false,
|
|
);
|
|
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenNthCalledWith(
|
|
1,
|
|
container,
|
|
{
|
|
loginPassword: 'qq-password',
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(refreshQrcode).not.toHaveBeenCalled();
|
|
expect(session.status).toBe('success');
|
|
const steps = (
|
|
(refreshService as any).sessionEventLogs.get(session.id) ?? []
|
|
).map((event: { step: string }) => event.step);
|
|
expect(steps).not.toContain('quick-login-start');
|
|
expect(steps).toEqual(
|
|
expect.arrayContaining(['password-login-start', 'login-success']),
|
|
);
|
|
});
|
|
|
|
it('fails password refresh when runtime password env cleanup fails', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-password-cleanup-failed',
|
|
name: 'napcat-10001',
|
|
};
|
|
const accountService = {
|
|
ensureScannedAccount: jest.fn().mockResolvedValue('account-1'),
|
|
};
|
|
const containerService = {
|
|
bindAccount: jest.fn().mockResolvedValue(undefined),
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValueOnce({ changed: false, ok: true })
|
|
.mockResolvedValueOnce({ changed: true, ok: true })
|
|
.mockResolvedValueOnce({ changed: false, ok: false }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
accountService as unknown as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest
|
|
.spyOn(refreshService as any, 'getLoginStatus')
|
|
.mockResolvedValueOnce({
|
|
isLogin: false,
|
|
loginError: '快速登录未找到历史会话',
|
|
})
|
|
.mockResolvedValueOnce({
|
|
isLogin: true,
|
|
});
|
|
jest.spyOn(refreshService as any, 'getLoginInfo').mockResolvedValue({
|
|
nickname: 'Kwi',
|
|
online: true,
|
|
uin: '10001',
|
|
});
|
|
|
|
await (refreshService as any).prepareReloginQrcode(
|
|
session,
|
|
container,
|
|
'qq-password',
|
|
);
|
|
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenNthCalledWith(
|
|
3,
|
|
container,
|
|
{
|
|
clearLoginPassword: true,
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(accountService.ensureScannedAccount).not.toHaveBeenCalled();
|
|
expect(containerService.bindAccount).not.toHaveBeenCalled();
|
|
expect(session.status).toBe('error');
|
|
expect(session.errorMessage).toBe(
|
|
'NapCat 密码登录已完成，但运行态密码清理失败，请重试更新登录',
|
|
);
|
|
const steps = (
|
|
(refreshService as any).sessionEventLogs.get(session.id) ?? []
|
|
).map((event: { step: string }) => event.step);
|
|
expect(steps).toContain('password-env-cleanup');
|
|
expect(steps).not.toContain('login-success');
|
|
});
|
|
|
|
it('falls back to qrcode only after quick login and password login both fail', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-password-fallback',
|
|
name: 'napcat-10001',
|
|
};
|
|
const containerService = {
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValue({ changed: true, ok: true }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
{} as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest
|
|
.spyOn(refreshService as any, 'getLoginStatus')
|
|
.mockResolvedValueOnce({
|
|
isLogin: false,
|
|
loginError: '快速登录未找到历史会话',
|
|
})
|
|
.mockResolvedValueOnce({
|
|
isLogin: false,
|
|
loginError: '密码登录未完成',
|
|
});
|
|
jest
|
|
.spyOn(refreshService as any, 'refreshOrGetQrcode')
|
|
.mockResolvedValue('fallback-qrcode');
|
|
|
|
await (refreshService as any).prepareReloginQrcode(
|
|
session,
|
|
container,
|
|
'qq-password',
|
|
);
|
|
|
|
expect(containerService.resetRuntimeLoginState).toHaveBeenCalledWith(
|
|
container,
|
|
expect.any(Function),
|
|
);
|
|
expect(session.qrcode).toBe('fallback-qrcode');
|
|
const steps = (
|
|
(refreshService as any).sessionEventLogs.get(session.id) ?? []
|
|
).map((event: { step: string }) => event.step);
|
|
expect(steps.indexOf('quick-login-fallback')).toBeLessThan(
|
|
steps.indexOf('password-login-start'),
|
|
);
|
|
expect(steps.indexOf('password-login-fallback')).toBeLessThan(
|
|
steps.indexOf('relogin-reset-start'),
|
|
);
|
|
});
|
|
|
|
it('does not enter qrcode fallback when password env cleanup after failed password login fails', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-password-failed-cleanup-failed',
|
|
name: 'napcat-10001',
|
|
};
|
|
const containerService = {
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValueOnce({ changed: false, ok: true })
|
|
.mockResolvedValueOnce({ changed: true, ok: true })
|
|
.mockResolvedValueOnce({ changed: false, ok: false }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
{} as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest
|
|
.spyOn(refreshService as any, 'getLoginStatus')
|
|
.mockResolvedValueOnce({
|
|
isLogin: false,
|
|
loginError: '快速登录未找到历史会话',
|
|
})
|
|
.mockResolvedValueOnce({
|
|
isLogin: false,
|
|
loginError: '密码登录未完成',
|
|
});
|
|
const refreshQrcode = jest
|
|
.spyOn(refreshService as any, 'refreshOrGetQrcode')
|
|
.mockResolvedValue('fallback-qrcode');
|
|
|
|
await (refreshService as any).prepareReloginQrcode(
|
|
session,
|
|
container,
|
|
'qq-password',
|
|
);
|
|
|
|
expect(containerService.ensureRuntimeLoginEnv).toHaveBeenNthCalledWith(
|
|
3,
|
|
container,
|
|
{
|
|
clearLoginPassword: true,
|
|
selfId: '10001',
|
|
},
|
|
);
|
|
expect(containerService.resetRuntimeLoginState).not.toHaveBeenCalled();
|
|
expect(refreshQrcode).not.toHaveBeenCalled();
|
|
expect(session.status).toBe('error');
|
|
expect(session.errorMessage).toBe(
|
|
'NapCat 密码登录未完成，且运行态密码清理失败，请重试更新登录',
|
|
);
|
|
});
|
|
|
|
it('does not reset login state when quick login succeeds but binding fails', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-bind-error',
|
|
name: 'napcat-10001',
|
|
};
|
|
const accountService = {
|
|
ensureScannedAccount: jest
|
|
.fn()
|
|
.mockRejectedValue(new Error('账号绑定写入失败')),
|
|
};
|
|
const containerService = {
|
|
bindAccount: jest.fn().mockResolvedValue(undefined),
|
|
ensureRuntimeLoginEnv: jest
|
|
.fn()
|
|
.mockResolvedValue({ changed: false, ok: true }),
|
|
resetRuntimeLoginState: jest.fn().mockResolvedValue(true),
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
accountService as unknown as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
const session = (refreshService as any).createSession({
|
|
accountId: 'account-1',
|
|
container,
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
});
|
|
(refreshService as any).sessions.set(session.id, session);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest.spyOn(refreshService as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: true,
|
|
});
|
|
jest.spyOn(refreshService as any, 'getLoginInfo').mockResolvedValue({
|
|
nickname: 'Kwi',
|
|
online: true,
|
|
uin: '10001',
|
|
});
|
|
const refreshQrcode = jest
|
|
.spyOn(refreshService as any, 'refreshOrGetQrcode')
|
|
.mockResolvedValue('fallback-qrcode');
|
|
|
|
await (refreshService as any).prepareReloginQrcode(session, container);
|
|
|
|
expect(containerService.resetRuntimeLoginState).not.toHaveBeenCalled();
|
|
expect(refreshQrcode).not.toHaveBeenCalled();
|
|
expect(session.status).toBe('error');
|
|
expect(session.qrcode).toBeUndefined();
|
|
expect(session.errorMessage).toBe('账号绑定写入失败');
|
|
const steps = (
|
|
(refreshService as any).sessionEventLogs.get(session.id) ?? []
|
|
).map((event: { step: string }) => event.step);
|
|
expect(steps).toContain('quick-login-start');
|
|
expect(steps).not.toContain('quick-login-fallback');
|
|
expect(steps).not.toContain('relogin-reset-start');
|
|
});
|
|
|
|
it('does not complete refresh login from stale status while relogin is preparing', async () => {
|
|
(service as any).sessions.set('session-preparing', {
|
|
containerId: 'container-preparing',
|
|
containerName: 'napcat-preparing',
|
|
createdAt: Date.now(),
|
|
errorMessage: 'NapCat 正在尝试快速登录，请稍后',
|
|
expiresAt: Date.now() + 60_000,
|
|
id: 'session-preparing',
|
|
mode: 'refresh',
|
|
preparingRelogin: true,
|
|
status: 'pending',
|
|
webuiPort: 6106,
|
|
});
|
|
const getLoginStatus = jest.spyOn(service as any, 'getLoginStatus');
|
|
|
|
const result = await service.status('session-preparing');
|
|
|
|
expect(result.status).toBe('pending');
|
|
expect(result.errorMessage).toBe('NapCat 正在尝试快速登录，请稍后');
|
|
expect(getLoginStatus).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('replays scan progress events to late SSE subscribers', () => {
|
|
const session = {
|
|
containerId: 'container-events',
|
|
containerName: 'napcat-events',
|
|
createdAt: Date.now(),
|
|
expiresAt: Date.now() + 60_000,
|
|
id: 'session-events',
|
|
mode: 'refresh',
|
|
status: 'pending',
|
|
webuiPort: 6107,
|
|
};
|
|
(service as any).sessions.set('session-events', session);
|
|
(service as any).publishScanResultEvent(
|
|
session,
|
|
'container-stop',
|
|
'processing',
|
|
'正在停止 NapCat 容器',
|
|
);
|
|
const events: any[] = [];
|
|
|
|
const subscription = service
|
|
.events('session-events')
|
|
.subscribe((event) => events.push(event.data));
|
|
|
|
expect(events).toEqual([
|
|
expect.objectContaining({
|
|
message: '正在停止 NapCat 容器',
|
|
status: 'processing',
|
|
step: 'container-stop',
|
|
}),
|
|
]);
|
|
subscription.unsubscribe();
|
|
});
|
|
|
|
it('requires a qrcode different from the current one when refreshing qrcode', async () => {
|
|
(service as any).sessions.set('session-refresh-qrcode', {
|
|
containerId: 'container-3',
|
|
containerName: 'napcat-3',
|
|
createdAt: Date.now(),
|
|
expiresAt: Date.now() + 60_000,
|
|
id: 'session-refresh-qrcode',
|
|
mode: 'refresh',
|
|
qrcode: 'old-qrcode',
|
|
status: 'pending',
|
|
webuiPort: 6103,
|
|
});
|
|
const container = { id: 'container-3' };
|
|
jest
|
|
.spyOn(service as any, 'getSessionContainer')
|
|
.mockResolvedValue(container);
|
|
jest.spyOn(service as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: false,
|
|
qrcodeurl: 'old-qrcode',
|
|
});
|
|
jest.spyOn(service as any, 'callRefreshQrcode').mockResolvedValue('');
|
|
jest.spyOn(service as any, 'getQrcode').mockResolvedValue('new-qrcode');
|
|
|
|
const result = await service.refreshQrcode('session-refresh-qrcode');
|
|
|
|
expect(result.qrcode).toBe('new-qrcode');
|
|
expect((service as any).getQrcode).toHaveBeenCalledWith(container, false, {
|
|
requireFresh: true,
|
|
staleQrcode: 'old-qrcode',
|
|
});
|
|
});
|
|
|
|
it('keeps the refresh session pending when NapCat is still regenerating qrcode', async () => {
|
|
(service as any).sessions.set('session-pending-qrcode', {
|
|
containerId: 'container-pending',
|
|
containerName: 'napcat-pending',
|
|
createdAt: Date.now(),
|
|
expiresAt: Date.now() + 60_000,
|
|
id: 'session-pending-qrcode',
|
|
mode: 'refresh',
|
|
qrcode: 'old-qrcode',
|
|
status: 'pending',
|
|
webuiPort: 6105,
|
|
});
|
|
jest
|
|
.spyOn(service as any, 'getSessionContainer')
|
|
.mockResolvedValue({ id: 'container-pending' });
|
|
jest.spyOn(service as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: false,
|
|
qrcodeurl: 'old-qrcode',
|
|
});
|
|
jest
|
|
.spyOn(service as any, 'callRefreshQrcode')
|
|
.mockRejectedValue(new Error('NapCat 二维码仍未刷新'));
|
|
|
|
const result = await service.refreshQrcode('session-pending-qrcode');
|
|
|
|
expect(result.status).toBe('pending');
|
|
expect(result.qrcode).toBeUndefined();
|
|
expect(result.errorMessage).toContain('正在重新生成二维码');
|
|
});
|
|
|
|
it('normalizes login status to offline when login info reports offline', async () => {
|
|
jest
|
|
.spyOn(service as any, 'postNapcat')
|
|
.mockResolvedValueOnce({ isLogin: true, qrcodeurl: 'old-qrcode' })
|
|
.mockResolvedValueOnce({ online: false, uin: '10001' });
|
|
|
|
const result = await (service as any).getLoginStatus({
|
|
id: 'container-offline',
|
|
});
|
|
|
|
expect(result).toEqual(
|
|
expect.objectContaining({
|
|
isLogin: false,
|
|
isOffline: true,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('restarts container and returns pending when refresh login status is effectively offline', async () => {
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
{} as QqbotAccountService,
|
|
{} as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
jest
|
|
.spyOn(refreshService as any, 'cleanupSessions')
|
|
.mockResolvedValue(null);
|
|
jest.spyOn(refreshService as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: false,
|
|
isOffline: true,
|
|
loginError: 'NapCat 账号已离线',
|
|
qrcodeurl: 'old-qrcode',
|
|
});
|
|
const restartNapcatForLogin = jest
|
|
.spyOn(refreshService as any, 'restartNapcatForLogin')
|
|
.mockResolvedValue(undefined);
|
|
|
|
const result = await (refreshService as any).startScan(
|
|
{
|
|
accountId: 'account-1',
|
|
expectedSelfId: '10001',
|
|
mode: 'refresh',
|
|
},
|
|
{
|
|
baseUrl: 'http://127.0.0.1:6105/',
|
|
id: 'container-offline',
|
|
name: 'napcat-10001',
|
|
},
|
|
);
|
|
|
|
expect(result.status).toBe('pending');
|
|
expect(result.qrcode).toBeUndefined();
|
|
expect(result.errorMessage).toBe('NapCat 账号已离线');
|
|
expect(restartNapcatForLogin).toHaveBeenCalledWith(
|
|
expect.objectContaining({ id: 'container-offline' }),
|
|
{ waitForReady: false },
|
|
);
|
|
});
|
|
|
|
it('restarts the existing NapCat container before qrcode refresh when account is kicked offline', async () => {
|
|
const container = {
|
|
baseUrl: 'http://127.0.0.1:6103/',
|
|
id: 'container-3',
|
|
name: 'napcat-10001',
|
|
};
|
|
const containerService = {
|
|
restartRuntimeContainer: jest.fn().mockResolvedValue(true),
|
|
};
|
|
const refreshService = new QqbotNapcatLoginService(
|
|
{ get: jest.fn() } as unknown as ConfigService,
|
|
{} as QqbotAccountService,
|
|
containerService as unknown as QqbotNapcatContainerService,
|
|
new ToolsService(),
|
|
);
|
|
jest
|
|
.spyOn((refreshService as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest.spyOn(refreshService as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: false,
|
|
qrcodeurl: 'new-status-qrcode',
|
|
});
|
|
jest
|
|
.spyOn(refreshService as any, 'callRefreshQrcode')
|
|
.mockResolvedValue('');
|
|
jest
|
|
.spyOn(refreshService as any, 'getQrcode')
|
|
.mockResolvedValue('new-qrcode');
|
|
|
|
const result = await (refreshService as any).refreshOrGetQrcode(
|
|
container,
|
|
true,
|
|
{
|
|
fallbackStatus: {
|
|
isLogin: false,
|
|
isOffline: true,
|
|
loginError: '您的账号已在另一台终端登录',
|
|
qrcodeurl: 'old-qrcode',
|
|
},
|
|
},
|
|
);
|
|
|
|
expect(result).toBe('new-qrcode');
|
|
expect(containerService.restartRuntimeContainer).toHaveBeenCalledWith(
|
|
container,
|
|
);
|
|
expect((refreshService as any).getQrcode).toHaveBeenCalledWith(
|
|
container,
|
|
true,
|
|
{
|
|
requireFresh: true,
|
|
staleQrcode: 'old-qrcode',
|
|
},
|
|
);
|
|
});
|
|
|
|
it('retries while NapCat still exposes the stale qrcode', async () => {
|
|
jest
|
|
.spyOn((service as any).toolsService, 'sleep')
|
|
.mockResolvedValue(undefined);
|
|
jest
|
|
.spyOn(service as any, 'postNapcat')
|
|
.mockResolvedValueOnce({ qrcode: 'old-qrcode' })
|
|
.mockResolvedValueOnce({ qrcode: 'new-qrcode' });
|
|
|
|
const result = await (service as any).getQrcode(
|
|
{ id: 'container-4' },
|
|
true,
|
|
{
|
|
requireFresh: true,
|
|
staleQrcode: 'old-qrcode',
|
|
},
|
|
);
|
|
|
|
expect(result).toBe('new-qrcode');
|
|
expect((service as any).postNapcat).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('does not replace current qrcode with expired status qrcode', async () => {
|
|
(service as any).sessions.set('session-2', {
|
|
containerId: 'container-2',
|
|
containerName: 'napcat-2',
|
|
createdAt: Date.now(),
|
|
expiresAt: Date.now() + 60_000,
|
|
id: 'session-2',
|
|
mode: 'refresh',
|
|
qrcode: 'current-qrcode',
|
|
status: 'pending',
|
|
webuiPort: 6101,
|
|
});
|
|
jest
|
|
.spyOn(service as any, 'getSessionContainer')
|
|
.mockResolvedValue({ id: 'container-2' });
|
|
jest.spyOn(service as any, 'getLoginStatus').mockResolvedValue({
|
|
isLogin: false,
|
|
loginError: '二维码已过期',
|
|
qrcodeurl: 'expired-qrcode',
|
|
});
|
|
|
|
const result = await service.status('session-2');
|
|
|
|
expect(result.qrcode).toBe('current-qrcode');
|
|
expect(result.errorMessage).toBe('二维码已过期');
|
|
});
|
|
});
|