103 lines
7.3 KiB
JavaScript
103 lines
7.3 KiB
JavaScript
'use strict';
|
|
const test=require('node:test'),assert=require('node:assert/strict');
|
|
const {projectConnectionStatus,connectionSnapshot}=require('../../src/modules/bpm/connection-status.cjs');
|
|
const now=Date.parse('2026-10-24T06:00:00Z'),at=delta=>new Date(now+delta).toISOString();
|
|
function connection(){return {id:'c',owner:'worker',status:'connected',checkedAt:at(0),checks:{portal:{ok:true}},health:{portal:{status:'healthy',checkedAt:at(0)},todo:{status:'healthy',checkedAt:at(0)}},monitoring:{status:'listening',sources:{todo:{status:'healthy',lastSuccessAt:at(0)},inform:{status:'healthy',lastSuccessAt:at(0)}},delivery:{status:'healthy',pending:0}}};}
|
|
const read=(c,options={})=>projectConnectionStatus(c,{now,...options});
|
|
|
|
test('normal refresh keeps the last verified result while first reads remain pending',()=>{
|
|
const c=connection();assert.equal(read(c).sync.status,'healthy');
|
|
c.monitoring.sources.todo.status='running';assert.equal(read(c).sync.status,'healthy');
|
|
delete c.monitoring.sources.todo.lastSuccessAt;assert.equal(read(c).sync.status,'pending');
|
|
assert.equal(read(c).account.status,'healthy');
|
|
});
|
|
test('permission and delivery failures affect sync without invalidating a valid account',()=>{
|
|
const c=connection();c.health.todo={status:'forbidden',checkedAt:at(0)};
|
|
let result=read(c);assert.equal(result.account.status,'healthy');assert.equal(result.sync.reason,'READ_FORBIDDEN');
|
|
c.health.todo.status='healthy';c.monitoring.delivery={status:'error',pending:2};
|
|
result=read(c);assert.equal(result.account.status,'healthy');assert.equal(result.sync.reason,'DELIVERY_FAILED');
|
|
});
|
|
test('latest session evidence wins, and transport errors never masquerade as expired credentials',()=>{
|
|
const c=connection();c.status='login_required';c.checkedAt=at(-60000);
|
|
assert.equal(read(c).account.status,'healthy');
|
|
c.health.portal={status:'login_required',checkedAt:at(0)};
|
|
assert.equal(read(c).account.reason,'AUTH_REQUIRED');assert.equal(read(c).account.color,'red');
|
|
c.health.portal={status:'error',checkedAt:at(0)};
|
|
assert.equal(read(c).account.reason,'SESSION_UNAVAILABLE');assert.equal(read(c).account.color,'yellow');
|
|
c.status='connected';c.checkedAt=at(1000);c.checks.portal.ok=true;
|
|
assert.equal(read(c,{now:now+1000}).account.status,'healthy');
|
|
});
|
|
test('freshness follows reconciliation cadence and permits a normal session check grace period',()=>{
|
|
const c=connection();c.monitoring.sources.todo.lastSuccessAt=at(-12*60000);
|
|
assert.equal(read(c,{config:{intervalMinutes:10}}).sync.status,'healthy');
|
|
assert.equal(read(c,{config:{intervalMinutes:1}}).sync.reason,'SOURCE_STALE');
|
|
c.health.portal.checkedAt=c.checkedAt=at(-300001);
|
|
assert.equal(read(c).account.status,'healthy');
|
|
assert.equal(read(c,{now:now+330000}).account.reason,'SESSION_STALE');
|
|
});
|
|
test('pause overrides old failures; automatic-sync pause preserves the account',()=>{
|
|
const c=connection();c.monitoring.sources.todo.status='error';c.status='disabled';
|
|
let state=read(c);assert.equal(state.account.status,'paused');assert.equal(state.sync.status,'paused');
|
|
c.status='connected';state=read(c,{config:{enabled:false}});
|
|
assert.equal(state.account.status,'healthy');assert.equal(state.sync.status,'paused');
|
|
});
|
|
test('new account generation cannot inherit the old listener success',()=>{
|
|
const c=connection();c.monitoring.sessionEpoch=1;
|
|
const state=read(c,{sessionEpoch:2});
|
|
assert.equal(state.account.status,'healthy');assert.equal(state.sync.reason,'SESSION_CHANGED');assert.equal(state.sync.color,'yellow');
|
|
assert.equal(read(c,{sessionEpoch:1}).sync.status,'healthy');
|
|
});
|
|
test('newer read transport errors degrade sync until superseded by a full successful read',()=>{
|
|
for(const kind of ['todo','inform']){
|
|
const c=connection();c.monitoring.sources[kind].lastSuccessAt=at(-60000);c.health[kind]={status:'error',checkedAt:at(0)};
|
|
const state=read(c);assert.equal(state.account.status,'healthy');assert.equal(state.sync.reason,'READ_UNAVAILABLE');assert.equal(state.sync.color,'yellow');
|
|
c.monitoring.sources[kind].lastSuccessAt=at(1000);
|
|
assert.equal(read(c,{now:now+1000}).sync.status,'healthy');
|
|
}
|
|
});
|
|
test('recovered authentication waits for listener reconnect without asking for login again',()=>{
|
|
const c=connection();c.monitoring.status='login_required';
|
|
const state=read(c);assert.equal(state.account.status,'healthy');assert.equal(state.sync.reason,'LISTENER_PENDING');
|
|
assert.doesNotMatch(state.sync.message,/需要.*登录/);
|
|
c.health.portal={status:'login_required',checkedAt:at(0)};
|
|
assert.equal(read(c).sync.reason,'AUTH_REQUIRED');
|
|
});
|
|
test('retry preserves an unresolved failure, recovery clears it, and polling is a warning',()=>{
|
|
const c=connection(),source=c.monitoring.sources.todo;source.status='running';source.lastSuccessAt=at(-60000);source.lastFailureAt=at(-1000);
|
|
assert.equal(read(c).sync.reason,'SOURCE_FAILED');
|
|
source.status='healthy';source.lastSuccessAt=at(0);assert.equal(read(c).sync.status,'healthy');
|
|
c.monitoring.status='polling';assert.equal(read(c).sync.color,'yellow');assert.equal(read(c).account.color,'green');
|
|
});
|
|
test('snapshot only reads observations and derived states expose no credentials or upstream error bodies',()=>{
|
|
const c=connection(),before=structuredClone(c);
|
|
const manager={health:{freshMs:300000,snapshot:()=>c.health},ensure:()=>assert.fail('must not authenticate')};
|
|
const monitor={snapshot:()=>c.monitoring,scanner:{store:{config:()=>({intervalMinutes:10})}},reconfigure:()=>assert.fail('must not scan')};
|
|
c.monitoring.sources.todo.message='password=PRIVATE';
|
|
const snapshot=connectionSnapshot(c,{manager,monitor,now});
|
|
assert.equal(snapshot.connectionState.account.status,'healthy');assert.equal(snapshot.connectionState.sync.status,'healthy');
|
|
assert.doesNotMatch(JSON.stringify(snapshot.connectionState),/PRIVATE|password/);
|
|
c.monitoring.sessionEpoch=1;manager.epoch=()=>2;
|
|
assert.equal(connectionSnapshot(c,{manager,monitor,now}).connectionState.sync.reason,'SESSION_CHANGED');
|
|
delete c.monitoring.sessionEpoch;
|
|
delete c.monitoring.sources.todo.message;assert.deepEqual(c,before);
|
|
});
|
|
test('unavailable sync configuration does not hide a verified account or claim sync is healthy',()=>{
|
|
const c=connection();
|
|
const snapshot=connectionSnapshot(c,{now,config:()=>{throw Error('PRIVATE configuration failure');}});
|
|
assert.equal(snapshot.connectionState.account.status,'healthy');assert.equal(snapshot.connectionState.sync.reason,'SYNC_STATE_UNAVAILABLE');
|
|
assert.doesNotMatch(JSON.stringify(snapshot.connectionState),/PRIVATE/);
|
|
});
|
|
test('real session phases distinguish checking, automatic renewal, manual work and cooldown',()=>{
|
|
const c=connection();c.sessionActivity={phase:'checking',authentication:'valid'};
|
|
assert.equal(read(c).account.status,'healthy');
|
|
c.sessionActivity={phase:'renewing',authentication:'expired'};
|
|
assert.equal(read(c).account.reason,'RENEWING');assert.equal(read(c).sync.color,'yellow');
|
|
c.sessionActivity={phase:'manual',authentication:'valid'};
|
|
assert.equal(read(c).account.status,'healthy');assert.equal(read(c).sync.reason,'MANUAL_LOGIN');
|
|
c.health.portal={status:'login_required',checkedAt:at(0)};
|
|
c.sessionActivity={phase:'idle',authentication:'expired',retryAt:now+60000};
|
|
assert.equal(read(c).account.reason,'RENEWAL_COOLDOWN');assert.equal(read(c).account.color,'yellow');
|
|
c.sessionActivity={phase:'paused',authentication:'unknown'};
|
|
assert.equal(read(c).account.status,'paused');assert.equal(read(c).sync.status,'paused');
|
|
});
|