inbox-setup-view.test.ts (7411B)
1 import { inboxResolverCurrentAfterSample } from '../../src/lib/messaging/resolve-inbox.ts'; 2 import { it, expect } from 'vitest'; 3 import { 4 createInboxSetupView, 5 checkInboxSetupView, 6 reviewInboxSetupView, 7 inboxSetupViewSnapshot, 8 stopInboxSetupView, 9 closeInboxSetupView, 10 subscribeInboxSetupView, 11 unlockInboxSetupView 12 } from '../../src/lib/messaging/inbox-setup-view.ts'; 13 import { 14 makeSetupFixture, 15 fixturePolicy, 16 inbox 17 } from '../e2e/harness/inbox-setup.ts'; 18 it('incomplete actual bounded lookup remains unknown, never global absence', async () => { 19 const f = await makeSetupFixture(); 20 const view = createInboxSetupView({ 21 identity: f.identity, 22 policy: fixturePolicy(), 23 lookup: () => Promise.resolve(f.resolve(null, false).resolver), 24 now: () => 101 25 }); 26 try { 27 await checkInboxSetupView(view); 28 const state = inboxSetupViewSnapshot(view); 29 expect(state.status).toBe('lookup_incomplete'); 30 expect(state.currentWire).toBeNull(); 31 expect(state.setupComplete).toBe(false); 32 expect(f.counts().signs).toBe(0); 33 } finally { 34 closeInboxSetupView(view); 35 f.close(); 36 } 37 }); 38 it('exact review preserves unknown entries and displays global effect without signing', async () => { 39 const f = await makeSetupFixture(); 40 const view = createInboxSetupView({ 41 identity: f.identity, 42 policy: fixturePolicy(), 43 lookup: () => Promise.resolve(f.resolve().resolver), 44 now: () => 101 45 }); 46 try { 47 await checkInboxSetupView(view); 48 await reviewInboxSetupView(view, [inbox], [], []); 49 const state = inboxSetupViewSnapshot(view); 50 expect(state.status).toBe('review'); 51 expect(state.preview?.globalEffect).toContain('other clients'); 52 expect(state.preview?.selectedInboxes).toEqual([inbox]); 53 expect( 54 (JSON.parse(state.preview!.wire) as { tags: string[][] }).tags 55 ).toEqual([...f.event.tags, ['relay', inbox]]); 56 expect(f.counts().signs).toBe(0); 57 stopInboxSetupView(view); 58 expect(inboxSetupViewSnapshot(view).preview).toBeUndefined(); 59 expect(inboxSetupViewSnapshot(view).status).toBe('paused'); 60 } finally { 61 closeInboxSetupView(view); 62 f.close(); 63 } 64 }); 65 it('compatible observed configuration offers Unlock without replacing a global preference', async () => { 66 const f = await makeSetupFixture([['relay', inbox]]); 67 const view = createInboxSetupView({ 68 identity: f.identity, 69 policy: fixturePolicy(), 70 lookup: () => Promise.resolve(f.resolve().resolver), 71 now: () => 101 72 }); 73 try { 74 await checkInboxSetupView(view); 75 expect(inboxSetupViewSnapshot(view).status).toBe('compatible'); 76 await reviewInboxSetupView(view, [inbox], [], []); 77 expect(inboxSetupViewSnapshot(view).preview).toBeUndefined(); 78 expect(f.counts().signs).toBe(0); 79 expect(inboxSetupViewSnapshot(view).setupComplete).toBe(false); 80 } finally { 81 closeInboxSetupView(view); 82 f.close(); 83 } 84 }); 85 it('late original lookup cannot restore a stopped panel', async () => { 86 const f = await makeSetupFixture(); 87 let release: (() => void) | undefined; 88 const gate = new Promise<void>((resolve) => { 89 release = resolve; 90 }); 91 const view = createInboxSetupView({ 92 identity: f.identity, 93 policy: fixturePolicy(), 94 lookup: async () => { 95 await gate; 96 return f.resolve().resolver; 97 } 98 }); 99 try { 100 const pending = checkInboxSetupView(view); 101 stopInboxSetupView(view); 102 release?.(); 103 await pending; 104 expect(inboxSetupViewSnapshot(view).status).toBe('paused'); 105 expect(inboxSetupViewSnapshot(view).setupComplete).toBe(false); 106 expect(f.counts().signs).toBe(0); 107 } finally { 108 closeInboxSetupView(view); 109 f.close(); 110 } 111 }); 112 113 it('synchronous checking cancellation prevents lookup from starting', async () => { 114 const f = await makeSetupFixture(); 115 let lookups = 0; 116 const view = createInboxSetupView({ 117 identity: f.identity, 118 policy: fixturePolicy(), 119 lookup: () => { 120 lookups++; 121 return Promise.resolve(f.resolve().resolver); 122 } 123 }); 124 const unsubscribe = subscribeInboxSetupView(view, (state) => { 125 if (state.status === 'checking' && state.busy) stopInboxSetupView(view); 126 }); 127 try { 128 await checkInboxSetupView(view); 129 expect(lookups).toBe(0); 130 expect(inboxSetupViewSnapshot(view).status).toBe('paused'); 131 } finally { 132 unsubscribe(); 133 closeInboxSetupView(view); 134 f.close(); 135 } 136 }); 137 it('synchronous approval cancellation prevents a fresh provider observation', async () => { 138 const f = await makeSetupFixture(); 139 const view = createInboxSetupView({ 140 identity: f.identity, 141 policy: fixturePolicy(), 142 lookup: () => Promise.resolve(f.resolve().resolver) 143 }); 144 const unsubscribe = subscribeInboxSetupView(view, (state) => { 145 if (state.status === 'approval_wait' && state.busy) 146 stopInboxSetupView(view); 147 }); 148 try { 149 const keys = f.counts().keys; 150 await unlockInboxSetupView(view); 151 expect(f.counts().keys).toBe(keys); 152 expect(inboxSetupViewSnapshot(view).status).toBe('paused'); 153 } finally { 154 unsubscribe(); 155 closeInboxSetupView(view); 156 f.close(); 157 } 158 }); 159 it('Not now closes a retained incomplete discovery resolver', async () => { 160 const f = await makeSetupFixture(); 161 const retained = f.resolve(null, false).resolver; 162 const view = createInboxSetupView({ 163 identity: f.identity, 164 policy: fixturePolicy(), 165 lookup: () => Promise.resolve(retained) 166 }); 167 try { 168 await checkInboxSetupView(view); 169 expect(inboxResolverCurrentAfterSample(retained)).toBe(true); 170 stopInboxSetupView(view); 171 expect(inboxResolverCurrentAfterSample(retained)).toBe(false); 172 expect(inboxSetupViewSnapshot(view).status).toBe('paused'); 173 } finally { 174 closeInboxSetupView(view); 175 f.close(); 176 } 177 }); 178 179 it('closing is terminal before notifying observers', async () => { 180 const f = await makeSetupFixture(); 181 let lookups = 0; 182 let notifications = 0; 183 let restarted: Promise<void> | undefined; 184 const view = createInboxSetupView({ 185 identity: f.identity, 186 policy: fixturePolicy(), 187 lookup: () => { 188 lookups++; 189 return Promise.resolve(f.resolve().resolver); 190 } 191 }); 192 const unsubscribe = subscribeInboxSetupView(view, (state) => { 193 notifications++; 194 if (state.status === 'paused' && !state.busy) 195 restarted = checkInboxSetupView(view); 196 }); 197 try { 198 closeInboxSetupView(view); 199 await restarted; 200 expect(lookups).toBe(0); 201 expect(inboxSetupViewSnapshot(view).status).toBe('closed'); 202 const settledNotifications = notifications; 203 closeInboxSetupView(view); 204 expect(notifications).toBe(settledNotifications); 205 } finally { 206 unsubscribe(); 207 f.close(); 208 } 209 }); 210 211 it('closing prevents provider observation from a teardown observer', async () => { 212 const f = await makeSetupFixture(); 213 let restarted: Promise<void> | undefined; 214 const view = createInboxSetupView({ 215 identity: f.identity, 216 policy: fixturePolicy(), 217 lookup: () => Promise.resolve(f.resolve().resolver) 218 }); 219 const unsubscribe = subscribeInboxSetupView(view, (state) => { 220 if (state.status === 'paused' && !state.busy) 221 restarted = unlockInboxSetupView(view); 222 }); 223 try { 224 const keys = f.counts().keys; 225 closeInboxSetupView(view); 226 await restarted; 227 expect(f.counts().keys).toBe(keys); 228 expect(inboxSetupViewSnapshot(view).status).toBe('closed'); 229 } finally { 230 unsubscribe(); 231 f.close(); 232 } 233 });