notes

30.6 KB

1. // tests/browser.mjs — THE GATE of notes.worldapi.org (tickets notes#1: sidebar + Markdown editor; notes#2: offline + sync).
2. // Its own notes server on its own storage, its OWN ident (a copy of ident's code without .env — codes go to a mail
3. // sink, tests/identkit.mjs), real headless Chromes for everything visible. `*.notes.test` is mapped to 127.0.0.1
4. // inside Chrome (--host-resolver-rules) so ident and the app are the same site, as on worldapi.org.
5. //
6. // node tests/browser.mjs (NOTES_GATE_PORT server, default 8702; NOTES_GATE_IDENT_PORT, default 8701;
7. // NOTES_GATE_CHROME "8713-8719" = Chrome debug ports)
8. // Screenshots (390 / 1280 px) land in .scratch/gate-*.png. Every process started is stopped by PID.
9. import { spawn } from 'node:child_process';
10. import { rmSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
11. import { dirname, join, resolve } from 'node:path';
12. import { fileURLToPath } from 'node:url';
13. import { launchBrowser } from './cdp.mjs';
14. import { startIdent } from './identkit.mjs';
16. if (!process.env.HL_CHROME && existsSync('/opt/google/chrome/chrome')) process.env.HL_CHROME = '/opt/google/chrome/chrome';
17. const HERE = dirname(fileURLToPath(import.meta.url));
18. const APP = resolve(HERE, '..');
19. const BIN = join(APP, 'bin/hybriel');
20. const PORT = Number(process.env.NOTES_GATE_PORT || 8702);
21. const IDENT_PORT = Number(process.env.NOTES_GATE_IDENT_PORT || 8701);
22. const API = `http://127.0.0.1:${PORT}`;
23. const BASE = `http://notes.test:${PORT}`;
24. const IDENT_B = `http://ident.notes.test:${IDENT_PORT}`;
25. const [CH_FROM, CH_TO] = (process.env.NOTES_GATE_CHROME || '8703-8709').split('-').map(Number);
26. process.env.HL_CHROME_ARGS = '--host-resolver-rules=MAP *.notes.test 127.0.0.1, MAP notes.test 127.0.0.1|--unsafely-treat-insecure-origin-as-secure=' + `http://notes.test:${PORT}`; // a service worker needs a secure origin (https on worldapi.org)
27. const SCRATCH = join(APP, '.scratch');
28. const STORE = join(SCRATCH, 'gate-store');
29. const IDENT_DIR = process.env.NOTES_GATE_IDENT_DIR || [resolve(APP, '../ident.worldapi.org'), '/media/STORAGE/projects/ident.worldapi.org'].find(d => existsSync(join(d, 'project.hl')));
30. rmSync(STORE, { recursive: true, force: true });
31. mkdirSync(STORE, { recursive: true });
33. let failures = 0, passes = 0;
34. function check(label, ok, detail = '') {
35. console.log(`${ok ? 'ok ' : 'FAIL'} ${label}${ok ? '' : ' — ' + detail}`);
36. if (ok) passes++; else failures++;
37. }
38. const sleep = (ms) => new Promise(r => setTimeout(r, ms));
39. const J = JSON.stringify;
40. let log = '';
41. let server = null, ident = null;
42. const browsers = [];
44. function startServer(extraEnv = {}) {
45. log += '\n==== notes server start\n';
46. server = spawn(BIN, ['project.hl'], {
47. cwd: APP,
48. env: { ...process.env, NOTES_PORT: String(PORT), NOTES_STORAGE: join(STORE, 'mpackdb'), NOTES_SESSIONS: join(STORE, 'sessions') + '/', NOTES_WATCH: '0',
49. NOTES_PUBLIC_URL: BASE, IDENT_URL: IDENT_B, IDENT_EXCHANGE_URL: ident.base, ...extraEnv },
50. stdio: ['ignore', 'pipe', 'pipe'],
51. });
52. server.stdout.on('data', d => log += d); server.stderr.on('data', d => log += d);
53. }
54. async function serverUp() {
55. for (let i = 0; i < 80; i++) { try { const r = await fetch(API + '/'); if (r.ok) return; } catch {} await sleep(250); }
56. throw new Error('notes did not come up\n' + log);
57. }
58. async function stopServer() {
59. if (!server) return;
60. try { server.kill('SIGTERM'); } catch {}
61. await new Promise(r => { if (server.exitCode !== null || server.signalCode !== null) return r(); server.once('exit', r); setTimeout(r, 3000); });
62. server = null;
63. }
65. const SLOW = Number(process.env.NOTES_GATE_SLOW || 3);
66. function patient(page) {
67. const waitFor = page.waitFor.bind(page);
68. page.waitFor = (expr, o = {}) => waitFor(expr, { ...o, timeout: (o.timeout || 10000) * SLOW });
69. const goto = page.goto.bind(page);
70. page.goto = (url, o = {}) => goto(url, { ...o, timeout: (o.timeout || 15000) * SLOW });
71. return page;
72. }
73. // a page of a NEW Chrome (own cookies), or — given `like` — another tab of the same Chrome (same login)
74. async function newPage(like = null) {
75. if (like) return patient(await like.__browser.newPage());
76. const b = await launchBrowser({ debugPortRange: [CH_FROM, CH_TO] });
77. browsers.push(b);
78. const p = patient(await b.newPage());
79. p.__browser = b;
80. return p;
81. }
82. async function viewport(page, width, height) {
83. await page.send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: width < 600 });
84. await sleep(250);
85. }
86. async function shot(page, name) {
87. await page.send('Page.bringToFront');
88. const { data } = await page.send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true });
89. writeFileSync(join(SCRATCH, `gate-${name}.png`), Buffer.from(data, 'base64'));
90. }
91. const noOverflow = (page) => page.evaluate('document.documentElement.scrollWidth <= window.innerWidth');
92. const hydrated = (page) => page.waitFor('!!window.__hl && window.__hl.socket && window.__hl.socket.readyState === 1', { label: 'page hydrated' });
93. const txt = (page, sel) => page.evaluate(`(document.querySelector(${J(sel)}) || {}).textContent || null`);
94. const has = (page, sel) => page.evaluate(`!!document.querySelector(${J(sel)})`);
95. const subjects = (page) => page.evaluate(`[...document.querySelectorAll('#notes a')].map(a => a.textContent)`);
96. const visible = (page, sel) => page.evaluate(`(() => { const e = document.querySelector(${J(sel)}); return !!e && e.getBoundingClientRect().width > 0; })()`);
98. async function identSignIn(page, email) {
99. await page.goto(IDENT_B + '/');
100. await page.waitForSelector('#email');
101. await hydrated(page);
102. await page.type('#email', email);
103. await page.click('#sendcode');
104. await page.waitFor('/\\/code$/.test(location.pathname) && !!document.querySelector("#code")', { label: 'ident /code page' });
105. await hydrated(page);
106. await page.type('#code', ident.lastCode(email));
107. await page.click('#verify');
108. await page.waitForSelector('#signout', { timeout: 10000 });
109. }
110. // the login button of the page we are on → ident's "choose an identity" → back
111. async function buttonLogin(page) {
112. await page.click('#loginbutton');
113. await page.waitForSelector('#chooselist', { timeout: 10000 });
114. await hydrated(page);
115. await page.click('#chooselist li:nth-child(1) .choose');
116. }
118. // ---- REAL clicks and keys into the editor's shadow DOM (as in tickets' gate) ----------------------------
119. const mdR = (expr) => `(() => { const t = document.getElementById('notetext'); const h = t && t.closest('md-editor'); const r = h && h.shadowRoot; if (!r) return null; return (${expr}); })()`;
120. const CTRL = 2;
121. async function mdClick(page, sel) {
122. const bx = await page.evaluate(mdR(`(() => { const el = r.querySelector(${J(sel)}); if (!el) return null; el.scrollIntoView({ block: 'center' }); const q = el.getBoundingClientRect(); return { x: q.left, y: q.top, w: q.width, h: q.height }; })()`));
123. if (!bx || !bx.w) throw new Error('mdClick: ' + sel + ' is not laid out');
124. const x = Math.round(bx.x + bx.w / 2), y = Math.round(bx.y + bx.h / 2);
125. for (const [type, buttons] of [['mouseMoved', 0], ['mousePressed', 1], ['mouseReleased', 0]]) await page.send('Input.dispatchMouseEvent', { type, x, y, button: 'left', clickCount: 1, buttons });
126. await sleep(80);
127. }
128. async function mdPress(page, key, mods = 0) {
129. const K = { Enter: [13, 'Enter', '\r'], End: [35, 'End'] }[key];
130. const [vk, code, text] = K;
131. const t = text && !(mods & CTRL) ? text : undefined;
132. await page.send('Input.dispatchKeyEvent', { type: t ? 'keyDown' : 'rawKeyDown', modifiers: mods, key, code, windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk, ...(t ? { text: t, unmodifiedText: t } : {}) });
133. await page.send('Input.dispatchKeyEvent', { type: 'keyUp', modifiers: mods, key, code, windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk });
134. await sleep(30);
135. }
136. async function mdType(page, text) {
137. for (const ch of text) {
138. await page.send('Input.dispatchKeyEvent', { type: 'keyDown', text: ch, unmodifiedText: ch, key: ch });
139. await page.send('Input.dispatchKeyEvent', { type: 'keyUp', key: ch });
140. }
141. await sleep(60);
142. }
143. const taVal = (page) => page.evaluate(`document.getElementById('notetext').value`);
144. const editorReady = (page, label) => page.waitFor(mdR(`!!r.querySelector('[part~=editor]')`), { label });
145. const emitFace = async (event, payload, cookie) => {
146. const r = await fetch(API + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', ...(cookie ? { cookie } : {}) }, body: J({ t: 'emit', i: 1, event, payload }) });
147. const t = await r.text(); let j = null; try { j = JSON.parse(t); } catch {}
148. return { status: r.status, raw: t, value: j && j.value };
149. };
151. try {
152. ident = await startIdent({ identDir: IDENT_DIR, workDir: join(STORE, 'ident'), port: IDENT_PORT });
153. const alice = await ident.signIn('[email protected]');
154. await ident.signIn('[email protected]');
155. const APPKEY = await ident.registerApp(alice, 'notes (gate)', [BASE]);
156. check('ident: our own ident runs (a copy without .env), notes is registered', /^pk_[0-9a-f]{32}$/.test(APPKEY.key) && !existsSync(join(STORE, 'ident', 'ident-code', '.env')));
157. startServer({ IDENT_API_KEY: APPKEY.key, IDENT_API_SECRET: APPKEY.secret });
158. await serverUp();
160. // ---- signed out -------------------------------------------------------------------------------------
161. let html = await (await fetch(API + '/')).text();
162. check('signed out: the page only asks to log in (no list, no editor, no notes)', /Log in with ident/.test(html) && !/id="newnote"|<note-list|<md-editor|id="notesapp"/.test(html), html.slice(html.indexOf('<body')).slice(0, 300));
163. let r = await fetch(API + '/login/callback', { redirect: 'manual' });
164. check('login: /login/callback without a code → /login/failed', r.status === 302 && r.headers.get('location') === '/login/failed');
165. r = await fetch(API + '/api/notes');
166. check('signed out: the notes API answers 401', r.status === 401);
167. r = await (await fetch(API + '/api/me')).json();
168. check('signed out: /api/me says nobody', r.user === null, J(r));
170. // ---- log in with ident (the button flow) on device A ----------------------------------------------------
171. const a = await newPage();
172. await viewport(a, 1280, 900);
173. await identSignIn(a, '[email protected]');
174. await a.goto(BASE + '/');
175. await hydrated(a);
176. check('signed out (browser): "Log in with ident" shows, no "New note"', await has(a, '#loginbutton') && !(await has(a, '#newnote')));
177. await buttonLogin(a);
178. await a.waitForSelector('#newnote', { timeout: 15000 });
179. check('login: alice sees her (empty) list and "New note"', (await txt(a, '#empty')) !== null && (await subjects(a)).length === 0 && await has(a, '#logout'));
180. const cookieOf = async (page) => (await page.cookies([BASE])).filter(c => c.name === 'notessid').map(c => 'notessid=' + c.value)[0];
181. const cookieA = await cookieOf(a);
182. const apiGet = async (path, cookie) => { const x = await fetch(API + path, { headers: { cookie } }); return { status: x.status, json: await x.json().catch(() => null) }; };
183. const apiPost = async (body, cookie) => { const x = await fetch(API + '/api/notes', { method: 'POST', headers: { cookie, 'content-type': 'application/json' }, body: typeof body === 'string' ? body : J(body) }); return { status: x.status, json: await x.json().catch(() => null) }; };
184. const serverNotes = async (cookie) => {
185. const list = (await apiGet('/api/notes', cookie)).json.notes.filter(n => !n.gone);
186. const out = [];
187. for (const n of list) out.push({ ...n, text: (await apiGet('/api/notes?id=' + n.id, cookie)).json.text });
188. return out;
189. };
190. const untilServer = async (cookie, pred, label) => {
191. for (let i = 0; i < 80; i++) { const ns = await serverNotes(cookie); if (pred(ns)) return ns; await sleep(250); }
192. throw new Error('server never showed: ' + label + ' ' + J(await serverNotes(cookie)));
193. };
194. const syncNow = (page) => page.evaluate('window.__notesOffline.sync().then(() => true)');
195. const shellKept = async (page) => { for (let i = 0; i < 80; i++) { if (await page.evaluate(`caches.open('notes-shell-v1').then(c => c.match('/shell')).then(x => !!x)`)) return; await sleep(250); } throw new Error('the page was never kept for offline use'); };
196. await shellKept(a);
197. check('offline: the service worker keeps the page and its assets', await a.evaluate(`caches.open('notes-shell-v1').then(c => c.keys()).then(k => k.map(x => new URL(x.url).pathname).sort().join(' '))`).then(v => /\/md-editor\.js/.test(v) && /\/notes-offline\.js/.test(v) && /\/shell/.test(v) && /app\.css|__hl/.test(v) ? true : v));
199. // ---- THE INSTALLABLE APP (mission 046): hl:web's own manifest from project.hl appIcons — but NOT its service worker:
200. // notes has no `offline = [...]`, its own /sw.js (registered by notes-offline.js) stays the one worker for scope /.
201. const pwaHtml = await (await fetch(API + '/')).text();
202. const mhref = (pwaHtml.match(/<link rel="manifest" href="([^"]+)"/) || [])[1];
203. check('pwa: every page head links the manifest, the apple-touch-icon, the favicon and the theme colour (the header token `darker`)',
204. mhref === '/__hl/manifest.webmanifest' && pwaHtml.includes('<link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">')
205. && pwaHtml.includes('<link rel="icon" href="/icons/favicon.svg">') && pwaHtml.includes('<meta name="theme-color" content="rgb(15, 20, 25)">'), pwaHtml.slice(0, 900));
206. const mres = await fetch(API + mhref);
207. const man = await mres.json();
208. check('pwa: the manifest is served as application/manifest+json: name "notes", start_url /, scope /, display standalone, the token colours',
209. /manifest\+json/.test(mres.headers.get('content-type') || '') && man.name === 'notes' && man.short_name === 'notes' && man.start_url === '/' && man.scope === '/'
210. && man.display === 'standalone' && man.theme_color === 'rgb(15, 20, 25)' && man.background_color === 'rgb(25, 30, 35)', J(man));
211. const iconOk = [];
212. for (const ic of man.icons || []) {
213. const ir = await fetch(API + ic.src);
214. const buf = Buffer.from(await ir.arrayBuffer());
215. iconOk.push(ir.ok && ic.type === 'image/png' && buf.readUInt32BE(16) === Number(ic.sizes.split('x')[0]) && buf.readUInt32BE(20) === Number(ic.sizes.split('x')[1]));
216. }
217. check('pwa: every manifest icon loads and is a real PNG of its declared size (192 + 512, any + maskable)',
218. iconOk.length === 4 && iconOk.every(Boolean) && ['any', 'maskable'].every(pu => ['192x192', '512x512'].every(sz => man.icons.some(i => i.purpose === pu && i.sizes === sz))), J(man.icons) + ' ' + J(iconOk));
219. const touch = await fetch(API + '/icons/apple-touch-icon.png');
220. const touchBytes = Buffer.from(await touch.arrayBuffer());
221. const fav = await fetch(API + '/icons/favicon.svg');
222. const favText = await fav.text();
223. const ico = await fetch(API + '/favicon.ico');
224. const icoBytes = Buffer.from(await ico.arrayBuffer());
225. check('pwa: apple-touch-icon is a 180×180 PNG, the favicon an SVG in notes yellow, /favicon.ico a real icon file',
226. touch.ok && touchBytes.readUInt32BE(16) === 180 && fav.ok && /image\/svg\+xml/.test(fav.headers.get('content-type') || '') && favText.includes('#dcdcaa')
227. && ico.ok && icoBytes.readUInt32BE(0) === 0x00000100, `${touch.status} ${fav.status} ${ico.status}`);
228. const am = await a.send('Page.getAppManifest');
229. check('pwa: Chrome parses the manifest without errors', am.url && am.url.endsWith('/__hl/manifest.webmanifest') && (am.errors || []).length === 0, J(am.errors));
230. await a.waitFor('!!navigator.serviceWorker.controller', { label: 'page controlled by /sw.js' });
231. const inst = await a.send('Page.getInstallabilityErrors');
232. check('pwa: Chrome reports no installability error', (inst.installabilityErrors || []).length === 0, J(inst));
233. const regs = await a.evaluate(`navigator.serviceWorker.getRegistrations().then(rs => rs.map(r => new URL(r.scope).pathname + ' ' + new URL((r.active || r.waiting || r.installing).scriptURL).pathname).join(','))`);
234. check("pwa: exactly one service worker — notes' own /sw.js for scope /, it controls the page; hl:web serves none (/__hl/sw.js 404)",
235. regs === '/ /sw.js' && new URL(await a.evaluate('navigator.serviceWorker.controller.scriptURL')).pathname === '/sw.js' && (await fetch(API + '/__hl/sw.js')).status === 404, regs);
237. // ---- new note: heading and text; saved on the server ------------------------------------------------------
238. await a.click('#newnote');
239. await a.waitFor(`/^\\/note\\/l[0-9a-f]+$/.test(location.pathname)`, { label: 'the new note is open' });
240. await a.waitForSelector('#notetext');
241. await editorReady(a, 'editor on the new note');
242. check('new note: opens on the right, the sidebar lists it as "Untitled note"', (await subjects(a)).join('|') === 'Untitled note' && await visible(a, 'note-list') && await visible(a, 'note-editor'), J(await subjects(a)));
243. await mdClick(a, '[part~=editor]');
244. await mdType(a, '# Groceries');
245. await mdPress(a, 'Enter');
246. await mdType(a, 'milk and bread');
247. await a.waitFor(`document.querySelector('#notes a').textContent === 'Groceries'`, { label: 'sidebar shows the heading as the subject' });
248. const t1 = await taVal(a);
249. check('editor: "# " became a heading, the textarea holds the Markdown', t1 === '# Groceries\n\nmilk and bread' || t1 === '# Groceries\nmilk and bread', J(t1));
250. check('editor: the heading is formatted (h1 in the editor)', await a.evaluate(mdR(`!!r.querySelector('[part~=editor] h1')`)));
251. let sn = await untilServer(cookieA, ns => ns.length === 1 && /^# Groceries/.test(ns[0].text) && /milk and bread$/.test(ns[0].text), 'Groceries');
252. check('online: the note reached the server, which gave it its own id', /^[0-9a-z]{12}$/.test(sn[0].id), J(sn));
253. await a.waitFor(`location.pathname === '/note/${sn[0].id}'`, { label: 'the address follows the server id' });
254. const firstUrl = '/note/' + sn[0].id;
255. await shot(a, 'desktop-one-note');
257. // ---- a second note; the edited one goes to the top ------------------------------------------------------------
258. await a.click('#newnote');
259. await a.waitFor(`/^\\/note\\/l/.test(location.pathname)`, { label: 'second note' });
260. await a.waitFor(`document.getElementById('notetext') && document.getElementById('notetext').value === ''`, { label: 'the second note is empty' });
261. await editorReady(a, 'editor on the second note');
262. await mdClick(a, '[part~=editor]');
263. await mdType(a, 'Zebra facts');
264. await a.waitFor(`document.querySelector('#notes a').textContent === 'Zebra facts'`, { label: 'Zebra on top' });
265. check('sidebar: two notes, the newest edited on top', (await subjects(a)).join('|') === 'Zebra facts|Groceries', J(await subjects(a)));
266. await untilServer(cookieA, ns => ns.length === 2, 'two notes');
267. await a.click(`#notes a[href="${firstUrl}"]`);
268. await a.waitFor(`document.getElementById('notetext').value.startsWith('# Groceries')`, { label: 'Groceries text loaded' });
269. check('sidebar click: the note opens on the right with its text', location_ok(await a.evaluate('location.pathname'), firstUrl));
270. function location_ok(x, y) { return x === y; }
272. // ---- device B (another browser, same login) gets the notes -------------------------------------------------------
273. const b = await newPage();
274. await viewport(b, 1280, 900);
275. await identSignIn(b, '[email protected]');
276. await b.goto(BASE + '/');
277. await hydrated(b);
278. await buttonLogin(b);
279. await b.waitForSelector('#newnote', { timeout: 15000 });
280. await b.waitFor(`document.querySelectorAll('#notes a').length === 2`, { label: 'device B pulled the notes' });
281. check('second device: the same two notes appear after login', (await subjects(b)).join('|') === 'Zebra facts|Groceries', J(await subjects(b)));
282. await b.goto(BASE + firstUrl);
283. await b.waitForSelector('#notetext');
284. await b.waitFor(`document.getElementById('notetext').value.startsWith('# Groceries')`, { label: 'B opened Groceries by its address' });
285. check('second device: a note address opens the note', true);
286. const cookieB = await cookieOf(b);
287. await shellKept(b);
289. // ---- OFFLINE on A: the server is stopped (a real outage) ---------------------------------------------------------
290. await stopServer();
291. await a.goto(BASE + firstUrl);
292. await a.waitForSelector('#notetext', { timeout: 20000 });
293. await a.waitFor(`document.getElementById('notetext').value.startsWith('# Groceries')`, { label: 'offline: the note opens from the browser copy' });
294. check('offline: the page reloads with no server and shows the note and the list', (await subjects(a)).join('|') === 'Zebra facts|Groceries', J(await subjects(a)));
295. await editorReady(a, 'offline editor');
296. await mdClick(a, '[part~=editor] p:last-child');
297. await mdPress(a, 'End', CTRL);
298. await mdType(a, ' and eggs');
299. await a.waitFor(`document.querySelector('#notes a').textContent === 'Groceries'`, { label: 'offline edit moves the note to the top' });
300. await a.click('#newnote');
301. await a.waitFor(`/^\\/note\\/l/.test(location.pathname)`, { label: 'offline: new note' });
302. await editorReady(a, 'offline editor 2');
303. await mdClick(a, '[part~=editor]');
304. await mdType(a, 'Written offline');
305. await a.waitFor(`document.querySelector('#notes a').textContent === 'Written offline'`, { label: 'offline note in the list' });
306. await sleep(1500);
307. await a.waitFor(`/Offline/.test((document.getElementById('syncstate') || {}).textContent || '')`, { label: 'the page says it is offline' });
308. check('offline: the sidebar says the changes are kept here', true);
309. await a.goto(BASE + '/');
310. await a.waitForSelector('#notes a');
311. await a.waitFor(`/Offline/.test((document.getElementById('syncstate') || {}).textContent || '')`, { label: 'offline / says it is offline' });
312. check('offline: a reload of / with the server gone opens the shell (header, brand, logout, the list) and says it is offline (mission 046)',
313. (await txt(a, 'application-header .brand')) === 'notes' && await has(a, '#logout') && await has(a, 'note-list') && /Offline/.test(await txt(a, '#syncstate')));
314. await viewport(a, 390, 844);
315. await shot(a, 'pwa-phone-offline');
316. await viewport(a, 1280, 900);
317. check('offline: after another reload the offline edits are all there', (await subjects(a)).join('|') === 'Written offline|Groceries|Zebra facts', J(await subjects(a)));
318. await a.click('#notes li:nth-child(2) a');
319. await a.waitFor(`document.getElementById('notetext').value.endsWith('milk and bread and eggs')`, { label: 'the offline edit is in the note' });
320. check('offline: the edited text survived the reload', true);
322. // ---- back online: it reaches the server, and device B --------------------------------------------------------------
323. startServer({ IDENT_API_KEY: APPKEY.key, IDENT_API_SECRET: APPKEY.secret });
324. await serverUp();
325. await syncNow(a);
326. sn = await untilServer(cookieA, ns => ns.length === 3 && ns.some(n => /milk and bread and eggs$/.test(n.text)) && ns.some(n => n.text === 'Written offline'), 'the offline edits');
327. check('back online: the offline edit and the offline note reached the server', true, J(sn));
328. await a.waitFor(`[...document.querySelectorAll('#notes a')].every(x => !/\\/note\\/l/.test(x.getAttribute('href')))`, { label: 'the offline note got a server id' });
329. check('back online: the offline note now has a server id', true);
330. await syncNow(b);
331. await b.waitFor(`document.querySelectorAll('#notes a').length === 3`, { label: 'B got the offline note' });
332. await b.waitFor(`document.getElementById('notetext').value.endsWith('and eggs')`, { label: 'B shows the edit in the open note' });
333. check('second device: sees the edit made offline on the first (open note refreshed) and the new note', (await subjects(b)).join('|') === 'Written offline|Groceries|Zebra facts', J(await subjects(b)));
335. // ---- the same note edited on two devices while both are offline: nothing is lost -----------------------------------
336. await b.click('#notes li:nth-child(3) a');
337. await b.waitFor(`document.getElementById('notetext').value === 'Zebra facts'`, { label: 'B opened Zebra' });
338. await a.click('#notes li:nth-child(3) a');
339. await a.waitFor(`document.getElementById('notetext').value === 'Zebra facts'`, { label: 'A opened Zebra' });
340. await stopServer();
341. await editorReady(a, 'A zebra editor');
342. await mdClick(a, '[part~=editor] p:last-child');
343. await mdPress(a, 'End', CTRL);
344. await mdType(a, ' on A');
345. await sleep(1200);
346. await editorReady(b, 'B zebra editor');
347. await mdClick(b, '[part~=editor] p:last-child');
348. await mdPress(b, 'End', CTRL);
349. await mdType(b, ' on B');
350. await sleep(300);
351. startServer({ IDENT_API_KEY: APPKEY.key, IDENT_API_SECRET: APPKEY.secret });
352. await serverUp();
353. await syncNow(a);
354. await syncNow(b);
355. sn = await untilServer(cookieA, ns => ns.length === 4, 'the conflict copy');
356. const texts = sn.map(n => n.text);
357. check('conflict: the later edit (B) is the note, the other (A) is kept as a copy — nothing lost', texts.includes('Zebra facts on B') && texts.some(t => t.startsWith('Zebra facts on A') && /kept as a copy/.test(t)), J(texts));
358. await syncNow(a);
359. await a.waitFor(`document.querySelectorAll('#notes a').length === 4`, { label: 'A shows the copy' });
360. check('conflict: both devices end with the same four notes', (await subjects(a)).slice().sort().join('|') === (await subjects(b)).slice().sort().join('|'), J(await subjects(a)) + J(await subjects(b)));
362. // ---- delete on A reaches B -------------------------------------------------------------------------------------------------
363. await a.click('#notes li:nth-child(1) a');
364. await a.waitFor(`!!document.getElementById('notetext')`, { label: 'A opened a note to delete' });
365. const doomed = await a.evaluate('document.getElementById("notetext").value');
366. check('delete: the question is hidden until "Delete note" is clicked', !(await visible(a, '#deleteyes')));
367. await a.click('#delete');
368. await a.waitFor(`document.querySelector('#deleteyes').getBoundingClientRect().width > 0`, { label: 'delete question' });
369. await a.click('#deleteno');
370. await a.waitFor(`document.querySelector('#deleteyes').getBoundingClientRect().width === 0`, { label: 'kept' });
371. check('delete: "Keep" changes nothing', (await subjects(a)).length === 4);
372. await a.click('#delete');
373. await a.waitFor(`document.querySelector('#deleteyes').getBoundingClientRect().width > 0`, { label: 'delete question again' });
374. await a.click('#deleteyes');
375. await a.waitFor(`location.pathname === '/' && document.querySelectorAll('#notes a').length === 3`, { label: 'back to the list, one note less' });
376. check('delete: the note is gone from the list and the page is the list again', await has(a, '#pick'));
377. await untilServer(cookieA, ns => ns.length === 3 && !ns.some(n => n.text === doomed), 'the delete');
378. await syncNow(b);
379. await b.waitFor(`document.querySelectorAll('#notes a').length === 3`, { label: 'B follows the delete' });
380. check('delete: the other device follows', true);
382. // ---- somebody else sees nothing of it ----------------------------------------------------------------------------------------
383. const bob = await newPage();
384. await viewport(bob, 1280, 900);
385. await identSignIn(bob, '[email protected]');
386. await bob.goto(BASE + '/');
387. await hydrated(bob);
388. await buttonLogin(bob);
389. await bob.waitForSelector('#newnote', { timeout: 15000 });
390. await sleep(800);
391. check('another user: an empty list', (await subjects(bob)).length === 0);
392. const cookieBob = await cookieOf(bob);
393. const alicePick = (await serverNotes(cookieA))[0];
394. const aliceId = alicePick.id;
395. check("another user: alice's note is not in bob's API", (await apiGet('/api/notes?id=' + aliceId, cookieBob)).status === 404 && (await apiGet('/api/notes', cookieBob)).json.notes.length === 0);
396. await apiPost({ op: 'save', id: aliceId, local: '', text: 'hacked', base: 0, at: 1 }, cookieBob);
397. await apiPost({ op: 'delete', id: aliceId, base: 0 }, cookieBob);
398. check("another user: saving over / deleting alice's note does not touch it", (await serverNotes(cookieA)).some(n => n.id === aliceId && n.text === alicePick.text));
399. check('a note over the size limit is refused, not cut', (await apiPost({ op: 'save', id: '', local: 'x1', text: 'x'.repeat(200001), base: 0, at: 1 }, cookieA)).status === 400);
400. check('the API refuses invalid JSON and wrong fields with 400', (await apiPost('{nope', cookieA)).status === 400 && (await apiPost({ op: 'save', id: 5 }, cookieA)).status === 400 && (await apiPost({ op: 'zap' }, cookieA)).status === 400);
401. // a retried push (the answer was lost) does not make a second note
402. await apiPost({ op: 'save', id: '', local: 'lretry', text: 'retry me', base: 0, at: 5 }, cookieA);
403. await apiPost({ op: 'save', id: '', local: 'lretry', text: 'retry me', base: 0, at: 5 }, cookieA);
404. check('a push repeated after a lost answer makes no second note', (await serverNotes(cookieA)).filter(n => n.text === 'retry me').length === 1);
406. // ---- phone and desktop layout ----------------------------------------------------------------------------------------------------
407. await a.goto(BASE + '/');
408. await a.waitForSelector('#notes a');
409. await viewport(a, 390, 844);
410. check('phone: the list alone, no note', await visible(a, 'note-list') && !(await visible(a, 'note-reader')) && await noOverflow(a));
411. await shot(a, 'phone-list');
412. await a.click('#notes a');
413. await a.waitForSelector('#notetext');
414. await editorReady(a, 'phone editor');
415. check('phone: the opened note replaces the list, with a way back', !(await visible(a, 'note-list')) && await visible(a, 'note-editor') && await visible(a, '.back') && await noOverflow(a));
416. await shot(a, 'phone-note');
417. await a.click('.back');
418. await a.waitFor(`location.pathname === '/' && document.querySelector('note-list').getBoundingClientRect().width > 0`, { label: 'phone: back to the list' });
419. check('phone: "All notes" brings the list back', await visible(a, 'note-list') && !(await visible(a, 'note-reader')));
420. await viewport(a, 1280, 900);
421. await a.click('#notes a');
422. await editorReady(a, 'desktop editor');
423. check('desktop: list and note side by side, no "All notes" link', await visible(a, 'note-list') && await visible(a, 'note-editor') && !(await visible(a, '.back')) && await noOverflow(a));
424. await shot(a, 'desktop-two');
426. // ---- log out: the browser forgets the notes ---------------------------------------------------------------------------------------
427. await a.click('#logout');
428. await a.waitForSelector('#loginhint');
429. check('log out: the notes are gone from the page, the login hint shows', !(await has(a, '#notes')) && await has(a, '#loginbutton'));
430. await sleep(500);
431. check('log out: this browser deleted its copy of the notes', await a.evaluate(`(async () => (await indexedDB.databases()).filter(d => /^notes-/.test(d.name)).length === 0 && !localStorage.getItem('notes.user'))()`));
432. check('the server logged no error', !/error|Error/.test(log.replace(/error absorbed/g, '')), log.slice(-400));
433. } catch (e) {
434. console.log('FAIL gate crashed — ' + (e && e.stack || e));
435. failures++;
436. console.log(log.slice(-1500));
437. } finally {
438. for (const b of browsers) { try { await b.close(); } catch {} }
439. await stopServer();
440. if (ident) await ident.stop();
441. console.log(`${passes} passed, ${failures} failed`);
442. process.exit(failures ? 1 : 0);
443. }