notes

17.7 KB

1. // tests/short-id-switch.mjs — THE SHORT-ID SWITCH GATE of notes.worldapi.org (mission 039, ident#23), all over HTTP, no browser:
2. // 1. the OLD ident (the pre-ident#23 build, a copy of its code: OLD_IDENT_DIR, default
3. // ident.worldapi.org/.scratch/pre-023-ident) + this app on a fresh store: alice (Default AND a second identity
4. // "Work") and bob log in and make data; alice's "Work" identity is deleted in ident afterwards;
5. // 2. both stop; the ident store and the app store are COPIED (the originals stay as they were);
6. // 3. the NEW ident (ident#23's dev build, a copy of ident.worldapi.org's code: NEW_IDENT_DIR) on the ident copy;
7. // 4. CONTROL: the app on an UNMIGRATED copy → alice comes back as a NEW user (why the migration is needed);
8. // 5. tools/migrate-short-ids.hl on the other copy, TWICE: counts; the second run changes nothing;
9. // 6. the app on the migrated copy with the new ident: alice's OLD app session still works; a fresh login through the
10. // new ident finds the SAME user with the SAME data; bob too; nobody sees the other's data.
11. // Ports 8720, 8721 (ident, app). Work dir .scratch/m039-switch (wiped at start). Every process started is stopped by PID.
12. // node tests/short-id-switch.mjs
14. import { spawn, execFileSync } from 'node:child_process';
15. import { cpSync, mkdirSync, readFileSync, rmSync, existsSync, writeFileSync } from 'node:fs';
16. import { dirname, join, resolve } from 'node:path';
17. import { fileURLToPath } from 'node:url';
18. import { copyIdent } from './identkit.mjs';
20. const HERE = dirname(fileURLToPath(import.meta.url));
21. const APP = resolve(HERE, '..');
22. const BIN = join(APP, 'bin/hybriel');
23. const PROJECTS = resolve(APP, '..');
24. const NEW_IDENT_DIR = process.env.NEW_IDENT_DIR || join(PROJECTS, 'ident.worldapi.org');
25. const OLD_IDENT_DIR = process.env.OLD_IDENT_DIR || join(PROJECTS, 'ident.worldapi.org/.scratch/pre-023-ident');
26. const IDENT_PORT = 8720, PORT = 8721;
27. const ID = `http://127.0.0.1:${IDENT_PORT}`;
28. const BASE = `http://127.0.0.1:${PORT}`;
29. const W = join(APP, '.scratch/m039-switch');
30. const J = JSON.stringify;
31. const sleep = (ms) => new Promise(r => setTimeout(r, ms));
32. const SHORT = /^[2-9a-hj-km-np-z]{5}$/;
33. const OLD = /^[0-9a-f]{32}$/;
35. let passed = 0, failed = 0;
36. const check = (name, ok, detail = '') => {
37. if (ok) { passed++; console.log(' ok ' + name); } else { failed++; console.log(' FAIL ' + name + (detail ? ' — ' + detail : '')); }
38. };
39. let log = '';
40. const procs = new Set();
41. function start(label, bin, args, cwd, env) {
42. log += `\n==== ${label}\n`;
43. const p = spawn(bin, args, { cwd, env: { ...process.env, ...env }, stdio: ['ignore', 'pipe', 'pipe'] });
44. p.stdout.on('data', d => log += d); p.stderr.on('data', d => log += d);
45. procs.add(p);
46. return p;
47. }
48. async function stop(p) {
49. if (!p) return;
50. try { p.kill('SIGTERM'); } catch {}
51. await new Promise(r => { if (p.exitCode !== null || p.signalCode !== null) return r(); p.once('exit', r); setTimeout(r, 3000); });
52. procs.delete(p);
53. }
54. async function up(url, what) {
55. for (let i = 0; i < 120; i++) { try { const r = await fetch(url, { redirect: 'manual' }); if (r.status < 500) return; } catch {} await sleep(250); }
56. throw new Error(what + ' did not come up\n' + log.slice(-3000));
57. }
59. // ---- ident (old or new code, on a given data dir; codes go to a mail sink — never real mail) -------------------
60. async function startIdentOn(codeDir, dataDir) {
61. mkdirSync(dataDir, { recursive: true });
62. const sink = join(dataDir, 'mail.txt');
63. if (!existsSync(sink)) writeFileSync(sink, '');
64. const p = start('ident ' + codeDir, join(codeDir, 'bin/hybriel'), ['project.hl'], codeDir, {
65. IDENT_PORT: String(IDENT_PORT), IDENT_STORAGE: join(dataDir, 'mpackdb'), IDENT_SESSIONS: join(dataDir, 'sessions') + '/',
66. IDENT_MAIL_SINK: sink, IDENT_IP_LIMIT: '1000', IDENT_IP_DAY_LIMIT: '1000', IDENT_WATCH: '0', HL_HOST: '127.0.0.1',
67. SMTP_HOST: '', SMTP_USER: '', SMTP_PASSWORD: '' });
68. await up(ID + '/', 'ident');
69. return { p, sink };
70. }
71. let iemitI = 0;
72. async function identEmit(event, payload, cookie) {
73. const r = await fetch(ID + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', ...(cookie ? { cookie } : {}) }, body: J({ t: 'emit', i: ++iemitI, event, payload }) });
74. const t = await r.text(); let j = null; try { j = JSON.parse(t); } catch {}
75. return { value: j && j.value, raw: t, setCookie: (r.headers.get('set-cookie') || '').split(';')[0] };
76. }
77. async function identSignIn(sink, email) {
78. const c = await fetch(ID + '/api/code', { method: 'POST', headers: { 'content-type': 'application/json' }, body: J({ email }) });
79. if (c.status !== 200) throw new Error('ident code refused: ' + c.status);
80. const code = readFileSync(sink, 'utf8').trim().split('\n').filter(l => l.startsWith(email + ' ')).pop().split(' ')[1];
81. const v = await identEmit('verifyCode', [email, code, 'Europe/Vienna']);
82. if (!v.value || !v.value.account) throw new Error('ident sign-in failed: ' + v.raw);
83. return { email, cookie: v.setCookie, identities: v.value.identities };
84. }
85. // the selector's path: identities (as the app's page asks) → choose → one-time code
86. async function selectorCode(who, app, identityName = null) {
87. const l = await (await fetch(ID + '/api/selector/identities?key=' + app.key, { headers: { origin: BASE, cookie: who.cookie } })).json();
88. if (!l.identities || !l.identities.length) throw new Error('no identities: ' + J(l));
89. const pick = identityName ? l.identities.find(i => i.name === identityName) : l.identities[0];
90. if (!pick) throw new Error('no identity named ' + identityName + ': ' + J(l));
91. const c = await (await fetch(ID + '/api/selector/choose?key=' + app.key, { method: 'POST', headers: { origin: BASE, cookie: who.cookie, 'content-type': 'application/json' }, body: J({ identity: pick.id }) })).json();
92. if (!c.code) throw new Error('choose failed: ' + J(c));
93. return c.code;
94. }
96. // ---- the app -----------------------------------------------------------------------------------------------------
97. async function startApp(codeDir, store, app, extra = {}) {
98. const p = start('notes.worldapi.org on ' + store, join(codeDir, 'bin/hybriel'), ['project.hl'], codeDir, {
99. ...appEnv(store), HL_HOST: '127.0.0.1', IDENT_URL: ID, IDENT_EXCHANGE_URL: ID, IDENT_API_KEY: app.key, IDENT_API_SECRET: app.secret, ...extra });
100. await up(BASE + '/', 'notes.worldapi.org');
101. return p;
102. }
103. // the login button's / selector's landing: <app>/login/callback?ident_code= → the app's session cookie
104. async function appLogin(who, app, identityName = null, cookie = null) {
105. const code = await selectorCode(who, app, identityName);
106. const r = await fetch(BASE + '/login/callback?ident_code=' + code, { redirect: 'manual', headers: cookie ? { cookie } : {} });
107. const loc = r.headers.get('location') || '';
108. if (r.status !== 302 || loc.startsWith('/login/failed')) {
109. let why = r.status !== 302 ? (await r.text()).replace(/<(style|script)[\s\S]*?<\/(style|script)>/g, " ").replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 200) : '';
110. const sc = (r.headers.get('set-cookie') || '').split(';')[0] || cookie;
111. if (r.status === 302) try { why = await (await fetch(BASE + '/login/failed', { headers: sc ? { cookie: sc } : {} })).text(); why = (why.match(/login failed[^<]*|ident refused[^<]*|that is not[^<]*/i) || [why.slice(0, 200)])[0]; } catch {}
112. return { error: 'login failed (' + r.status + ' → ' + loc + ') ' + why };
113. }
114. return { cookie: (r.headers.get('set-cookie') || '').split(';')[0] || cookie };
115. }
116. let aemitI = 0;
117. async function appEmit(cookie, event, payload) {
118. const r = await fetch(BASE + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', cookie }, body: J({ t: 'emit', i: ++aemitI, event, payload }) });
119. const t = await r.text(); let j = null; try { j = JSON.parse(t); } catch {}
120. return j && j.value !== undefined ? j.value : { error: 'no value: ' + t.slice(0, 300) };
121. }
122. const runTool = (store, app) => execFileSync(BIN, ['tools/migrate-short-ids.hl'], { cwd: APP, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
123. env: { ...process.env, ...appEnv(store), IDENT_EXCHANGE_URL: ID, IDENT_URL: ID, IDENT_API_KEY: app.key, IDENT_API_SECRET: app.secret } });
124. const counts = (out) => { const m = out.match(/users seen (\d+), mapped (\d+), already short (\d+), unmapped (\d+), conflicts (\d+), failed (\d+)/); return m ? m.slice(1).map(Number) : null; };
126. // ---- notes: what a user has — /api/me (the users @id) and the notes (/api/notes) ------------------------------------
127. const appEnv = (store) => ({ NOTES_PORT: String(PORT), NOTES_STORAGE: join(store, 'mpackdb'), NOTES_SESSIONS: join(store, 'sessions') + '/', NOTES_WATCH: '0', NOTES_PUBLIC_URL: BASE });
128. const prepareCode = async () => APP;
129. const firstEnv = async () => ({});
130. const laterEnv = async () => ({});
131. const toolExtra = async () => {};
132. const getJ = async (path, cookie) => { const r = await fetch(BASE + path, { headers: { cookie } }); return { status: r.status, j: await r.json() }; };
133. const postJ = async (body, cookie) => { const r = await fetch(BASE + '/api/notes', { method: 'POST', headers: { cookie, 'content-type': 'application/json' }, body: J(body) }); return { status: r.status, j: await r.json() }; };
134. async function makeData(ca, cb, cw) {
135. const out = {};
136. for (const [who, cookie, text] of [['alice', ca, '# Alice note\nonly hers'], ['bob', cb, '# Bob note\nonly his'], ['work', cw, '# Work note']]) {
137. const me = (await getJ('/api/me', cookie)).j.user;
138. const s = await postJ({ op: 'save', id: '', local: 'l-' + who, text, base: 0, at: Date.now() }, cookie);
139. out[who] = { user: me, note: s.j.id, text };
140. }
141. check('old world: three users, one note each', new Set([out.alice.user, out.bob.user, out.work.user]).size === 3 && out.alice.note && out.bob.note && out.work.note, J(out));
142. return out;
143. }
144. async function isNewEmptyUser(cookie, before) {
145. const me = (await getJ('/api/me', cookie)).j.user;
146. const list = (await getJ('/api/notes', cookie)).j.notes;
147. return me && me !== before.alice.user && Array.isArray(list) && list.length === 0;
148. }
149. async function sameUser(label, cookie, who) {
150. const me = (await getJ('/api/me', cookie)).j.user;
151. const list = (await getJ('/api/notes', cookie)).j.notes || [];
152. const n = await getJ('/api/notes?id=' + who.note, cookie);
153. check(label + ': the SAME user (users @id), exactly the own note, same text',
154. me === who.user && list.length === 1 && list[0].id === who.note && n.status === 200 && n.j.text === who.text, J({ me, want: who.user, list, n: n.status }));
155. }
158. let identP = null, appP = null;
159. try {
160. rmSync(W, { recursive: true, force: true });
161. mkdirSync(W, { recursive: true });
162. const oldCode = join(W, 'ident-old-code'), newCode = join(W, 'ident-new-code');
163. copyIdent(OLD_IDENT_DIR, oldCode);
164. copyIdent(NEW_IDENT_DIR, newCode);
165. const oldIsOld = !readFileSync(join(oldCode, 'store.hl'), 'utf8').includes('shortId');
166. const newIsNew = readFileSync(join(newCode, 'project.hl'), 'utf8').includes('migrate-ids');
167. check('the old ident has no short ids, the new one has /api/migrate-ids', oldIsOld && newIsNew);
168. const CODE = await prepareCode();
170. // ---- 1. the OLD world -------------------------------------------------------------------------------------------
171. console.log('# 1. old ident + notes.worldapi.org, data made');
172. let id = await startIdentOn(oldCode, join(W, 'ident-data'));
173. identP = id.p;
174. const alice = await identSignIn(id.sink, '[email protected]');
175. const bob = await identSignIn(id.sink, '[email protected]');
176. const added = await identEmit('addIdentity', [{ identityName: 'Work' }], alice.cookie);
177. const work = added.value && added.value.identities ? added.value.identities.find(i => i.identityName === 'Work') : null;
178. const reg = await identEmit('appCreate', [{ name: 'notes.worldapi.org', origins: [BASE] }], alice.cookie);
179. if (!reg.value || !reg.value.secret) throw new Error('appCreate failed: ' + reg.raw);
180. const app = { key: reg.value.app.apiKey, secret: reg.value.secret };
181. writeFileSync(join(W, 'test-app-key.json'), J(app)); // the THROW-AWAY test app's key (for a by-hand rerun of the tool)
182. appP = await startApp(CODE, join(W, 'app-store'), app, await firstEnv());
183. const a1 = await appLogin(alice, app), b1 = await appLogin(bob, app);
184. const w1 = await appLogin(alice, app, 'Work');
185. check('old ident: alice, bob and alice\'s "Work" log in to notes.worldapi.org', !a1.error && !b1.error && !w1.error && work != null, J([a1.error, b1.error, w1.error]));
186. const before = await makeData(a1.cookie, b1.cookie, w1.cookie);
187. await stop(appP); appP = null;
188. const dropped = await identEmit('dropIdentity', [work.id], alice.cookie);
189. check('alice deletes her "Work" identity in ident (its app user becomes UNMAPPED)', dropped.value && !dropped.value.error, dropped.raw.slice(0, 200));
190. await stop(identP); identP = null;
192. // ---- 2. copies --------------------------------------------------------------------------------------------------
193. cpSync(join(W, 'ident-data'), join(W, 'ident-data-new'), { recursive: true });
194. cpSync(join(W, 'app-store'), join(W, 'app-store-control'), { recursive: true });
195. cpSync(join(W, 'app-store'), join(W, 'app-store-migrated'), { recursive: true });
197. // ---- 3. the NEW ident on the copy -------------------------------------------------------------------------------
198. console.log('# 2. new ident (ident#23) on a copy of the old ident store');
199. id = await startIdentOn(newCode, join(W, 'ident-data-new'));
200. identP = id.p;
201. const mig = await (await fetch(ID + '/api/migrate-ids', { method: 'POST', headers: { 'content-type': 'application/json' }, body: J(app) })).json();
202. const olds = Object.keys(mig.ids || {});
203. check('new ident: migrate-ids maps 2 old ids (alice Default, bob) to short ids; the deleted identity is left out; not finished',
204. olds.length === 2 && olds.every(k => OLD.test(k)) && Object.values(mig.ids).every(v => SHORT.test(v)) && mig.finished === false, J(mig));
206. // ---- 4. CONTROL: unmigrated store ---------------------------------------------------------------------------------
207. console.log('# 3. control: the app on an UNMIGRATED copy');
208. appP = await startApp(CODE, join(W, 'app-store-control'), app, await laterEnv(mig));
209. const c1 = await appLogin(alice, app);
210. if (c1.error) check('control: login through the new ident fails or …', false, c1.error);
211. else check('control (not migrated): alice comes back as a NEW, EMPTY user — this is what the migration prevents', await isNewEmptyUser(c1.cookie, before), '');
212. await stop(appP); appP = null;
214. // ---- 5. the migration, twice --------------------------------------------------------------------------------------
215. console.log('# 4. tools/migrate-short-ids.hl on the other copy, twice');
216. const r1 = runTool(join(W, 'app-store-migrated'), app);
217. writeFileSync(join(W, 'migrate-run1.txt'), r1);
218. console.log(r1.trim().split('\n').map(l => ' | ' + l).join('\n'));
219. check('run 1: users seen 3, mapped 2, already short 0, unmapped 1 (deleted identity), conflicts 0, failed 0', J(counts(r1)) === J([3, 2, 0, 1, 0, 0]), J(counts(r1)));
220. const shorts = [...r1.matchAll(/MAPPED user \S+ → (\S+)/g)].map(m => m[1]).sort();
221. check('run 1: the users now hold exactly the short ids ident mapped', J(shorts) === J(Object.values(mig.ids).sort()), J([shorts, mig.ids]));
222. check('run 1 never prints the key or the secret', !r1.includes(app.secret) && !r1.includes(app.key));
223. const r2 = runTool(join(W, 'app-store-migrated'), app);
224. writeFileSync(join(W, 'migrate-run2.txt'), r2);
225. check('run 2 (idempotent): seen 3, mapped 0, already short 2, unmapped 1', J(counts(r2)) === J([3, 0, 2, 1, 0, 0]), J(counts(r2)));
226. await toolExtra(r1, r2, mig, app, alice);
227. const badSecret = (() => { try { runTool(join(W, 'app-store-migrated'), { key: app.key, secret: 'sk_' + '0'.repeat(48) }); return 'ran'; } catch (e) { return String(e.stdout || '') + String(e.stderr || ''); } })();
228. // the control copy: the app ran with the new ident BEFORE the migration and made a new user for alice's short id
229. const rc = (() => { try { return 'exit 0: ' + runTool(join(W, 'app-store-control'), app); } catch (e) { return String(e.stdout || '') + String(e.stderr || ''); } })();
230. writeFileSync(join(W, 'migrate-control.txt'), rc);
231. check('the tool on the control copy (app ran before the migration): alice = CONFLICT, left alone, exit non-zero',
232. J(counts(rc)) === J([4, 1, 1, 1, 1, 0]) && /CONFLICT user/.test(rc) && /CONFLICTS:/.test(rc) && !rc.startsWith('exit 0'), rc.slice(0, 400));
233. check('a wrong secret: the tool stops with ident\'s 401, changes nothing', /401/.test(badSecret), badSecret.slice(0, 300));
235. // ---- 6. the app on the migrated store ------------------------------------------------------------------------------
236. console.log('# 5. the app on the MIGRATED copy with the new ident');
237. appP = await startApp(CODE, join(W, 'app-store-migrated'), app, await laterEnv(mig));
238. await sameUser('alice, OLD app session (no new login)', a1.cookie, before.alice);
239. const a2 = await appLogin(alice, app);
240. check('alice logs in again through the new ident', !a2.error, a2.error);
241. if (!a2.error) await sameUser('alice, fresh login through the new ident', a2.cookie, before.alice, mig);
242. const b2 = await appLogin(bob, app);
243. check('bob logs in again through the new ident', !b2.error, b2.error);
244. if (!b2.error) await sameUser('bob, fresh login through the new ident', b2.cookie, before.bob, mig);
245. await stop(appP); appP = null;
246. const r3 = runTool(join(W, 'app-store-migrated'), app);
247. writeFileSync(join(W, 'migrate-run3.txt'), r3);
248. check('after the logins: still 3 users (no new one was made), all short or unmapped as before', J(counts(r3)) === J([3, 0, 2, 1, 0, 0]), J(counts(r3)));
249. await stop(identP); identP = null;
250. } catch (err) {
251. failed++; console.log(' FAIL (aborted) ' + (err.stack || err));
252. } finally {
253. for (const p of [...procs]) await stop(p);
254. mkdirSync(W, { recursive: true });
255. writeFileSync(join(W, 'servers.log'), log);
256. }
257. console.log(`\n${passed} passed, ${failed} failed`);
258. process.exit(failed ? 1 : 0);