Files
order-notification-automation/tests/bpm/bpm-session.test.cjs
T

178 lines
13 KiB
JavaScript

const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs/promises');
const os = require('node:os');
const path = require('node:path');
const http = require('node:http');
const { loadPlaywright, browserOptions } = require('../../src/platform/browser.cjs');
const principal = { user: { id: '1', username: 'owner', role: 'operator' }, sessionId: 'dashboard-session' };
const connection = { id: 'a', owner: 'owner', status: 'disconnected' };
const other = { user: { id: '2', username: 'intruder', role: 'operator' }, sessionId: 'other-session' };
const html = `<!doctype html><meta charset="utf-8"><input id="name" style="position:absolute;left:10px;top:10px;width:200px;height:30px"><button style="position:absolute;left:10px;top:60px" onclick="login()">登录</button><div id="status"></div><script>
const dbp=new Promise((resolve,reject)=>{const r=indexedDB.open('auth',1);r.onupgradeneeded=()=>r.result.createObjectStore('tokens');r.onsuccess=()=>resolve(r.result);r.onerror=reject});
async function login(){const db=await dbp;await new Promise(r=>{const t=db.transaction('tokens','readwrite');t.objectStore('tokens').put('idb-token','token');t.oncomplete=r});document.cookie='auth=yes; path=/';localStorage.setItem('auth','local-token');sessionStorage.setItem('auth','session-token');location.reload()}
(async()=>{const db=await dbp;const token=await new Promise(r=>{const q=db.transaction('tokens').objectStore('tokens').get('token');q.onsuccess=()=>r(q.result)});if(document.cookie.includes('auth=yes')&&localStorage.getItem('auth')==='local-token'&&sessionStorage.getItem('auth')==='session-token'&&token==='idb-token'){document.querySelector('#status').innerHTML='<a class="yz-btn-signinuser"><span class="x-btn-inner">Fixture User</span></a>'}})();
</script>`;
async function fixture(t) {
const { BpmSessionManager } = require('../../src/modules/bpm/session-manager.cjs');
const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'bpm-browser-'));
let blockedHits = 0;const requests=[];
const forbidden = http.createServer((req,res) => { blockedHits++; res.end('forbidden'); });
await new Promise(resolve => forbidden.listen(0, '127.0.0.1', resolve));
const badOrigin = `http://127.0.0.1:${forbidden.address().port}`;
const server = http.createServer((req,res) => {
requests.push(req.url);
if (req.url === '/escape-chain') { res.writeHead(302, { Location: '/escape' }); res.end(); return; }
if (req.url === '/escape') { res.writeHead(302, { Location: badOrigin }); res.end(); return; }
res.setHeader('content-type','text/html; charset=utf-8'); res.end(html+(req.url==='/iframe'?`<iframe src="${badOrigin}/tracking"></iframe>`:''));
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
const origin = `http://127.0.0.1:${server.address().port}`;
const browser = await loadPlaywright().chromium.launch(browserOptions());
const options = { stateDir: dir, browserFactory: async () => browser, urls: { main: origin + '/main' }, allowedOrigins: [origin],
probe: async page => { const marker = page.locator('a.yz-btn-signinuser .x-btn-inner'); await marker.waitFor({timeout:1000}).catch(()=>{}); return { ok: await marker.count() > 0, identity: (await marker.allTextContents())[0] || '' }; } };
const manager = new BpmSessionManager(options);
const managers=[manager],make=overrides=>{const next=new BpmSessionManager({...options,...overrides});managers.push(next);return next;};
t.after(async () => { for(const item of managers)await item.shutdown(); await browser.close(); await Promise.all([new Promise(r=>server.close(r)),new Promise(r=>forbidden.close(r))]); await fs.rm(dir,{recursive:true,force:true}); });
return { manager, options, make, browser, origin, badOrigin, requests, blockedHits:()=>blockedHits };
}
test('real browser login saves encrypted full state, restores after shutdown and isolates connections', async t => {
const { manager, make } = await fixture(t);
const opened = await manager.open(connection,principal);
assert.equal(opened.active,true); assert.deepEqual(opened.viewport,{width:1280,height:800});
const jpeg = await manager.frame('a',principal); assert.equal(jpeg.readUInt16BE(0),0xffd8);
assert.equal((await manager.save(connection,principal)).status,'login_required');
await manager.input('a',principal,{type:'click',x:50,y:25});
await manager.input('a',principal,{type:'text',text:'Not persisted password'});
await manager.input('a',principal,{type:'click',x:30,y:70});
await new Promise(r=>setTimeout(r,300));
const saved = await manager.save(connection,principal);
assert.equal(saved.status,'connected'); assert.equal(saved.identity,'Fixture User');
assert.equal(saved.checks.portal.ok,true); assert.deepEqual(Object.keys(saved.checks),['portal']);
await manager.open({...connection,id:'b'},principal);
assert.equal((await manager.check({...connection,id:'b'},principal)).status,'login_required');
// An unsuccessful verification must leave the last good encrypted state intact.
const lease = manager.sessions.get('a'); await lease.context.clearCookies();
assert.equal((await manager.save(connection,principal)).status,'login_required');
await manager.shutdown();
const restarted = make({browserFactory:undefined});
assert.equal((await restarted.check(connection,principal)).status,'connected');
});
test('session lease enforces owner, dashboard exclusivity, limits, TTL and logout cleanup', async t => {
const { manager } = await fixture(t);
await assert.rejects(manager.open(connection,other),e=>e.status===403);
await manager.open(connection,principal);
await assert.rejects(manager.frame('a',{...principal,sessionId:'different-login'}),e=>e.status===409);
await assert.rejects(manager.frame('a',other),e=>e.status===403);
await manager.open({...connection,id:'b'},principal); await manager.open({...connection,id:'c'},principal);
await assert.rejects(manager.open({...connection,id:'d'},principal),e=>e.status===429);
manager.sessions.get('a').expiresAt=Date.now()-1;
await assert.rejects(manager.frame('a',principal),e=>e.status===410);
assert.equal(manager.sessions.has('a'),false);
await manager.releaseSession(principal.sessionId); assert.equal(manager.sessions.size,0);
});
test('bounded inputs and navigation reject arbitrary origins and scripts before any request', async t => {
const { manager, origin, blockedHits } = await fixture(t);
await manager.open(connection,principal);
for (const action of [{type:'text',text:'x'.repeat(2001)},{type:'key',key:'Control+L'},{type:'click',x:-1,y:2},{type:'scroll',deltaY:Infinity,deltaX:0},{type:'evaluate',script:'alert(1)'}]) {
await assert.rejects(manager.input('a',principal,action),e=>e.status===400);
}
await assert.rejects(manager.navigate('a',principal,{target:'https://example.com'}),e=>e.status===400);
const lease=manager.sessions.get('a');
await lease.page.goto(origin+'/escape-chain').catch(()=>{});
assert.equal(blockedHits(),0);
await assert.rejects(manager.frame('a',principal),e=>e.status===403);
await manager.close('a',principal);
assert.equal(manager.sessions.has('a'),false);
});
test('positive new BPM login alone reports connected and never requests a legacy entry', async t => {
const { manager, origin, requests } = await fixture(t);
await manager.open(connection,principal);
await manager.sessions.get('a').page.route(origin+'/main',route=>route.fulfill({contentType:'text/html',body:'<a class="yz-btn-signinuser"><span class="x-btn-inner">Fixture User</span></a>'}));
const result=await manager.save(connection,principal);
assert.equal(result.status,'connected');
assert.equal(result.checks.portal.ok,true);
assert.deepEqual(Object.keys(result.checks),['portal']);
assert.equal(requests.includes('/detail'),false);
assert.ok(await manager.vault().read('a'));
});
test('legacy detail navigation is rejected before any request',async t=>{
const {manager,requests}=await fixture(t);await manager.open(connection,principal);
await assert.rejects(manager.navigate('a',principal,{target:'detail'}),error=>error.status===400);
assert.equal(requests.includes('/detail'),false);
});
test('production origin policy permits verified company SSO but rejects lookalikes and arbitrary injections', async t => {
const { BpmSessionManager } = require('../../src/modules/bpm/session-manager.cjs');
const dir=await fs.mkdtemp(path.join(os.tmpdir(),'bpm-origin-'));
t.after(()=>fs.rm(dir,{recursive:true,force:true}));
const manager=new BpmSessionManager({stateDir:dir}); t.after(()=>manager.shutdown());
assert.equal(manager.allowed('https://sso.skyworthdigital.com/realms/skyworth/protocol/openid-connect/auth'),true);
for (const url of ['https://bpm.skyworthdigital.com/','http://sso.skyworthdigital.com/','https://sso.skyworthdigital.com.evil.example/','https://evil.example/','file:///C:/Windows/win.ini']) assert.equal(manager.allowed(url),false);
assert.throws(()=>new BpmSessionManager({stateDir:dir,allowedOrigins:['https://evil.example']}),e=>e.status===400);
assert.throws(()=>new BpmSessionManager({stateDir:dir,urls:{main:'https://bpmn.skyworthdigital.com/',detail:'https://bpm.skyworthdigital.com/'}}),e=>e.status===400);
});
test('blocked external iframe and popup make no external request and preserve usable login frame', async t => {
const {manager,origin,blockedHits}=await fixture(t);
await manager.open(connection,principal);
const lease=manager.sessions.get('a');
await lease.page.goto(origin+'/iframe',{waitUntil:'domcontentloaded'});
await lease.page.evaluate(url=>window.open(url,'_blank'),origin+'/escape-chain');
await new Promise(resolve=>setTimeout(resolve,200));
assert.equal(blockedHits(),0);
assert.equal((await manager.frame('a',principal)).readUInt16BE(0),0xffd8);
assert.equal((await manager.check(connection,principal)).status,'login_required');
});
test('concurrent startup never exceeds three contexts and disabling in flight closes and prevents reopening', async t => {
const {manager,browser}=await fixture(t);
const results=await Promise.allSettled(['a','b','c','d','e'].map(id=>manager.open({...connection,id},principal)));
assert.equal(results.filter(result=>result.status==='fulfilled').length,3);
assert.equal(browser.contexts().length,3);
await manager.releaseSession(principal.sessionId);
assert.equal(browser.contexts().length,0);
const nextPrincipal={...principal,sessionId:'new-dashboard-session-after-logout'};
const opening=manager.open(connection,nextPrincipal);
const disabling=manager.disable('a');
await Promise.allSettled([opening,disabling]);
assert.equal(browser.contexts().length,0);
await assert.rejects(manager.open(connection,nextPrincipal),e=>e.status===409);
await manager.shutdown();
await assert.rejects(manager.open({...connection,id:'b'},nextPrincipal),e=>e.status===503);
});
test('immediate save after remote login Enter waits for pending login navigation and verifies the portal', async t => {
const {manager,origin}=await fixture(t);
await manager.open(connection,principal);
const lease=manager.sessions.get('a');
await lease.page.route(origin+'/pending-login',async route=>{
await route.fulfill({contentType:'text/html',body:`<form onsubmit="event.preventDefault();document.cookie='auth=yes; path=/';localStorage.setItem('auth','local-token');sessionStorage.setItem('auth','session-token');location.href='/main'"><input autofocus><button>Login</button></form><script>const r=indexedDB.open('auth',1);r.onupgradeneeded=()=>r.result.createObjectStore('tokens');r.onsuccess=()=>{const t=r.result.transaction('tokens','readwrite');t.objectStore('tokens').put('idb-token','token')};</script>`});
});
await lease.page.goto(origin+'/pending-login');
await lease.page.locator('input').focus();
await manager.input('a',principal,{type:'key',key:'Enter'});
assert.equal((await manager.save(connection,principal)).status,'connected');
});
test('login verification waits for the document but does not wait for a stalled portal image',async t=>{
const {manager,origin}=await fixture(t);await manager.open(connection,principal);const lease=manager.sessions.get('a');
let release;const pending=new Promise(resolve=>{release=resolve;});
await lease.page.route(origin+'/pending-image',async route=>{await pending;await route.fulfill({status:204}).catch(()=>{});});
await lease.page.route(origin+'/main',route=>route.fulfill({contentType:'text/html',body:'<a class="yz-btn-signinuser"><span class="x-btn-inner">Fixture User</span></a><img src="/pending-image">'}));
try{await lease.page.goto(origin+'/main',{waitUntil:'domcontentloaded'});assert.equal((await manager.save(connection,principal)).status,'connected');}
finally{release();}
});
test('portal identity rendered after four seconds is recognized as logged in',async t=>{
const {manager}=await fixture(t);await manager.open(connection,principal);const page=manager.sessions.get('a').page;
await page.setContent('<main>Loading</main><script>setTimeout(()=>{document.body.innerHTML=\'<a class="yz-btn-signinuser"><span class="x-btn-inner">Fixture User</span></a>\'},4500)</script>');
assert.deepEqual(await manager.defaultProbe(page),{ok:true,identity:'Fixture User'});
});