146 lines
11 KiB
Python
146 lines
11 KiB
Python
import json
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
|
|
MODULE = Path(__file__).parents[1] / "frontend" / "human-gates.js"
|
|
INDEX = Path(__file__).parents[1] / "frontend" / "index.html"
|
|
DASHBOARD = Path(__file__).parents[1] / "frontend" / "dashboard.js"
|
|
|
|
|
|
def run_node(body):
|
|
script = f"const createHumanGates=require({json.dumps(str(MODULE))});\n" + body
|
|
result = subprocess.run(["node", "-e", script], check=True, text=True, capture_output=True)
|
|
return json.loads(result.stdout)
|
|
|
|
|
|
def test_queue_loads_pending_count_uses_account_cache_and_renders_inbox_zero():
|
|
output = run_node(r"""
|
|
const values=new Map(); const storage={getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)};
|
|
let response={pending_count:1,items:[{id:'g1',title:'Candidate',candidate_hash:'abc123',priority:4,state:'pending',revision:1,checks:[]}]};
|
|
const nodes={count:{textContent:''},list:{innerHTML:''},status:{textContent:''},panel:{hidden:true}};
|
|
const gates=createHumanGates({storage,getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:''},fetchJson:async()=>response});
|
|
(async()=>{ await gates.load(); const first={snapshot:gates.snapshot(),count:nodes.count.textContent,html:nodes.list.innerHTML,keys:[...values.keys()]}; response={pending_count:0,items:[]}; await gates.load(); process.stdout.write(JSON.stringify({first,zero:{snapshot:gates.snapshot(),status:nodes.status.textContent,html:nodes.list.innerHTML}})); })();
|
|
""")
|
|
assert output["first"]["count"] == "1"
|
|
assert "abc123" in output["first"]["html"]
|
|
assert output["first"]["keys"] == ["stackchain.human-gates.v1:timmy"]
|
|
assert output["zero"]["snapshot"]["pending_count"] == 0
|
|
assert "Inbox zero" in output["zero"]["html"]
|
|
|
|
|
|
def test_review_next_is_a_fixed_snapshot_and_decision_and_next_advances_without_new_arrivals():
|
|
output = run_node(r"""
|
|
const calls=[]; const nodes={count:{textContent:''},list:{innerHTML:''},status:{textContent:''},panel:{hidden:true},detail:{innerHTML:''}};
|
|
const initial={pending_count:2,items:[{id:'old',title:'Old',candidate_hash:'a1',revision:1,checks:[]},{id:'next',title:'Next',candidate_hash:'b2',revision:1,checks:[]}]};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:'#/my-work/human-gates'},fetchJson:async(path,options={})=>{calls.push({path,options}); if(options.method==='POST') return {receipt_id:'r1',state:'released'}; return initial;}});
|
|
(async()=>{await gates.load(); const reviewed=gates.reviewNext(); initial.items.unshift({id:'new',title:'New arrival',candidate_hash:'c3',revision:1,checks:[]}); const result=await gates.decideAndNext('release',{checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}}); process.stdout.write(JSON.stringify({reviewed,result,current:gates.current(),calls,hash:gates.route()}));})();
|
|
""")
|
|
assert output["reviewed"]["id"] == "old"
|
|
assert output["result"]["receipt"]["receipt_id"] == "r1"
|
|
assert output["current"]["id"] == "next"
|
|
assert output["hash"] == "#/my-work/human-gates"
|
|
post = next(call for call in output["calls"] if call["options"].get("method") == "POST")
|
|
assert post["path"] == "api/v1/human-gates/old/decision"
|
|
assert "Idempotency-Key" in post["options"]["headers"]
|
|
|
|
|
|
def test_review_loads_exact_detail_with_links_provenance_and_history():
|
|
output = run_node(r"""
|
|
const detail={id:'g1',title:'Candidate',project:'stackchain/dashboard',candidate_hash:'abc123',revision:1,checks:[{name:'unit',state:'success',required:true}],artifacts:[{name:'manifest',url:'https://forge.example/manifest'}],links:[{label:'pull',url:'https://forge.example/pull/1'}],score:{value:98,provenance:'eval/v1'},provenance:{producer:'bot',run_id:'9'},history:[{action:'intake',at:100}]};
|
|
const nodes={count:{},list:{},status:{},panel:{},detail:{innerHTML:''}};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:''},fetchJson:async path=>path.endsWith('/g1')?detail:{pending_count:1,items:[detail]}});
|
|
(async()=>{await gates.load();gates.reviewNext();await new Promise(resolve=>setTimeout(resolve,0));process.stdout.write(JSON.stringify({html:nodes.detail.innerHTML}));})();
|
|
""")
|
|
assert "stackchain/dashboard" in output["html"]
|
|
assert "https://forge.example/pull/1" in output["html"]
|
|
assert "bot" in output["html"]
|
|
assert "intake" in output["html"]
|
|
|
|
|
|
def test_release_requires_override_for_unmet_required_checks_and_decisions_require_online_identity():
|
|
output = run_node(r"""
|
|
let online=true, login='timmy', posts=0;
|
|
const item={id:'g1',title:'Failing',candidate_hash:'a1',revision:1,checks:[{name:'browser',state:'failure',required:true}]};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=>login,isOnline:()=>online,nodes:{count:{},list:{},status:{},panel:{},detail:{}},location:{hash:''},fetchJson:async(path,options={})=>{if(options.method==='POST'){posts++;return {receipt_id:'r1'}};return {pending_count:1,items:[item]};}});
|
|
(async()=>{await gates.load();gates.reviewNext();let override,offline,identity;try{await gates.decideAndNext('release',{checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}})}catch(e){override=e.message} online=false;try{await gates.decideAndNext('hold',{reason:'wait',checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}})}catch(e){offline=e.message} online=true;login='';try{await gates.decideAndNext('hold',{reason:'wait',checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}})}catch(e){identity=e.message}process.stdout.write(JSON.stringify({override,offline,identity,posts}));})();
|
|
""")
|
|
assert "override reason" in output["override"]
|
|
assert "online" in output["offline"]
|
|
assert "identity" in output["identity"]
|
|
assert output["posts"] == 0
|
|
|
|
|
|
def test_offline_cache_is_scoped_to_immutable_account_identity():
|
|
output = run_node(r"""
|
|
const values=new Map(); const storage={getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)};
|
|
let account='1:timmy'; const nodes={count:{},list:{},status:{},panel:{}};
|
|
const gates=createHumanGates({storage,getLogin:()=> 'timmy',getAccountKey:()=>account,isOnline:()=>true,nodes,location:{hash:''},fetchJson:async()=>({pending_count:1,items:[{id:'g1',title:'Private',candidate_hash:'a1'}]})});
|
|
(async()=>{await gates.load();account='2:timmy';process.stdout.write(JSON.stringify({keys:[...values.keys()],restored:gates.restoreCached()}));})();
|
|
""")
|
|
assert output["keys"] == ["stackchain.human-gates.v1:1:timmy"]
|
|
assert output["restored"] is None
|
|
|
|
|
|
def test_account_switch_clears_in_memory_gate_data_before_failed_load():
|
|
output = run_node(r"""
|
|
const values=new Map(); const storage={getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)};
|
|
let account='1:timmy', fail=false; const nodes={count:{},list:{innerHTML:''},status:{},panel:{}};
|
|
const gates=createHumanGates({storage,getLogin:()=> 'timmy',getAccountKey:()=>account,isOnline:()=>true,nodes,location:{hash:''},fetchJson:async()=>{if(fail)throw new Error('offline');return {pending_count:1,items:[{id:'private-1',title:'Principal 1 private',candidate_hash:'secret'}]}}});
|
|
(async()=>{await gates.load();account='2:timmy';fail=true;try{await gates.load()}catch(_){}process.stdout.write(JSON.stringify({snapshot:gates.snapshot(),html:nodes.list.innerHTML}));})();
|
|
""")
|
|
assert output["snapshot"] == {"pending_count": 0, "items": []}
|
|
assert "Principal 1 private" not in output["html"]
|
|
assert "secret" not in output["html"]
|
|
|
|
|
|
def test_decision_retry_reuses_the_same_idempotency_key():
|
|
output = run_node(r"""
|
|
let attempts=0; const keys=[];
|
|
const item={id:'g1',title:'Candidate',candidate_hash:'a1',revision:1,checks:[]};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes:{count:{},list:{},status:{},panel:{},detail:{}},location:{hash:''},fetchJson:async(path,options={})=>{if(options.method==='POST'){keys.push(options.headers['Idempotency-Key']);attempts++;if(attempts===1)throw new Error('network');return {receipt_id:'r1'}};return {pending_count:1,items:[item]};}});
|
|
(async()=>{await gates.load();gates.reviewNext();const values={reason:'wait',checklist:{}};try{await gates.decideAndNext('hold',values)}catch(_){}await gates.decideAndNext('hold',values);process.stdout.write(JSON.stringify({keys}));})();
|
|
""")
|
|
assert len(output["keys"]) == 2
|
|
assert output["keys"][0] == output["keys"][1]
|
|
|
|
|
|
def test_concurrent_decision_taps_submit_once_and_advance_once():
|
|
output = run_node(r"""
|
|
let posts=0, releasePost; const posted=new Promise(resolve=>releasePost=resolve);
|
|
const items=[{id:'g1',title:'One',candidate_hash:'a1',revision:1,checks:[]},{id:'g2',title:'Two',candidate_hash:'b2',revision:1,checks:[]}];
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes:{count:{},list:{},status:{},panel:{},detail:{}},location:{hash:''},fetchJson:async(path,options={})=>{if(options.method==='POST'){posts++;await posted;return {receipt_id:'r1'}};return {pending_count:2,items};}});
|
|
(async()=>{await gates.load();gates.reviewNext();const values={reason:'wait',checklist:{}};const first=gates.decideAndNext('hold',values);const second=gates.decideAndNext('hold',values);releasePost();await Promise.all([first,second]);process.stdout.write(JSON.stringify({posts,current:gates.current()?.id,snapshot:gates.snapshot()}));})();
|
|
""")
|
|
assert output["posts"] == 1
|
|
assert output["current"] == "g2"
|
|
assert output["snapshot"]["pending_count"] == 1
|
|
assert [item["id"] for item in output["snapshot"]["items"]] == ["g2"]
|
|
|
|
|
|
def test_selecting_a_queue_card_opens_that_exact_gate():
|
|
output = run_node(r"""
|
|
const details={
|
|
g1:{id:'g1',title:'First',project:'p/one',candidate_hash:'a1',revision:1,checks:[]},
|
|
g2:{id:'g2',title:'Second',project:'p/two',candidate_hash:'b2',revision:1,checks:[]},
|
|
};
|
|
const nodes={count:{},list:{},status:{},panel:{},detail:{innerHTML:''}};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:''},fetchJson:async path=>path.includes('/g')?details[path.split('/').pop()]:{pending_count:2,items:Object.values(details)}});
|
|
(async()=>{await gates.load();gates.reviewNext();gates.select('g2');await new Promise(resolve=>setTimeout(resolve,0));process.stdout.write(JSON.stringify({current:gates.current().id,html:nodes.detail.innerHTML}));})();
|
|
""")
|
|
assert output["current"] == "g2"
|
|
assert "Second" in output["html"]
|
|
assert "p/two" in output["html"]
|
|
|
|
|
|
def test_human_gate_mobile_shell_and_deep_route_are_wired():
|
|
index = INDEX.read_text()
|
|
dashboard = DASHBOARD.read_text()
|
|
assert 'id="human-gates"' in index
|
|
assert 'id="human-gates-count"' in index
|
|
assert 'Review next <span id="human-gates-count"' in index
|
|
assert 'static/human-gates.js' in index
|
|
assert "#/my-work/human-gates" in dashboard
|
|
assert "createHumanGates" in dashboard
|
|
assert "planningOwnerAccountKey = confirmedOwnerLogin && saved.user?.id" in dashboard
|