257 lines
12 KiB
Python
257 lines
12 KiB
Python
import json
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from tests.dashboard_bundle import dashboard
|
|
|
|
|
|
OUTBOX = Path(__file__).parents[1] / "frontend" / "authored-outbox.js"
|
|
|
|
|
|
def run_node(script: str):
|
|
result = subprocess.run(["node", "-e", script], check=True, capture_output=True, text=True)
|
|
return json.loads(result.stdout)
|
|
|
|
|
|
def test_authored_outbox_quarantines_legacy_and_cross_account_messages():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map([['stackchain.authored-outbox.v1', JSON.stringify({{version:1,items:[
|
|
{{id:'legacy',operationId:'legacy',kind:'issue-comment',repository:'o/r',number:1,body:'Old',status:'queued'}}
|
|
]}})]]);
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
|
|
const calls = [];
|
|
const outbox = createAuthoredOutbox({{
|
|
storage, getOwnerLogin:()=>'timmy',
|
|
fetchJson:async url => {{calls.push(url); return {{id:1}};}},
|
|
}});
|
|
const bound = outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:2,body:'Mine',operationId:'mine'}});
|
|
(async()=>{{
|
|
const wrong = await outbox.flush('alexander');
|
|
const right = await outbox.flush('timmy');
|
|
process.stdout.write(JSON.stringify({{bound,wrong,right,calls,remaining:outbox.list()}}));
|
|
}})();
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert output["bound"]["ownerLogin"] == "timmy"
|
|
assert output["wrong"]["blocked"] == 2
|
|
assert len(output["right"]["confirmed"]) == 1
|
|
assert [item["id"] for item in output["remaining"]] == ["legacy"]
|
|
assert len(output["calls"]) == 1
|
|
|
|
|
|
def test_authored_outbox_persists_each_message_kind_and_flushes_sequentially():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map();
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v),removeItem:k=>values.delete(k)}};
|
|
const calls = [];
|
|
const outbox = createAuthoredOutbox({{
|
|
storage, getOwnerLogin:()=>'timmy', now:() => 1234,
|
|
fetchJson:async (url, options) => {{
|
|
calls.push({{url,key:options.headers['Idempotency-Key'],body:JSON.parse(options.body)}});
|
|
return {{id:calls.length}};
|
|
}},
|
|
}});
|
|
outbox.enqueue({{kind:'issue-comment',repository:'stackchain/api',number:7,body:'Issue note',operationId:'issue-op'}});
|
|
outbox.enqueue({{kind:'pull-comment',repository:'stackchain/web',number:8,body:'PR note',operationId:'pull-op'}});
|
|
outbox.enqueue({{kind:'update-reply',notificationId:9,body:'Update note',operationId:'update-op'}});
|
|
const persisted = createAuthoredOutbox({{storage,fetchJson:outbox.fetchJson}}).list();
|
|
outbox.flush('timmy').then(result => process.stdout.write(JSON.stringify({{persisted,calls,result,remaining:outbox.list()}})));
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert [item["kind"] for item in output["persisted"]] == [
|
|
"issue-comment", "pull-comment", "update-reply"
|
|
]
|
|
assert [item["operationId"] for item in output["persisted"]] == ["issue-op", "pull-op", "update-op"]
|
|
assert output["calls"] == [
|
|
{"url": "api/v1/repos/stackchain/api/issues/7/comments", "key": "issue-op", "body": {"body": "Issue note"}},
|
|
{"url": "api/v1/repos/stackchain/web/pulls/8/comments", "key": "pull-op", "body": {"body": "PR note"}},
|
|
{"url": "api/v1/notifications/9/reply", "key": "update-op", "body": {"body": "Update note"}},
|
|
]
|
|
assert len(output["result"]["confirmed"]) == 3
|
|
assert output["remaining"] == []
|
|
|
|
|
|
def test_authored_outbox_classifies_failures_and_continues_past_attention_items():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map();
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v),removeItem:k=>values.delete(k)}};
|
|
let phase = 'permanent';
|
|
const calls = [];
|
|
const outbox = createAuthoredOutbox({{
|
|
storage,
|
|
getOwnerLogin:()=>'timmy',
|
|
fetchJson:async (_url, options) => {{
|
|
const body = JSON.parse(options.body).body; calls.push(body);
|
|
if (body === 'Bad' && phase === 'permanent') {{ const e = new Error('Reply rejected'); e.status=422; throw e; }}
|
|
if (body === 'Later' && phase === 'transient') {{ const e = new Error('Offline'); e.status=503; throw e; }}
|
|
return {{id:calls.length}};
|
|
}},
|
|
}});
|
|
const bad=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Bad',operationId:'a'}});
|
|
outbox.enqueue({{kind:'pull-comment',repository:'o/r',number:2,body:'Good',operationId:'b'}});
|
|
outbox.flush('timmy').then(async first => {{
|
|
phase='transient';
|
|
outbox.enqueue({{kind:'update-reply',notificationId:3,body:'Later',operationId:'c'}});
|
|
const second=await outbox.flush('timmy');
|
|
process.stdout.write(JSON.stringify({{first,second,calls,remaining:outbox.list(),badId:bad.id}}));
|
|
}});
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert output["calls"] == ["Bad", "Good", "Later"]
|
|
assert len(output["first"]["confirmed"]) == 1
|
|
assert output["remaining"][0]["id"] == output["badId"]
|
|
assert output["remaining"][0]["status"] == "attention"
|
|
assert output["remaining"][0]["error"] == "Reply rejected"
|
|
assert output["remaining"][1]["status"] == "queued"
|
|
|
|
|
|
def test_authored_outbox_retry_is_single_flight_and_edit_rotates_identity():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map();
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v),removeItem:k=>values.delete(k)}};
|
|
let release; const gate=new Promise(resolve=>release=resolve); let calls=0; let sequence=0;
|
|
const outbox=createAuthoredOutbox({{
|
|
storage, getOwnerLogin:()=>'timmy', createOperationId:()=> 'new-' + (++sequence),
|
|
fetchJson:async()=>{{calls++; await gate; return {{id:1}};}},
|
|
}});
|
|
const item=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Old',operationId:'old'}});
|
|
const edited=outbox.update(item.id,{{body:'New'}});
|
|
const flush=outbox.flush('timmy'); const retry=outbox.retry(item.id, 'timmy'); release();
|
|
Promise.all([flush,retry]).then(results=>process.stdout.write(JSON.stringify({{edited,calls,results,remaining:outbox.list()}})));
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert output["edited"]["body"] == "New"
|
|
assert output["edited"]["operationId"] == "new-1"
|
|
assert output["calls"] == 1
|
|
assert output["remaining"] == []
|
|
|
|
|
|
def test_authored_outbox_deduplicates_repeated_queue_attempts_by_operation_id():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map();
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
|
|
const outbox=createAuthoredOutbox({{storage,getOwnerLogin:()=>'timmy'}});
|
|
const first=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Same',operationId:'stable'}});
|
|
const second=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Same',operationId:'stable'}});
|
|
process.stdout.write(JSON.stringify({{first,second,items:outbox.list()}}));
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert output["first"] == output["second"]
|
|
assert len(output["items"]) == 1
|
|
|
|
|
|
def test_authored_outbox_mirrors_to_background_sync_and_reconciles_worker_results():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map(); const mirrors=[]; let requested=0;
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
|
|
const backgroundSync = {{
|
|
reconcile: async (items, lane) => mirrors.push({{items:items.map(item=>({{...item}})),lane}}),
|
|
requestSync: async () => {{requested += 1;}},
|
|
}};
|
|
const outbox=createAuthoredOutbox({{storage,getOwnerLogin:()=>'timmy',backgroundSync}});
|
|
const sent=outbox.enqueue({{kind:'issue-comment',repository:'o/r',number:1,body:'Sent',operationId:'sent'}});
|
|
const failed=outbox.enqueue({{kind:'update-reply',notificationId:2,body:'Fix me',operationId:'failed'}});
|
|
setTimeout(() => {{
|
|
const reconciled=outbox.reconcileBackground([
|
|
{{...sent,status:'sent'}},
|
|
{{...failed,status:'attention',error:'Reply rejected'}},
|
|
]);
|
|
setTimeout(() => process.stdout.write(JSON.stringify({{mirrors,requested,reconciled}})), 0);
|
|
}}, 0);
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert output["mirrors"][0]["lane"] == "authored"
|
|
assert [item["operationId"] for item in output["mirrors"][-1]["items"]] == ["failed"]
|
|
assert output["requested"] >= 1
|
|
assert [(item["operationId"], item["status"]) for item in output["reconciled"]] == [
|
|
("failed", "attention")
|
|
]
|
|
|
|
|
|
def test_authored_outbox_waits_for_durable_background_admission():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map();
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
|
|
let release; const gate = new Promise(resolve => release = resolve); const events = [];
|
|
const outbox = createAuthoredOutbox({{
|
|
storage, getOwnerLogin:()=> 'timmy',
|
|
backgroundSync: {{
|
|
reconcile: async (_items, lane) => {{ events.push('mirror:' + lane); await gate; events.push('committed'); }},
|
|
requestSync: async () => events.push('registered'),
|
|
}},
|
|
}});
|
|
const admission = outbox.enqueueDurably({{
|
|
kind:'issue-comment',repository:'o/r',number:1,body:'Do not lose',operationId:'message-1'
|
|
}}).then(result => {{ events.push('confirmed'); return result; }});
|
|
Promise.resolve().then(async () => {{
|
|
const pending = events.slice(); release(); const result = await admission;
|
|
process.stdout.write(JSON.stringify({{pending,events,result,items:outbox.list()}}));
|
|
}});
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert output["pending"] == ["mirror:authored"]
|
|
assert output["events"] == ["mirror:authored", "committed", "registered", "confirmed"]
|
|
assert output["result"]["durability"] == "background"
|
|
assert output["items"][0]["operationId"] == "message-1"
|
|
|
|
|
|
def test_authored_outbox_foreground_send_uses_atomic_background_delivery():
|
|
script = f"""
|
|
const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
|
|
const values = new Map(); let backgroundCalls=0; let directCalls=0;
|
|
const storage = {{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
|
|
const backgroundSync = {{
|
|
reconcile: async()=>{{}}, requestSync:async()=>{{}},
|
|
send: async (item, owner) => {{backgroundCalls += 1; return {{message:{{id:3,owner}}}};}},
|
|
}};
|
|
const outbox=createAuthoredOutbox({{
|
|
storage,getOwnerLogin:()=>'timmy',backgroundSync,
|
|
fetchJson:async()=>{{directCalls += 1; return {{id:4}};}},
|
|
}});
|
|
outbox.enqueue({{kind:'pull-comment',repository:'o/r',number:2,body:'Review',operationId:'once'}});
|
|
(async()=>{{
|
|
const result=await outbox.flush('timmy');
|
|
process.stdout.write(JSON.stringify({{backgroundCalls,directCalls,result,remaining:outbox.list()}}));
|
|
}})();
|
|
"""
|
|
output = run_node(script)
|
|
|
|
assert output["backgroundCalls"] == 1
|
|
assert output["directCalls"] == 0
|
|
assert output["result"]["confirmed"] == [{"id": 3, "owner": "timmy"}]
|
|
assert output["remaining"] == []
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_mobile_dashboard_loads_and_operates_authored_message_outbox():
|
|
html = await dashboard()
|
|
|
|
assert '<script src="static/authored-outbox.js"></script>' in html
|
|
assert "const authoredOutbox = createAuthoredOutbox({" in html
|
|
assert "activeFlushLogin = contextIdentityFresh ?" in html
|
|
assert "flushAuthoredOutbox();" in html
|
|
assert "await authoredOutbox.enqueueDurably" in html
|
|
assert "Saving for background delivery…" in html
|
|
assert "Saved for next launch; background delivery unavailable." in html
|
|
assert "authoredOutbox.retry(item.outbox_id, activeFlushLogin)" in html
|
|
assert "authoredOutbox.discard(item.outbox_id)" in html
|
|
assert "if (result?.queued)" in html
|
|
assert "backgroundSync: backgroundIssueSync" in html
|
|
assert "authoredOutbox.reconcileBackground(records)" in html
|