notes

13.6 KB

1. // tests/realdata-baseline.mjs (notes mission 002, code order; after gitoria's): every read the app answers + a fixed write
2. // sequence, on a COPY of the LIVE storage, saved for diffing two code trees (a cleanup must answer the same). Compare two
3. // outputs with tests/realdata-compare.py. README "Test" → "Same output".
4. // node tests/realdata-baseline.mjs <tree> <port> <outdir> (kills only the server it started)
5. // The live copy: NOTES_REALDATA (default .scratch/realdata) must hold storage/mpackdb, e.g. from Byrodin:
6. // tar -C /CONTAINERS/projects/notes.worldapi.org -cf - storage/mpackdb | ssh loreana tar -C <repo>/.scratch/realdata -xf -
7. // Each run works on a fresh copy of it (<outdir>.run, removed after). Signed in as the creator (identity az5b2 → users @id
8. // 0muh6o5a3kkd) through a session file written before the start; every page and API read is fetched signed in AND out.
9. // ident is a FAKE on <port>+5 (POST /api/exchange: code abcdef01 → az5b2, abcdef02 → an invalid id, abcdef03 → 403,
10. // else 400); the login routes and faces answer what they answer for that. The public URL is the same for every port
11. // (http://notes.test), so two runs on two ports can be compared.
12. import { spawn } from 'node:child_process';
13. import { request, createServer } from 'node:http';
14. import { writeFileSync, mkdirSync, rmSync, cpSync } from 'node:fs';
15. import { createHash, randomBytes } from 'node:crypto';
16. import { join, resolve } from 'node:path';
18. const [tree, portArg, outArg] = process.argv.slice(2);
19. const PORT = Number(portArg);
20. const W = resolve(process.env.NOTES_REALDATA || '.scratch/realdata'), OUT = resolve(outArg), RUN = OUT + '.run';
21. const USER = '0muh6o5a3kkd';
22. rmSync(RUN, { recursive: true, force: true }); rmSync(OUT, { recursive: true, force: true });
23. mkdirSync(join(RUN, 'sessions'), { recursive: true }); mkdirSync(OUT, { recursive: true });
24. cpSync(join(W, 'storage'), join(RUN, 'storage'), { recursive: true });
26. // ---- the sessions: signed in, and a signed-out one (for the failed-login reason) -----------------------------------
27. const now = Date.now();
28. const session = (user, tag) => {
29. const sid = randomBytes(16).toString('hex');
30. writeFileSync(join(RUN, 'sessions', createHash('sha256').update(sid).digest('hex')),
31. JSON.stringify({ created: now, data: { tag }, handled: [], id: sid, seen: now, user }), { mode: 0o600 });
32. return 'notessid=' + sid;
33. };
34. const COOKIE = session({ id: USER }, 'rdtag1'), C2 = session(null, 'rdtag2');
35. const sleep = ms => new Promise(r => setTimeout(r, ms));
36. const HOST = `notes.test:${PORT}`;
37. const IDENT = `http://127.0.0.1:${PORT + 5}`;
38. const fakeIdent = createServer((req, res) => {
39. let body = ''; req.on('data', d => body += d); req.on('end', () => {
40. let j = {}; try { j = JSON.parse(body); } catch {}
41. const answer = (status, v) => { res.writeHead(status, { 'content-type': 'application/json' }); res.end(JSON.stringify(v)); };
42. if (req.method !== 'POST' || req.url !== '/api/exchange') return answer(404, { error: 'fake ident: not here' });
43. if (j.key !== 'pk_rd' || j.secret !== 'sk_rd') return answer(403, { error: 'bad key' });
44. if (j.code === 'abcdef01') return answer(200, { identity: 'az5b2' });
45. if (j.code === 'abcdef02') return answer(200, { identity: 'Not Valid!' });
46. if (j.code === 'abcdef03') return answer(403, { error: 'code expired' });
47. return answer(400, { error: 'unknown code' });
48. });
49. });
50. fakeIdent.listen(PORT + 5, '127.0.0.1');
52. const srv = spawn(resolve(tree, 'bin/hybriel'), ['project.hl'], { cwd: resolve(tree), stdio: ['ignore', 'pipe', 'pipe'],
53. env: { ...process.env, NOTES_PORT: String(PORT), NOTES_PUBLIC_URL: 'http://notes.test', NOTES_STORAGE: join(RUN, 'storage/mpackdb'),
54. NOTES_SESSIONS: join(RUN, 'sessions') + '/', NOTES_WATCH: '0', IDENT_URL: 'http://ident.test', IDENT_EXCHANGE_URL: IDENT,
55. IDENT_API_KEY: 'pk_rd', IDENT_API_SECRET: 'sk_rd' } });
56. let log = ''; srv.stdout.on('data', d => log += d); srv.stderr.on('data', d => log += d);
58. const hreq = (method, path, headers = {}, body = null) => new Promise((res) => {
59. const rq = request({ host: '127.0.0.1', port: PORT, path, method, headers: { host: HOST, ...headers } }, (r) => {
60. const parts = []; r.on('data', d => parts.push(d)); r.on('end', () => res({ status: r.statusCode, headers: r.headers, body: Buffer.concat(parts).toString('utf8') }));
61. });
62. rq.on('error', (e) => res({ status: 0, headers: {}, body: 'ERROR ' + e.message }));
63. if (body != null) { rq.setHeader('content-length', Buffer.byteLength(body)); rq.write(body); }
64. rq.end();
65. });
66. let n = 0;
67. const file = (name, text) => writeFileSync(join(OUT, String(++n).padStart(4, '0') + '-' + name.replace(/[^a-zA-Z0-9._-]+/g, '_').slice(0, 120)), text);
68. const save = async (name, method, path, headers = {}, body = null) => {
69. const r = await hreq(method, path, headers, body);
70. const head = [r.status, r.headers['content-type'] || '', r.headers['location'] || '', r.headers['cache-control'] || '', r.headers['set-cookie'] ? 'set-cookie' : ''].join(' | ');
71. file(name, head + '\n' + r.body);
72. return r;
73. };
74. let ei = 0;
75. const emitF = async (name, event, payload, cookie = COOKIE) => {
76. const r = await hreq('POST', '/__hl/emit', { 'content-type': 'application/json', cookie }, JSON.stringify({ t: 'emit', i: ++ei, event, payload }));
77. file('w-face-' + name, r.status + '\n' + r.body);
78. try { return JSON.parse(r.body).value; } catch { return null; }
79. };
80. const JH = { 'content-type': 'application/json', cookie: COOKIE };
81. const post = async (name, body, cookie = COOKIE) => {
82. const r = await save(name, 'POST', '/api/notes', { 'content-type': 'application/json', cookie }, typeof body === 'string' ? body : JSON.stringify(body));
83. try { return JSON.parse(r.body); } catch { return {}; }
84. };
86. try {
87. for (let i = 0; i < 240; i++) { if ((await hreq('GET', '/api/me')).status === 200) break; await sleep(500); }
88. const list = JSON.parse((await save('api-notes', 'GET', '/api/notes', { cookie: COOKIE })).body).notes;
89. // ---- READS ------------------------------------------------------------------------------------------------------
90. const pages = ['/', '/note/nosuch', '/note/', '/login/failed', '/nope', '/login.js', '/sw.js', '/notes-offline.js', '/md-editor.js',
91. '/favicon.ico', '/icons/icon-192.png', '/icons/icon-512.png', '/icons/apple-touch-icon.png', '/icons/favicon.svg',
92. '/__hl/manifest.webmanifest', '/__hl/sw.js'];
93. for (const x of list) pages.push('/note/' + x.id);
94. const modules = new Set();
95. for (const p of pages) {
96. const r = await save('in-' + p, 'GET', p, { cookie: COOKIE }); await save('out-' + p, 'GET', p);
97. for (const m of r.body.matchAll(/(\/(?:components|__hl)\/[\w./-]+\.(?:hl|js|css))\?v=[0-9a-f]+/g)) modules.add(m[0]);
98. }
99. for (const m of [...modules].sort()) await save('module-' + m.replace(/\?v=.*/, ''), 'GET', m);
100. const apis = ['/api/me', '/api/notes', '/api/notes?id=nosuch', '/api/notes?id='];
101. for (const x of list) apis.push('/api/notes?id=' + x.id);
102. for (const u of apis) { await save('api-in' + u, 'GET', u, { cookie: COOKIE }); await save('api-out' + u, 'GET', u); }
103. // the refusals of POST /api/notes
104. for (const [name, body] of [['empty', ''], ['badjson', '{"op":'], ['surrogate', '{"op":"save","text":"\\ud83d\\ude00"}'], ['array', '[1,2]'],
105. ['string', '"x"'], ['null', 'null'], ['noop', '{}'], ['badop', '{"op":"rename"}'],
106. ['save-nofields', '{"op":"save"}'], ['save-numid', '{"op":"save","id":1,"local":"","text":"","base":0,"at":0}'],
107. ['save-negbase', '{"op":"save","id":"","local":"","text":"","base":-1,"at":0}'],
108. ['save-longid', JSON.stringify({ op: 'save', id: 'x'.repeat(65), local: '', text: 'a', base: 0, at: 0 })],
109. ['save-longlocal', JSON.stringify({ op: 'save', id: '', local: 'l'.repeat(65), text: 'a', base: 0, at: 0 })],
110. ['save-toolong', JSON.stringify({ op: 'save', id: '', local: 'lrdlong', text: 'x'.repeat(200001), base: 0, at: 0 })],
111. ['delete-nofields', '{"op":"delete"}'], ['delete-strbase', '{"op":"delete","id":"x","base":"1"}']])
112. await post('post-' + name, body);
113. await save('post-out', 'POST', '/api/notes', { 'content-type': 'application/json' }, '{"op":"save"}');
114. await save('put', 'PUT', '/api/notes', JH, '{}');
115. await save('delete-method', 'DELETE', '/api/notes', JH);
116. await save('me-post', 'POST', '/api/me', JH, '{}');
117. // the login's function route (the fake ident)
118. for (const q of ['', '?ident_code=zz', '?ident_code=abc123', '?ident_code=abcdef02', '?ident_code=abcdef03', '?ident_code=abc&next=/note/x']) await save('callback' + q, 'GET', '/login/callback' + q);
119. await save('callback-post', 'POST', '/login/callback', {}, 'x');
120. await save('page-loginfailed-after', 'GET', '/login/failed');
121. await save('callback-cookie', 'GET', '/login/callback?ident_code=abc123', { cookie: C2 });
122. await save('page-loginfailed-cookie', 'GET', '/login/failed', { cookie: C2 });
123. await save('callback-cookie-nocode', 'GET', '/login/callback', { cookie: C2 });
124. await save('page-loginfailed-cookie2', 'GET', '/login/failed', { cookie: C2 });
125. await save('callback-cookie-get-only', 'POST', '/login/callback', { cookie: C2 }, 'x');
126. await save('page-loginfailed-cookie3', 'GET', '/login/failed', { cookie: C2 });
127. await save('callback-cookie-expired', 'GET', '/login/callback?ident_code=abcdef03', { cookie: C2 });
128. await save('page-loginfailed-cookie4', 'GET', '/login/failed', { cookie: C2 });
129. // a login that works (the fake ident knows abcdef01 = az5b2): fresh browser → a new session; `next` → back to that path
130. for (const q of ['', '&next=/note/x', '&next=//evil', '&next=/login/failed', '&next=/a%20b', '&next=/a<b', '&next=x']) {
131. const r = await save('w-callback-ok' + q, 'GET', '/login/callback?ident_code=abcdef01' + q);
132. const ck = (r.headers['set-cookie'] || [''])[0].split(';')[0];
133. if (q === '') { await save('w-callback-ok-page', 'GET', '/', { cookie: ck }); await save('w-callback-ok-me', 'GET', '/api/me', { cookie: ck }); }
134. }
135. // the same in a browser that has a signed-out session: that session is signed in (no new cookie)
136. await save('w-callback-ok-cookie', 'GET', '/login/callback?ident_code=abcdef01&next=/note/y', { cookie: C2 });
137. await save('w-callback-ok-cookie-me', 'GET', '/api/me', { cookie: C2 });
138. await save('w-callback-ok-cookie-failed', 'GET', '/login/failed', { cookie: C2 });
140. // ---- WRITES ('w-' files; realdata-compare.py masks the new ids and the times) ---------------------------------------
141. const a = await post('w-save-new', { op: 'save', id: '', local: 'lrd1', text: '# rd one\n\nbody', base: 0, at: 1700000000000 });
142. await post('w-save-retry', { op: 'save', id: '', local: 'lrd1', text: '# rd one\n\nbody', base: 0, at: 1700000000000 });
143. await post('w-save-same', { op: 'save', id: a.id, local: '', text: '# rd one\n\nbody', base: a.edited, at: 1700000001000 });
144. const b = await post('w-save-edit', { op: 'save', id: a.id, local: '', text: '# rd one\n\nbody 2', base: a.edited, at: 1700000002000 });
145. // conflict: base is old; the push is LATER than the server's version → the push wins, the server's version is a copy
146. const c = await post('w-save-conflict-later', { op: 'save', id: a.id, local: '', text: 'rd later', base: a.edited, at: Date.now() - 1000 });
147. // conflict: the push is OLDER → the server keeps its text, the push becomes a copy
148. await post('w-save-conflict-older', { op: 'save', id: a.id, local: '', text: 'rd older', base: a.edited, at: 1600000000000 });
149. await post('w-save-unknownid', { op: 'save', id: 'nosuch', local: '', text: 'rd unknown id', base: 5, at: 0 });
150. await post('w-save-real', { op: 'save', id: list.find(x => !x.gone)?.id || 'none', local: '', text: 'rd overwrite?', base: 1, at: 1 });
151. await post('w-save-out', { op: 'save', id: '', local: 'lrd2', text: 'x', base: 0, at: 0 }, 'notessid=none');
152. await post('w-delete-wrongbase', { op: 'delete', id: a.id, base: 1 });
153. await post('w-delete', { op: 'delete', id: a.id, base: c.edited ?? b.edited });
154. await post('w-delete-again', { op: 'delete', id: a.id, base: 0 });
155. await post('w-delete-nosuch', { op: 'delete', id: 'nosuch', base: 0 });
156. await post('w-delete-empty', { op: 'delete', id: '', base: 0 });
157. await post('w-save-after-delete', { op: 'save', id: a.id, local: '', text: 'rd back', base: 0, at: 0 });
158. await post('w-save-oldlocal-again', { op: 'save', id: '', local: 'lrd1', text: 'rd local again', base: 0, at: 0 });
159. await save('w-api-notes', 'GET', '/api/notes', { cookie: COOKIE });
160. await save('w-api-one', 'GET', '/api/notes?id=' + a.id, { cookie: COOKIE });
161. await save('w-page-main', 'GET', '/', { cookie: COOKIE });
162. await save('w-page-note', 'GET', '/note/' + a.id, { cookie: COOKIE });
163. // the faces: login with a code (ident down), logout, then the pages again
164. await emitF('login-bad', 'notesLogin', ['zz']);
165. await emitF('login-hex', 'notesLogin', ['abc123']);
166. await emitF('login-invalid', 'notesLogin', ['abcdef02']);
167. await emitF('login-out', 'notesLogin', ['abc123'], 'notessid=none');
168. const C3 = session(null, 'rdtag3');
169. await emitF('login-ok', 'notesLogin', ['abcdef01'], C3);
170. await save('w-login-ok-me', 'GET', '/api/me', { cookie: C3 });
171. await save('w-login-ok-page', 'GET', '/', { cookie: C3 });
172. await emitF('logout', 'notesLogOut', []);
173. await save('w-page-main-loggedout', 'GET', '/', { cookie: COOKIE });
174. await save('w-api-me-loggedout', 'GET', '/api/me', { cookie: COOKIE });
175. await save('w-api-notes-loggedout', 'GET', '/api/notes', { cookie: COOKIE });
176. console.log(`${n} responses saved to ${OUT} (${pages.length} pages x2, ${apis.length} api urls x2, + writes)`);
177. } finally {
178. fakeIdent.close();
179. srv.kill('SIGTERM'); await sleep(1000); try { process.kill(srv.pid, 'SIGKILL'); } catch {}
180. }
181. writeFileSync(join(OUT, '0000-server-log'), log.split('\n').filter(l => !/listening|watch/i.test(l)).join('\n'));
182. rmSync(RUN, { recursive: true, force: true });