bun test v1.4.4 (38afee6c8)

student-tests/sealed-shutdown.test.ts:
(pass) fresh running processes with post-seal cause and exit prove all three shutdowns [1.58ms]
 8 |  const stopped={api1:true,api2:true,worker:true};let replaced=false,initialRunning=true,readError:Error|null=null,readDelay=0;
 9 |  const ports:SealedPorts={inspect:async(service,id)=>({id:sealed&&replaced?"f".repeat(64):ids[service],running:sealed?!stopped[service]:initialRunning,restarts:sealed&&stopped[service]?1:0}),readFreshness:async(service)=>{if(readError)throw readError;now+=readDelay;return fresh[service];},readEvents:async(id,since)=>{calls.push("events");const service=sealedServices.find(s=>ids[s]===id)!;return events[service];},seal:async()=>{calls.push("seal");sealed=true;},now:()=>now,sleep:async(ms)=>{now+=ms;}};
10 |  return {ports,calls,fresh,events,stopped,setReplaced:()=>{replaced=true;},setInitialStopped:()=>{initialRunning=false;},setReadError:(e:Error)=>{readError=e;},setReadDelay:(ms:number)=>{readDelay=ms;},run:()=>createSealedShutdown(ports,{maxAgeMilliseconds:1000,deadlineMilliseconds:10,pollMilliseconds:1})()};
11 | }
12 | test("fresh running processes with post-seal cause and exit prove all three shutdowns",async()=>{const f=fixture(),r=await f.run();expect(Object.keys(r.observed).sort()).toEqual([...sealedServices].sort());expect(r.observed.worker?.event).toBe("secret_freshness_failed");});
13 | test("unrelated restart without freshness cause cannot pass sealed acceptance",async()=>{const f=fixture();f.events.worker=[];await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
                                                                                                                                                                 ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:13:157)
(fail) unrelated restart without freshness cause cannot pass sealed acceptance [1.39ms]
 9 |  const ports:SealedPorts={inspect:async(service,id)=>({id:sealed&&replaced?"f".repeat(64):ids[service],running:sealed?!stopped[service]:initialRunning,restarts:sealed&&stopped[service]?1:0}),readFreshness:async(service)=>{if(readError)throw readError;now+=readDelay;return fresh[service];},readEvents:async(id,since)=>{calls.push("events");const service=sealedServices.find(s=>ids[s]===id)!;return events[service];},seal:async()=>{calls.push("seal");sealed=true;},now:()=>now,sleep:async(ms)=>{now+=ms;}};
10 |  return {ports,calls,fresh,events,stopped,setReplaced:()=>{replaced=true;},setInitialStopped:()=>{initialRunning=false;},setReadError:(e:Error)=>{readError=e;},setReadDelay:(ms:number)=>{readDelay=ms;},run:()=>createSealedShutdown(ports,{maxAgeMilliseconds:1000,deadlineMilliseconds:10,pollMilliseconds:1})()};
11 | }
12 | test("fresh running processes with post-seal cause and exit prove all three shutdowns",async()=>{const f=fixture(),r=await f.run();expect(Object.keys(r.observed).sort()).toEqual([...sealedServices].sort());expect(r.observed.worker?.event).toBe("secret_freshness_failed");});
13 | test("unrelated restart without freshness cause cannot pass sealed acceptance",async()=>{const f=fixture();f.events.worker=[];await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
                                                                                                                                                                     ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:14:161)
(fail) old pre-seal events cannot explain a later unrelated restart [0.57ms]
10 |  return {ports,calls,fresh,events,stopped,setReplaced:()=>{replaced=true;},setInitialStopped:()=>{initialRunning=false;},setReadError:(e:Error)=>{readError=e;},setReadDelay:(ms:number)=>{readDelay=ms;},run:()=>createSealedShutdown(ports,{maxAgeMilliseconds:1000,deadlineMilliseconds:10,pollMilliseconds:1})()};
11 | }
12 | test("fresh running processes with post-seal cause and exit prove all three shutdowns",async()=>{const f=fixture(),r=await f.run();expect(Object.keys(r.observed).sort()).toEqual([...sealedServices].sort());expect(r.observed.worker?.event).toBe("secret_freshness_failed");});
13 | test("unrelated restart without freshness cause cannot pass sealed acceptance",async()=>{const f=fixture();f.events.worker=[];await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
                                                                                                                                                 ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:15:141)
(fail) future cause events are not accepted [0.13ms]
(pass) cause event alone does not prove process exit or restart [0.08ms]
12 | test("fresh running processes with post-seal cause and exit prove all three shutdowns",async()=>{const f=fixture(),r=await f.run();expect(Object.keys(r.observed).sort()).toEqual([...sealedServices].sort());expect(r.observed.worker?.event).toBe("secret_freshness_failed");});
13 | test("unrelated restart without freshness cause cannot pass sealed acceptance",async()=>{const f=fixture();f.events.worker=[];await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
                                                                                                                                                                                                                                                                                                     ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:17:289)
(fail) malformed baseline freshness fails before seal [0.18ms]
12 | test("fresh running processes with post-seal cause and exit prove all three shutdowns",async()=>{const f=fixture(),r=await f.run();expect(Object.keys(r.observed).sort()).toEqual([...sealedServices].sort());expect(r.observed.worker?.event).toBe("secret_freshness_failed");});
13 | test("unrelated restart without freshness cause cannot pass sealed acceptance",async()=>{const f=fixture();f.events.worker=[];await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
                                                                                                                                                                                                                                                                                                     ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:17:289)
(fail) future baseline freshness fails before seal [0.27ms]
12 | test("fresh running processes with post-seal cause and exit prove all three shutdowns",async()=>{const f=fixture(),r=await f.run();expect(Object.keys(r.observed).sort()).toEqual([...sealedServices].sort());expect(r.observed.worker?.event).toBe("secret_freshness_failed");});
13 | test("unrelated restart without freshness cause cannot pass sealed acceptance",async()=>{const f=fixture();f.events.worker=[];await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
                                                                                                                                                                                                                                                                                                     ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:17:289)
(fail) stale baseline freshness fails before seal [0.11ms]
13 | test("unrelated restart without freshness cause cannot pass sealed acceptance",async()=>{const f=fixture();f.events.worker=[];await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
18 | test("all baseline processes must be running before seal",async()=>{const f=fixture();f.setInitialStopped();await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_RUNNING");expect(f.calls).not.toContain("seal");});
                                                                                                                                               ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:18:139)
(fail) all baseline processes must be running before seal [0.10ms]
14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
18 | test("all baseline processes must be running before seal",async()=>{const f=fixture();f.setInitialStopped();await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_RUNNING");expect(f.calls).not.toContain("seal");});
19 | test("freshness read I/O error preserves its primary identity and never seals",async()=>{const f=fixture(),e=new Error("FIXTURE_READ_FAILED");f.setReadError(e);let actual:unknown;try{await f.run();}catch(error){actual=error;}expect(actual).toBe(e);expect(f.calls).not.toContain("seal");});
                                                                                                                                                                                                                                                     ^
error: expect(received).toBe(expected)

Expected: 14 | test("old pre-seal events cannot explain a later unrelated restart",async()=>{const f=fixture();f.events.worker[0].milliseconds--;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
18 | test("all baseline processes must be running before seal",async()=>{const f=fixture();f.setInitialStopped();await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_RUNNING");expect(f.calls).not.toContain("seal");});
19 | test("freshness read I/O error preserves its primary identity and never seals",async()=>{const f=fixture(),e=new Error("FIXTURE_READ_FAILED");f.setReadError(e);let actual:unknown;try{await f.run();}catch(error){actual=error;}expect(actual).toBe(e);expect(f.calls).not.toContain("seal");});
                                                                                                                      ^
error: FIXTURE_READ_FAILED
      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:19:114)

Received: undefined

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:19:241)
(fail) freshness read I/O error preserves its primary identity and never seals [0.14ms]
15 | test("future cause events are not accepted",async()=>{const f=fixture();f.events.worker[0].milliseconds+=1000;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
18 | test("all baseline processes must be running before seal",async()=>{const f=fixture();f.setInitialStopped();await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_RUNNING");expect(f.calls).not.toContain("seal");});
19 | test("freshness read I/O error preserves its primary identity and never seals",async()=>{const f=fixture(),e=new Error("FIXTURE_READ_FAILED");f.setReadError(e);let actual:unknown;try{await f.run();}catch(error){actual=error;}expect(actual).toBe(e);expect(f.calls).not.toContain("seal");});
20 | test("baseline ages are rechecked after reads immediately before sealing",async()=>{const f=fixture();f.setReadDelay(400);await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
                                                                                                                                                             ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:20:153)
(fail) baseline ages are rechecked after reads immediately before sealing [0.50ms]
16 | test("cause event alone does not prove process exit or restart",async()=>{const f=fixture();f.stopped.worker=false;await expect(f.run()).rejects.toThrow("SEALED_CAUSAL_SHUTDOWN_NOT_PROVED");});
17 | test.each([{name:"malformed",value:"invalid"},{name:"future",value:new Date(1_000_001).toISOString()},{name:"stale",value:new Date(998_999).toISOString()}])("$name baseline freshness fails before seal",async({value})=>{const f=fixture();f.fresh.worker=value;await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
18 | test("all baseline processes must be running before seal",async()=>{const f=fixture();f.setInitialStopped();await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_RUNNING");expect(f.calls).not.toContain("seal");});
19 | test("freshness read I/O error preserves its primary identity and never seals",async()=>{const f=fixture(),e=new Error("FIXTURE_READ_FAILED");f.setReadError(e);let actual:unknown;try{await f.run();}catch(error){actual=error;}expect(actual).toBe(e);expect(f.calls).not.toContain("seal");});
20 | test("baseline ages are rechecked after reads immediately before sealing",async()=>{const f=fixture();f.setReadDelay(400);await expect(f.run()).rejects.toThrow("SEALED_BASELINE_NOT_FRESH");expect(f.calls).not.toContain("seal");});
21 | test("a replaced container cannot satisfy the original process baseline",async()=>{const f=fixture();f.setReplaced();await expect(f.run()).rejects.toThrow("SEALED_CONTAINER_CHANGED");});
                                                                                                                                                        ^
error: expect(received).rejects.toThrow(expected)

Expected promise that rejects
Received promise that resolved: Promise { <resolved> }

      at <anonymous> (/Users/rey/mtuci/vp/lab7/student-tests/sealed-shutdown.test.ts:21:148)
(fail) a replaced container cannot satisfy the original process baseline [0.06ms]

 2 pass
 10 fail
 13 expect() calls
Ran 12 tests across 1 file. [24.00ms]
