gitoria

95.1 KB

1. // tests/browser.mjs — THE GATE of gitoria.worldapi.org (ticket #6: repos with their own address).
2. // Its own gitoria server on its own storage, its OWN ident (a copy of ident's code without .env —
3. // codes go to a mail sink, tests/identkit.mjs), real headless Chromes for everything visible.
4. // `*.gitoria.test` is mapped to 127.0.0.1 inside Chrome (--host-resolver-rules), so a repo really
5. // lives at http://<slug>.gitoria.test:<port>/ — the same mechanism as <slug>.gitoria.worldapi.org.
6. //
7. // node tests/browser.mjs (GITORIA_GATE_PORT server, default 8700; GITORIA_GATE_IDENT_PORT, default 8701;
8. // GITORIA_GATE_CHROME "8702-8709" = Chrome debug ports)
9. // Screenshots (390 / 1280 px) land in .scratch/gate-*.png. Every process started is stopped by PID.
10. import { spawn, execFileSync } from 'node:child_process';
11. import { request as httpRequest } from 'node:http';
12. import { rmSync, mkdirSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
13. import { dirname, join, resolve } from 'node:path';
14. import { fileURLToPath } from 'node:url';
15. import { launchBrowser } from './cdp.mjs';
16. import { launchFirefox } from './firefox.mjs';
17. import { startIdent } from './identkit.mjs';
18. import { startTickets } from './ticketskit.mjs';
20. if (!process.env.HL_CHROME && existsSync('/opt/google/chrome/chrome')) process.env.HL_CHROME = '/opt/google/chrome/chrome';
21. const HERE = dirname(fileURLToPath(import.meta.url));
22. const APP = resolve(HERE, '..');
23. const BIN = join(APP, 'bin/hybriel');
24. const PORT = Number(process.env.GITORIA_GATE_PORT || 8700);
25. const IDENT_PORT = Number(process.env.GITORIA_GATE_IDENT_PORT || 8701);
26. const API = `http://127.0.0.1:${PORT}`; // node's view of the server
27. const BASE = `http://gitoria.test:${PORT}`; // the browser's view: the main address
28. // ident as the BROWSER sees it: same site as gitoria.test (the selector's fetch carries ident's Lax cookie only same-site)
29. const IDENT_B = `http://ident.gitoria.test:${IDENT_PORT}`;
30. const REPO = (slug) => `http://${slug}.gitoria.test:${PORT}`;
31. const TICKETS_PORT = Number(process.env.GITORIA_GATE_TICKETS_PORT || 8702);
32. const FIREFOX_PORT = Number(process.env.GITORIA_GATE_FIREFOX || 8699); // WebDriver BiDi port of the gate's Firefox
33. const [CH_FROM, CH_TO] = (process.env.GITORIA_GATE_CHROME || '8703-8709').split('-').map(Number);
34. process.env.HL_CHROME_ARGS = '--host-resolver-rules=MAP *.gitoria.test 127.0.0.1, MAP gitoria.test 127.0.0.1';
35. const SCRATCH = join(APP, '.scratch');
36. const STORE = join(SCRATCH, 'gate-store');
37. const ORIGINS = ['alpha', 'beta-2', 'gamma'].map(x => `http://${x}.gitoria.test:${PORT}`).join(',');
38. const TICKETS_DIR = process.env.GITORIA_GATE_TICKETS_DIR || [resolve(APP, '../tickets.worldapi.org'), '/media/STORAGE/projects/tickets.worldapi.org'].find(d => existsSync(join(d, 'project.hl')));
39. const IDENT_DIR = process.env.GITORIA_GATE_IDENT_DIR || [resolve(APP, '../ident.worldapi.org'), '/media/STORAGE/projects/ident.worldapi.org'].find(d => existsSync(join(d, 'project.hl')));
40. rmSync(STORE, { recursive: true, force: true });
41. mkdirSync(STORE, { recursive: true });
43. let failures = 0, passes = 0;
44. function check(label, ok, detail = '') {
45. console.log(`${ok ? 'ok ' : 'FAIL'} ${label}${ok ? '' : ' — ' + detail}`);
46. if (ok) passes++; else failures++;
47. }
48. const sleep = (ms) => new Promise(r => setTimeout(r, ms));
49. const J = JSON.stringify;
50. const XSS = '</script><b id="xss">x</b><script>window.__xss=1</script>';
51. let log = '';
52. let server = null, ident = null, tickets = null, ff = null;
53. const browsers = [];
55. function startServer(extraEnv = {}) {
56. log += '\n==== gitoria server start\n';
57. server = spawn(BIN, ['project.hl'], {
58. cwd: APP,
59. env: { ...process.env, GITORIA_PORT: String(PORT), GITORIA_STORAGE: join(STORE, 'mpackdb'), GITORIA_SESSIONS: join(STORE, 'sessions') + '/', GITORIA_WATCH: '0', GITORIA_GIT: join(STORE, 'git'),
60. GITORIA_PUBLIC_URL: BASE, IDENT_URL: IDENT_B, IDENT_EXCHANGE_URL: ident.base, ...extraEnv },
61. stdio: ['ignore', 'pipe', 'pipe'],
62. });
63. server.stdout.on('data', d => log += d); server.stderr.on('data', d => log += d);
64. }
65. async function serverUp() {
66. for (let i = 0; i < 80; i++) { try { const r = await fetch(API + '/api/repos'); if (r.ok) return; } catch {} await sleep(250); }
67. throw new Error('gitoria did not come up\n' + log);
68. }
69. async function stopServer() {
70. if (!server) return;
71. try { server.kill('SIGTERM'); } catch {}
72. await new Promise(r => { if (server.exitCode !== null || server.signalCode !== null) return r(); server.once('exit', r); setTimeout(r, 3000); });
73. server = null;
74. }
76. const SLOW = Number(process.env.GITORIA_GATE_SLOW || 3);
77. function patient(page) {
78. const waitFor = page.waitFor.bind(page);
79. page.waitFor = (expr, o = {}) => waitFor(expr, { ...o, timeout: (o.timeout || 10000) * SLOW });
80. const goto = page.goto.bind(page);
81. page.goto = (url, o = {}) => goto(url, { ...o, timeout: (o.timeout || 15000) * SLOW });
82. return page;
83. }
84. async function newPage() {
85. const b = await launchBrowser({ debugPortRange: [CH_FROM, CH_TO] });
86. browsers.push(b);
87. return patient(await b.newPage());
88. }
89. async function viewport(page, width, height) {
90. await page.send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: width < 600 });
91. await sleep(250);
92. }
93. async function shot(page, name) {
94. const { data } = await page.send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true });
95. writeFileSync(join(SCRATCH, `gate-${name}.png`), Buffer.from(data, 'base64'));
96. }
97. const noOverflow = (page) => page.evaluate('document.documentElement.scrollWidth <= window.innerWidth');
98. const hydrated = (page) => page.waitFor('!!window.__hl && window.__hl.socket && window.__hl.socket.readyState === 1', { label: 'page hydrated' });
99. const txt = (page, sel) => page.evaluate(`(document.querySelector(${J(sel)}) || {}).textContent || null`);
100. const has = (page, sel) => page.evaluate(`!!document.querySelector(${J(sel)})`);
102. // INSIDE ident's selector (shadow DOM): an expression over its root `r`, and a REAL click (as in tickets' gate)
103. const sh = (expr) => `(() => { const h = document.querySelector('#selector'); const r = h && h.shadowRoot; if (!r) return null; return (${expr}); })()`;
104. async function shClick(page, inner, name = null) {
105. const find = `(() => { const h = document.querySelector('#selector'); const r = h && h.shadowRoot; if (!r) return null; const el = ${name === null ? `r.querySelector(${J(inner)})` : `[...r.querySelectorAll(${J(inner)})].find(b => b.textContent === ${J(name)})`}; if (!el) return null; el.scrollIntoView({ block: 'center' }); const b = el.getBoundingClientRect(); if (!b.width) return null; return { x: b.left + b.width / 2, y: b.top + b.height / 2 }; })()`;
106. const box = await page.waitFor(find, { label: 'selector ' + inner + ' ' + (name || '') });
107. const at = { x: Math.round(box.x), y: Math.round(box.y), button: 'left', clickCount: 1 };
108. await page.send('Input.dispatchMouseEvent', { type: 'mouseMoved', ...at, buttons: 0 });
109. await page.send('Input.dispatchMouseEvent', { type: 'mousePressed', ...at, buttons: 1 });
110. await page.send('Input.dispatchMouseEvent', { type: 'mouseReleased', ...at, buttons: 0 });
111. }
112. async function identSignIn(page, email) {
113. await page.goto(IDENT_B + '/');
114. await page.waitForSelector('#email');
115. await hydrated(page);
116. await page.type('#email', email);
117. await page.click('#sendcode');
118. // ident#20: a sent code NAVIGATES to ident's /code page; type only once that page is hydrated
119. await page.waitFor('/\\/code$/.test(location.pathname) && !!document.querySelector("#code")', { label: 'ident /code page' });
120. await hydrated(page);
121. await page.type('#code', ident.lastCode(email));
122. await page.click('#verify');
123. await page.waitForSelector('#signout', { timeout: 10000 });
124. }
125. // the login button of the page we are on → ident's "choose an identity" → back
126. async function buttonLogin(page) {
127. await page.click('#loginbutton');
128. await page.waitForSelector('#chooselist', { timeout: 10000 });
129. await hydrated(page);
130. await page.click('#chooselist li:nth-child(1) .choose');
131. }
132. async function nameIt(page, name) {
133. await page.waitForSelector('#nameform');
134. await hydrated(page);
135. await page.type('#displayname', name);
136. await page.click('#namesave');
137. await page.waitFor('!document.querySelector("#nameform")', { label: 'name saved' });
138. }
139. async function createRepo(page, slug, description) {
140. await page.evaluate('document.querySelector("#slug").value = ""; document.querySelector("#description").value = ""');
141. await page.type('#slug', slug);
142. if (description) await page.type('#description', description);
143. await page.click('#createsave');
144. }
145. // the FIRST HTML of a page as the server sends it, for any Host (node's fetch cannot set Host) — gitoria#16
146. const firstHtml = (path, host, cookie) => new Promise((res, rej) => {
147. const rq = httpRequest({ host: '127.0.0.1', port: PORT, path, headers: { host, ...(cookie ? { cookie } : {}) } }, (r) => {
148. let b = ''; r.setEncoding('utf8'); r.on('data', d => b += d); r.on('end', () => res({ status: r.statusCode, headers: r.headers, body: b }));
149. });
150. rq.on('error', rej); rq.end();
151. });
152. const bodyText = (html) => ((html.match(/<body>([\s\S]*)<\/body>/) || [])[1] || '').replace(/<script[\s\S]*?<\/script>/g, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ');
153. const emitFace = async (event, payload, cookie) => {
154. const r = await fetch(API + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', ...(cookie ? { cookie } : {}) }, body: J({ t: 'emit', i: 1, event, payload }) });
155. const t = await r.text(); let j = null; try { j = JSON.parse(t); } catch {}
156. return { status: r.status, raw: t, value: j && j.value };
157. };
159. try {
160. // ---- our own ident; gitoria is registered with ONE origin: the main address ------------------------
161. ident = await startIdent({ identDir: IDENT_DIR, workDir: join(STORE, 'ident'), port: IDENT_PORT });
162. const alice = await ident.signIn('[email protected]');
163. const gateAcct = await ident.signIn('[email protected]');
164. const APPKEY = await ident.registerApp(alice, 'gitoria (gate)', [BASE]);
165. check('ident: our own ident runs (a copy without .env), gitoria is registered', /^pk_[0-9a-f]{32}$/.test(APPKEY.key) && !existsSync(join(STORE, 'ident', 'ident-code', '.env')));
166. // our own tickets (a copy without .env), with a token for its user "gitoria" — gitoria opens tickets with it
167. tickets = await startTickets({ ticketsDir: TICKETS_DIR, workDir: join(STORE, 'tickets'), port: TICKETS_PORT, ident, who: alice, origins: ORIGINS });
168. check('tickets: our own tickets runs (a copy without .env), gitoria has an API token', /^tkt_[0-9a-f]{48}$/.test(tickets.token) && !existsSync(join(STORE, 'tickets', 'tickets-code', '.env')));
169. const env = { IDENT_API_KEY: APPKEY.key, IDENT_API_SECRET: APPKEY.secret, GITORIA_TICKETS_URL: tickets.base };
170. startServer(env);
171. await serverUp();
173. // ---- the API (reads are public) --------------------------------------------------------------
174. let r = await fetch(API + '/api/repos');
175. check('api: GET /api/repos is empty at the start', r.status === 200 && J(await r.json()) === '{"repos":[]}');
176. r = await fetch(API + '/api/repos', { method: 'POST', body: '{}' });
177. check('api: POST /api/repos → 405 (creating is a web action)', r.status === 405);
178. r = await fetch(API + '/api/repos/nothing');
179. check('api: unknown repo → 404', r.status === 404);
180. r = await fetch(API + '/api/repos', { headers: { accept: 'text/markdown' } });
181. check('api: Markdown read view of the list', /text\/markdown/.test(r.headers.get('content-type')) && /^# Repositories \(0\)/.test(await r.text()));
183. // ---- the login button's server half: where does ?next= lead? ------------------------------------
184. const cbCookie = 'gitoriasid=' + 'ab'.repeat(16);
185. // a failed login is a PAGE now (components/loginfailed.hl, gitoria#16): the reason is parked in the session → /login/failed
186. const failedPage = async (url) => {
187. const c = await fetch(url, { redirect: 'manual' });
188. const ck = (c.headers.get('set-cookie') || '').split(';')[0];
189. const pg = await firstHtml('/login/failed', `gitoria.test:${PORT}`, ck);
190. return { status: c.status, location: c.headers.get('location'), cookie: ck, page: bodyText(pg.body), pageStatus: pg.status };
191. };
192. let lf = await failedPage(API + '/login/callback');
193. check('login: /login/callback without a code → /login/failed says "ident sent no login code"', lf.status === 302 && lf.location === '/login/failed' && lf.pageStatus === 200 && /Login failed/.test(lf.page) && /ident sent no login code/.test(lf.page), J(lf));
194. lf = await failedPage(API + '/login/callback?ident_code=' + 'ab'.repeat(24));
195. check('login: an unknown code → /login/failed says "ident refused"', lf.status === 302 && lf.location === '/login/failed' && /ident refused/.test(lf.page), J(lf));
196. const nexts = [
197. ['/', '/'], ['/x?y=1', '/x?y=1'], [REPO('alpha') + '/code', REPO('alpha') + '/code'], [REPO('alpha') + '/', REPO('alpha') + '/'], [REPO('alpha'), REPO('alpha') + '/'],
198. ['//evil.example', '/'], ['http://evil.example/', '/'], [REPO('www') + '/', '/'], [`http://alpha.gitoria.test:${PORT}.evil.example/`, '/'],
199. [REPO('alpha') + '/a b', '/'], [REPO('a--b') + '/', '/'], [REPO('Alpha') + '/', '/'], ['/x\r\nSet-Cookie: a=b', '/'], ['/login/callback', '/'], ['', '/'],
200. [`https://alpha.gitoria.test:${PORT}/`, '/'], [`http://x.y.gitoria.test:${PORT}/`, '/'],
201. ];
202. let allNext = true, nextDetail = '';
203. for (const [want, expect] of nexts) {
204. const code = await ident.selectorCode(gateAcct, APPKEY, BASE);
205. const c = await fetch(API + '/login/callback?next=' + encodeURIComponent(want) + '&ident_code=' + code, { redirect: 'manual' });
206. const loc = c.headers.get('location');
207. if (c.status !== 302 || loc !== expect) { allNext = false; nextDetail += ` [${J(want)} → ${c.status} ${loc}, wanted ${expect}]`; }
208. }
209. check('login: ?next= accepts a path or a valid repo address, everything else → /', allNext, nextDetail);
210. const cookieCode = await ident.selectorCode(gateAcct, APPKEY, BASE);
211. const cc = await fetch(API + '/login/callback?ident_code=' + cookieCode, { redirect: 'manual' });
212. const setCookie = cc.headers.get('set-cookie') || '';
213. check('login: the session cookie is shared by every repo address (Domain=.gitoria.test)', /^gitoriasid=[0-9a-f]{32};/.test(setCookie) && /Domain=\.gitoria\.test/.test(setCookie) && /HttpOnly/.test(setCookie), setCookie);
215. // ---- the re-vendored Hybriel (mission 033): what the dropped local patches did is upstream now ------------
216. r = await fetch(API + '/__hl/app.css');
217. const css = await r.text();
218. check('styles: /__hl/app.css is 200 and the token file\'s var() tokens are in :root and used (hybriel#39 upstream)', r.status === 200 && /:root\s*\{[^}]*--dark\s*:/.test(css) && /var\(--/.test(css), css.slice(0, 200));
220. // ---- forged face session: nobody logged in may create --------------------------------------------
221. let f = await emitFace('gitoriaCreate', ['forged', '', { user: { id: 'x' } }]);
222. check('face: a forged trailing session argument creates nothing', !(await (await fetch(API + '/api/repos/forged')).ok) && !(f.value && f.value.repo), f.raw);
223. f = await emitFace('gitoriaCreate', ['anon', '']);
224. check('face: not logged in → refused with a message', f.value && /log in/.test(f.value.error || ''), f.raw);
226. // ---- A = alice in a browser -----------------------------------------------------------------------
227. const A = await newPage();
228. await identSignIn(A, '[email protected]');
229. await A.goto(BASE + '/');
230. await A.waitFor('!!document.querySelector("#heading")', { label: 'main address shows the list' });
231. await hydrated(A);
232. check('main address: "Repositories", empty list, hint to log in, no create form', (await txt(A, '#heading')) === 'Repositories' && (await has(A, '#empty')) && (await has(A, '#loginhint')) && !(await has(A, '#createform')));
233. check('signed out: the login button goes to ident /login with the app key and the callback', (await A.evaluate('document.querySelector("#loginbutton").getAttribute("href")')) === `${IDENT_B}/login?key=${APPKEY.key}&return=${encodeURIComponent(BASE + '/login/callback')}`);
234. await buttonLogin(A);
235. await A.waitFor(`location.href === ${J(BASE + '/')} && !!document.querySelector("#nameform")`, { label: 'A back with the name prompt' });
236. check('button: back on the main address, logged in, asked for a display name', await has(A, '#whoami') && !(await has(A, '#loginbutton')));
237. await nameIt(A, 'alice');
238. await A.waitForSelector('#createform');
239. check('named: the "create a repository" form appears', (await txt(A, '#whoami')) === 'alice');
241. // ---- B = a signed-out viewer of the main address, for the live list ---------------------------------
242. const B = await newPage();
243. await B.goto(BASE + '/');
244. await B.waitForSelector('#empty');
245. await hydrated(B);
247. // ---- create ---------------------------------------------------------------------------------------
248. const errAfter = async (slug, want) => {
249. await createRepo(A, slug, '');
250. await A.waitFor(`new RegExp(${J(want)}).test(document.querySelector("#createerror").textContent)`, { label: 'error for ' + slug });
251. const e = await txt(A, '#createerror');
252. check(`create: "${slug}" is refused — ${want}`, new RegExp(want).test(e), e);
253. return e;
254. };
255. await errAfter('Bad Slug', 'only have lowercase');
256. await errAfter('www', 'reserved');
257. await errAfter('ab-', 'starts and ends');
258. await errAfter('ab--cd', 'two hyphens');
259. await errAfter('-abc', 'starts and ends');
260. check('create: nothing was stored by the refusals', J(await (await fetch(API + '/api/repos')).json()) === '{"repos":[]}');
261. await A.evaluate('document.querySelector("#createerror").textContent = ""');
262. await createRepo(A, 'alpha', 'The first repository');
263. await A.waitForSelector('#created');
264. check('create: "alpha" is created, the page says so and links to its address', /alpha/.test(await txt(A, '#created')) && (await A.evaluate('document.querySelector("#createdlink").href')) === REPO('alpha') + '/');
265. check('create: the list shows alpha with description, owner alice and time', await A.evaluate(`(() => { const li = document.querySelector('#repos li'); return !!li && /alpha/.test(li.textContent) && /The first repository/.test(li.textContent) && /alice/.test(li.textContent) && /\\d{4}-\\d\\d-\\d\\d \\d\\d:\\d\\d/.test(li.textContent) && li.querySelector('a').href === ${J(REPO('alpha') + '/')}; })()`), await A.evaluate('document.querySelector("#repos li").outerHTML'));
266. await B.waitFor('document.querySelectorAll("#repos li").length === 1', { label: 'B sees alpha live' });
267. check('live: the signed-out viewer B sees alpha without a reload', /alpha/.test(await txt(B, '#repos')) && !(await has(B, '#empty')));
268. await errAfter('alpha', 'taken');
269. await A.evaluate('document.querySelector("#createerror").textContent = ""');
270. await createRepo(A, 'beta-2', '');
271. await A.waitFor('document.querySelectorAll("#repos li").length === 2', { label: 'A: two repos' });
272. await B.waitFor('document.querySelectorAll("#repos li").length === 2', { label: 'B: two repos' });
273. check('create: a second repo (with a hyphen) and the list is newest first', (await A.evaluate('[...document.querySelectorAll("#repos .slug")].map(a => a.textContent).join()')) === 'beta-2,alpha');
274. r = await fetch(API + '/api/repos/alpha');
275. const alphaRow = await r.json();
276. check('api: GET /api/repos/alpha = slug, description, owner, address', alphaRow.slug === 'alpha' && alphaRow.description === 'The first repository' && alphaRow.owner === 'alice' && alphaRow.address === REPO('alpha') + '/' && /^[0-9a-z]{12}$/.test(alphaRow.id), J(alphaRow));
277. r = await fetch(API + '/api/repos/alpha', { headers: { accept: 'text/markdown' } });
278. const md = await r.text();
279. check('api: Markdown read view of a repo', /^# alpha\n/.test(md), md);
281. // ---- the address: <slug>.gitoria.test ------------------------------------------------------------------
282. await A.goto(REPO('alpha') + '/');
283. await A.waitFor('!!document.querySelector("#reponame")', { label: 'alpha at its own address' });
284. check('alpha.<domain> shows that repo: name, description, address, owner', (await txt(A, '#reponame')) === 'alpha' && (await txt(A, '#repodescription')) === 'The first repository' && (await txt(A, '#repoaddress')) === REPO('alpha') + '/' && (await txt(A, '#repoowner')) === 'alice' && !(await has(A, '#createform')), await A.evaluate('document.querySelector("repo-home").innerText'));
285. check('alpha.<domain>: the login is shared with the main address (same cookie)', (await txt(A, '#whoami')) === 'alice');
286. check('alpha.<domain>: the title is the repo page, tab title set', (await A.evaluate('document.title')) !== '');
287. await A.goto(REPO('nothing-here') + '/');
288. await A.waitFor('!!document.querySelector("#missing")', { label: 'unknown address' });
289. check('an address nobody created → "No such repository" with a link to the main address', (await txt(A, '#missing')) === 'No such repository' && (await A.evaluate('document.querySelector("#toall").href')) === BASE + '/');
290. await A.goto(REPO('www') + '/');
291. await A.waitFor('!!document.querySelector("#missing")', { label: 'reserved address' });
292. check('a reserved address is no repo either', true);
293. await A.goto(BASE + '/');
294. await A.waitFor('!!document.querySelector("#repos li")', { label: 'back on main' });
295. await A.click('#repos li:nth-child(2) .slug');
296. await A.waitFor(`location.hostname === 'alpha.gitoria.test' && !!document.querySelector("#reponame")`, { label: 'click on alpha' });
297. check('clicking a repo in the list opens its own address', (await txt(A, '#reponame')) === 'alpha');
299. // ---- login FROM a repo address: through the main address and back --------------------------------------
300. await identSignIn(B, '[email protected]');
301. await B.goto(REPO('alpha') + '/');
302. await B.waitFor('!!document.querySelector("#reponame")', { label: 'B at alpha' });
303. check('signed out at alpha.<domain>: repo visible, login button there', (await has(B, '#loginbutton')) && !(await has(B, '#whoami')));
304. await hydrated(B);
305. await buttonLogin(B);
306. await B.waitFor(`location.href === ${J(REPO('alpha') + '/')} && !!document.querySelector("#whoami")`, { label: 'B logged in back at alpha' });
307. await B.waitFor('!!document.querySelector("#reponame")', { label: 'B: the repo page after the login' });
308. check('login started at alpha.<domain> returns to alpha.<domain>, logged in', (await txt(B, '#whoami')) === 'alice' && (await txt(B, '#reponame')) === 'alpha', await B.evaluate('location.href + " " + document.body.innerText.slice(0, 300)'));
309. await B.goto(BASE + '/');
310. await B.waitForSelector('#createform');
311. check('the same login holds on the main address (cookie for all addresses)', (await txt(B, '#whoami')) === 'alice');
313. // ---- the homepage of a repo (ticket #8): README.md, or the $docs folder --------------------------------------
314. check('a new repo has an empty bare git repository', existsSync(join(STORE, 'git', 'alpha.git', 'HEAD')), J(existsSync(join(STORE, 'git'))));
315. const pushFiles = (slug, files) => { // a commit into the bare repo, the way a push would leave it
316. const work = join(STORE, 'work-' + slug);
317. rmSync(work, { recursive: true, force: true }); mkdirSync(work, { recursive: true });
318. const git = (...a) => execFileSync('git', ['-C', work, '-c', 'user.name=t', '-c', '[email protected]', ...a], { stdio: 'pipe' });
319. git('init', '-q', '-b', 'main');
320. for (const [p, c] of Object.entries(files)) { mkdirSync(dirname(join(work, p)), { recursive: true }); writeFileSync(join(work, p), c); }
321. git('add', '-A'); git('commit', '-q', '-m', 'files');
322. git('push', '-q', '-f', join(STORE, 'git', slug + '.git'), 'main');
323. };
324. const homeText = async (p) => { await p.waitFor('!document.querySelector("#docsloading") && (!!document.querySelector("#homepage") || !!document.querySelector("#nohomepage"))', { label: 'homepage answer' }); return await p.evaluate('document.body.innerText'); };
325. await A.goto(REPO('alpha') + '/');
326. check('an empty repo says it has no README.md yet', /no README\.md yet/.test(await homeText(A)));
327. pushFiles('alpha', {
328. 'README.md': '# Alpha project\n\nSome **strong** and *soft* text with `code` and a [link](https://example.org/x).\n\n- one\n- two\n\n> quoted words\n\n| Name | Value |\n|---|---|\n| a | 1 |\n| b | 2 |\n\n---\n\n```\nlet x = 1 < 2\n```\n\n<script>window.__pwned = 1</script>\n\n[bad](javascript:alert(1))\n',
329. 'docs/other.md': '# not the homepage\n',
330. });
331. await A.goto(REPO('alpha') + '/');
332. const alphaText = await homeText(A);
333. check('/ shows README.md as HTML: heading, strong, list, quote, table, rule, code block', await A.evaluate(`(() => { const m = document.querySelector('#homepage markdown-text'); return !!m && m.querySelector('h2')?.textContent === 'Alpha project' && m.querySelector('strong')?.textContent === 'strong' && m.querySelectorAll('ul li').length === 2 && m.querySelector('blockquote')?.textContent.trim() === 'quoted words' && m.querySelectorAll('table tr').length === 3 && m.querySelector('td')?.textContent === 'a' && !!m.querySelector('hr') && m.querySelector('pre code')?.textContent === 'let x = 1 < 2'; })()`), alphaText.slice(0, 400));
334. check('README links are real links; javascript: and raw HTML stay text', await A.evaluate(`(() => { const m = document.querySelector('#homepage markdown-text'); return m.querySelector('a').getAttribute('href') === 'https://example.org/x' && !m.querySelector('script') && !window.__pwned && m.textContent.includes('<script>window.__pwned = 1</script>') && m.textContent.includes('[bad](javascript:alert(1))') && ![...m.querySelectorAll('a')].some(a => /javascript/.test(a.getAttribute('href'))); })()`));
335. pushFiles('alpha', {
336. 'README.md': '# Root readme\n',
337. '$docs/b-second.md': '# Second doc\n\nText two.\n',
338. '$docs/a-first.md': '# First doc\n\nText one.\n',
339. '$docs/sub/c-third.md': '## Third doc\n',
340. '$docs/notes.txt': 'not markdown\n',
341. });
342. await A.goto(REPO('alpha') + '/');
343. await homeText(A);
344. check('with a $docs folder its Markdown files form the homepage (in path order), the root README does not', await A.evaluate(`(() => { const h = [...document.querySelectorAll('#homepage h2, #homepage h3')].map(x => x.textContent).join('|'); return h === 'First doc|Second doc|Third doc' && !document.body.innerText.includes('Root readme') && !document.body.innerText.includes('not markdown'); })()`), await A.evaluate('document.body.innerText.slice(0, 400)'));
345. check('the homepage of another repo is untouched (beta-2 has no README.md)', await (async () => { await A.goto(REPO('beta-2') + '/'); return /no README\.md yet/.test(await homeText(A)); })());
346. for (const [w, h, name] of [[390, 844, 'narrow'], [1280, 900, 'wide']]) {
347. await viewport(A, w, h);
348. pushFiles('beta-2', { 'README.md': '# Wide table\n\n| a | b | c | d | e | f | g | h |\n|---|---|---|---|---|---|---|---|\n| aaaaaaaaaaaaaaa | bbbbbbbbbbbbbbbbb | cccccccccccccccccc | ddddddddddddddd | eeeeeeeeeeeeeee | ffffffffffffffff | ggggggggggggggg | hhhhhhhhhhhhhhh |\n\nhttps://example.org/a/very/long/url/that/should/wrap/somewhere/because/it/is/really/quite/long/indeed\n' });
349. await A.goto(REPO('beta-2') + '/');
350. await homeText(A);
351. check(`layout ${w}px: the homepage has no horizontal overflow`, await noOverflow(A));
352. await shot(A, `${name}-home`);
353. }
355. // ---- browsing code (ticket #9): /code, /branch/<name>, /commit/<id> ------------------------------------------
356. const gitIn = (work, ...a) => execFileSync('git', ['-C', work, '-c', 'user.name=t', '-c', '[email protected]', ...a], { stdio: 'pipe' }).toString();
357. const work = join(STORE, 'work-code');
358. rmSync(work, { recursive: true, force: true }); mkdirSync(join(work, 'src', 'deep'), { recursive: true });
359. gitIn(work, 'init', '-q', '-b', 'main');
360. writeFileSync(join(work, 'README.md'), '# Code repo\n');
361. writeFileSync(join(work, 'src', 'a.txt'), 'line one\n\n indented <b>&amp;</b>\n');
362. writeFileSync(join(work, 'src', 'deep', 'b.txt'), 'deep file\n');
363. writeFileSync(join(work, 'my file.txt'), 'spaced name\n');
364. writeFileSync(join(work, 'bin.dat'), Buffer.from([0, 1, 2, 255, 0, 254, 0, 0]));
365. gitIn(work, 'add', '-A'); gitIn(work, 'commit', '-q', '-m', 'first commit');
366. const firstSha = gitIn(work, 'rev-parse', 'HEAD').trim();
367. writeFileSync(join(work, 'src', 'a.txt'), 'main changed\n');
368. gitIn(work, 'commit', '-qam', 'second on main');
369. const mainSha = gitIn(work, 'rev-parse', 'HEAD').trim();
370. gitIn(work, 'checkout', '-q', '-b', 'feature/x', firstSha);
371. writeFileSync(join(work, 'src', 'a.txt'), 'feature changed\n');
372. writeFileSync(join(work, 'only-feature.txt'), 'f\n');
373. gitIn(work, 'add', '-A'); gitIn(work, 'commit', '-q', '-m', 'feature work');
374. gitIn(work, 'checkout', '-q', '-b', 'dev', firstSha);
375. gitIn(work, 'push', '-q', '-f', join(STORE, 'git', 'alpha.git'), 'main', 'feature/x', 'dev');
376. const codeReady = (p) => p.waitFor('!document.querySelector("#codeloading") && (!!document.querySelector("#codemessage") || !!document.querySelector("#codefile") || !!document.querySelector("#entries") || !!document.querySelector("#noentries"))', { label: 'code answer' });
377. const names = (p, sel) => p.evaluate(`[...document.querySelectorAll(${J(sel)})].map(x => x.textContent.trim()).join('|')`);
378. await viewport(A, 1280, 900);
379. await A.goto(REPO('alpha') + '/code');
380. await codeReady(A);
381. check('/code: the main branch at its last commit (tree: folder first, then files)', await txt(A, '#coderef') === 'main' && (await names(A, '#entries li > :first-child')) === 'src|README.md|bin.dat|my file.txt' && (await txt(A, '#commitsubject')) === 'second on main' && (await txt(A, '#commitlink')) === mainSha.slice(0, 8), await A.evaluate('document.body.innerText.slice(0, 500)'));
382. check('/code: latest commits and branches are listed, the main branch marked', (await names(A, '#commits a')) === mainSha.slice(0, 8) + '|' + firstSha.slice(0, 8) && (await names(A, '#branches li > :first-child')) === 'dev|feature/x|main' && /main branch/.test(await txt(A, '#branches')), await A.evaluate('document.querySelector("#branches").innerText'));
383. await A.click('#entries a.dir');
384. await A.waitFor('location.pathname === "/code/src" && !!document.querySelector("#crumbs strong") && document.querySelector("#crumbs strong").textContent === "src" && !!document.querySelector("#entries")', { label: 'folder opened' });
385. check('a folder link opens the folder (client navigation), crumbs show the path', (await A.evaluate('location.pathname')) === '/code/src' && (await names(A, '#entries li > :first-child')) === 'deep|a.txt' && (await names(A, '#crumbs a, #crumbs strong')) === 'main|src', await A.evaluate('location.pathname + " " + document.body.innerText.slice(0, 300)'));
386. await A.goto(REPO('alpha') + '/code/src/a.txt');
387. await codeReady(A);
388. check('/code/<file>: numbered lines with the exact text (HTML stays text, blank lines kept)', await A.evaluate(`(() => { const li = [...document.querySelectorAll('#lines li')]; return li.length === 1 && li[0].textContent === 'main changed'; })()`), await A.evaluate('document.body.innerText.slice(0, 300)'));
389. await A.goto(REPO('alpha') + '/commit/' + firstSha + '/src/a.txt');
390. await codeReady(A);
391. check('/commit/<id>/<file>: the file as it was at that commit', await A.evaluate(`[...document.querySelectorAll('#lines li')].map(l => l.textContent).join('|')`) === 'line one|| indented <b>&amp;</b>' && (await txt(A, '#codekind')) === 'Commit' && !(await has(A, '#lines script')), await A.evaluate('document.body.innerText.slice(0, 300)'));
392. await A.goto(REPO('alpha') + '/commit/' + firstSha.slice(0, 7));
393. await codeReady(A);
394. check('/commit/<short id>: the whole project at that commit (an old tree, no later file)', (await names(A, '#entries li > :first-child')) === 'src|README.md|bin.dat|my file.txt' && (await txt(A, '#commitsubject')) === 'first commit' && (await txt(A, '#coderef')) === firstSha.slice(0, 8), await A.evaluate('document.body.innerText.slice(0, 300)'));
395. await A.goto(REPO('alpha') + '/branch/feature/x');
396. await codeReady(A);
397. check('/branch/<name with a slash>: that branch at its last commit', (await txt(A, '#coderef')) === 'feature/x' && (await names(A, '#entries li > :first-child')) === 'src|README.md|bin.dat|my file.txt|only-feature.txt' && (await txt(A, '#commitsubject')) === 'feature work', await A.evaluate('document.body.innerText.slice(0, 300)'));
398. await A.goto(REPO('alpha') + '/branch/feature/x/src/a.txt');
399. await codeReady(A);
400. check('/branch/<name>/<file>: the file on that branch', (await names(A, '#lines li')) === 'feature changed', await A.evaluate('document.body.innerText.slice(0, 300)'));
401. await A.goto(REPO('alpha') + '/code/my%20file.txt');
402. await codeReady(A);
403. check('a file with a space in its name opens', (await names(A, '#lines li')) === 'spaced name');
404. await A.goto(REPO('alpha') + '/code/bin.dat');
405. await codeReady(A);
406. check('a binary file is not shown as text', (await has(A, '#binary')) && !(await has(A, '#lines li')));
407. for (const [path, want] of [['/code/nope', /No such path/], ['/branch/nobranch', /no branch 'nobranch'/], ['/commit/deadbeef', /No commit 'deadbeef'/], ['/commit/zz', /No such commit/], ['/code/src/nope/deeper', /No such path/]]) {
408. await A.goto(REPO('alpha') + path);
409. await codeReady(A);
410. check(`${path}: a plain message, no crash`, want.test(await txt(A, '#codemessage') || ''), await A.evaluate('document.body.innerText.slice(0, 200)'));
411. }
412. await A.goto(BASE + '/');
413. await A.waitForSelector('#createform');
414. await hydrated(A);
415. await createRepo(A, 'gamma', XSS);
416. await A.waitFor('!!document.querySelector("#created")', { label: 'gamma created' });
417. await A.goto(REPO('gamma') + '/code');
418. await codeReady(A);
419. check('an empty repo says it has no commits yet', /no commits yet/.test(await txt(A, '#codemessage') || ''), await A.evaluate('document.body.innerText.slice(0, 200)'));
420. // "Add code to this repository" (gitoria#20): stands as plain text, not a collapsible, ONLY on the Code page of an
421. // empty repo (gamma) — checked on every tab of an empty repo AND a filled one (alpha, has commits)
422. check('empty repo /code: "Add code to this repository" stands as plain text (no <details>, no <summary>)', (await has(A, '#addcode')) && (await A.evaluate('document.querySelector("#addcode").tagName')) !== 'DETAILS' && !(await has(A, '#addcode summary')) && (await A.evaluate('!!document.querySelector("#clonecommand").offsetParent')), await A.evaluate('document.querySelector("#addcode") ? document.querySelector("#addcode").outerHTML.slice(0, 150) : "missing"'));
423. const addCodeTabs = [['/', '#nohomepage, #homepage'], ['/pulls', '#pullsmessage, #pullshelp'], ['/releases', '#releasesmessage, #releaseshelp'], ['/tickets', '#ticketsnotconnected, #ticketlist'], ['/settings', '#connecttickets, #notconnected']];
424. for (const [p, sel] of addCodeTabs) {
425. await A.goto(REPO('gamma') + p);
426. await A.waitFor(`!!document.querySelector(${J(sel)})`, { label: 'gamma ' + p + ' for addcode check' });
427. check(`empty repo ${p}: no "Add code" box (only the Code page has it)`, !(await has(A, '#addcode')), await A.evaluate('document.body.innerText.slice(0, 150)'));
428. }
429. for (const [p, sel] of [['/code', '#entries, #codemessage'], ...addCodeTabs]) {
430. await A.goto(REPO('alpha') + p);
431. await A.waitFor(`!!document.querySelector(${J(sel)})`, { label: 'alpha ' + p + ' for addcode check' });
432. check(`filled repo ${p}: no "Add code" box (already has commits)`, !(await has(A, '#addcode')), await A.evaluate('document.body.innerText.slice(0, 150)'));
433. }
434. await A.goto(REPO('alpha') + '/code');
435. await codeReady(A);
436. check('the owner sees "Make main" on the other branches, not on the main one', (await A.evaluate('document.querySelectorAll("#branches .setmain").length')) === 2, await A.evaluate('document.querySelector("#branches").innerText'));
437. await hydrated(A); // the view is in the FIRST HTML now: wait for the page to be live before clicking
438. await A.click('#branches .setmain');
439. await A.waitFor('document.querySelector("#coderef") && document.querySelector("#coderef").textContent === "dev"', { label: 'main branch changed' });
440. check('"Make main" changes the main branch: /code now shows it (kept in the repo record)', (await txt(A, '#coderef')) === 'dev' && (await names(A, '#entries li > :first-child')) === 'src|README.md|bin.dat|my file.txt' && (await txt(A, '#commitsubject')) === 'first commit' && (await (await fetch(API + '/api/repos/alpha')).json()).branch === 'dev', await A.evaluate('document.body.innerText.slice(0, 300)'));
441. await A.goto(REPO('alpha') + '/');
442. await homeText(A);
443. check('the homepage README follows the main branch too', await A.evaluate('!!document.querySelector("#homepage")'));
444. const S = await newPage();
445. await S.goto(REPO('alpha') + '/code');
446. await codeReady(S);
447. check('a signed-out viewer sees the code, but no "Make main"', (await txt(S, '#coderef')) === 'dev' && (await S.evaluate('document.querySelectorAll("#branches .setmain").length')) === 0);
448. const forged = await emitFace('gitoriaSetBranch', ['alpha', 'main', 'code', '', 'x'], '');
449. const still = await (await fetch(API + '/api/repos/alpha')).json();
450. check('face: a stranger cannot change the main branch', still.branch === 'dev', J(forged) + J(still));
451. for (const [w, h, name] of [[390, 844, 'narrow'], [1280, 900, 'wide']]) {
452. await viewport(A, w, h);
453. await A.goto(REPO('alpha') + '/code');
454. await codeReady(A);
455. check(`layout ${w}px: /code has no horizontal overflow`, await noOverflow(A));
456. await shot(A, `${name}-code`);
457. await A.goto(REPO('alpha') + '/code/src/a.txt');
458. await codeReady(A);
459. check(`layout ${w}px: a file view has no horizontal overflow of the page`, await noOverflow(A));
460. await shot(A, `${name}-file`);
461. }
462. await viewport(A, 1280, 900);
464. // the connect flow in the browser: the owner (alice, logged in at tickets with the gate's cookie) clicks "Tickets: connect"
465. // in the repo's settings, picks the project on tickets and continues back to the repo
466. const connectRepo = async (page, slug, projectValue, newTitle) => {
467. const [ck, cv] = tickets.cookie.split('=');
468. await page.send('Network.setCookie', { name: ck, value: cv, url: tickets.base });
469. await page.goto(REPO(slug) + '/settings');
470. await page.waitFor('!!document.querySelector("#connecttickets")', { label: 'settings: connect button' });
471. await page.click('#connecttickets');
472. await page.waitFor('location.origin === ' + J(tickets.base) + ' && !!document.querySelector("#connectform")', { label: 'tickets connect page' });
473. await hydrated(page);
474. if (newTitle) {
475. await page.evaluate('(() => { const s = document.querySelector("#connectproject"); s.value = ""; s.dispatchEvent(new Event("change", { bubbles: true })); })()');
476. await page.waitFor('!!document.querySelector("#connecttitleinput")', { label: 'new project title field' });
477. await page.type('#connecttitleinput', newTitle);
478. } else if (projectValue) {
479. await page.evaluate(`(() => { const s = document.querySelector("#connectproject"); s.value = ${J(projectValue)}; s.dispatchEvent(new Event("change", { bubbles: true })); })()`);
480. }
481. await page.click('#connectconfirm');
482. try { await page.waitFor('!!document.querySelector("#connectcontinue")', { label: 'tickets: connected' }); }
483. catch (e) { throw new Error(e.message + ' | page: ' + await page.evaluate('(document.querySelector("#connectmessage") || {}).textContent + " / " + document.body.innerHTML.slice(0, 1500)')); }
484. await page.click('#connectcontinue');
485. await page.waitFor(`location.hostname === '${slug}.gitoria.test' && !!document.querySelector("#connectedto")`, { label: 'back in settings, connected' });
486. };
487. // ---- the repo's tickets (gitoria#10): /tickets lists tickets.worldapi.org's project, the first ticket makes it ----
488. const PROJ = 'alpha.gitoria.test';
489. await A.goto(REPO('alpha') + '/tickets');
490. await A.waitFor('!!document.querySelector("#ticketsnotconnected")', { label: 'tickets page, not connected' });
491. check('connect: an unconnected repo says so on /tickets, no form, no list', !(await has(A, '#newticketform')) && !(await has(A, '#ticketlist')));
492. await S.goto(REPO('alpha') + '/settings');
493. await S.waitFor('!!document.querySelector("#notconnected")', { label: 'S: settings' });
494. check('connect: a signed-out viewer sees "not connected" and no connect button', !(await has(S, '#connecttickets')) && !(await has(S, '#disconnecttickets')));
495. // the owner connects: the project exists in tickets (made by the tickets user of alice, its admin)
496. const mk = await fetch(tickets.base + '/api/projects', { method: 'POST', headers: { authorization: 'Bearer ' + tickets.token, 'content-type': 'application/json' }, body: J({ title: PROJ, slug: PROJ }) });
497. check('connect: the project for alpha exists in tickets', mk.status === 201 || mk.status === 200, String(mk.status));
498. await connectRepo(A, 'alpha', null, null);
499. check('connect: settings says connected to that project, with the disconnect button', /alpha/.test(await txt(A, '#connectedto')) && (await has(A, '#disconnecttickets')));
500. check('connect: tickets shows the connection', J((await tickets.api(`/api/projects/${PROJ}/connections`)).json).includes('alpha'), J((await tickets.api(`/api/projects/${PROJ}/connections`))));
501. await A.goto(REPO('alpha') + '/tickets');
502. await A.waitFor('!!document.querySelector("#noticketsyet")', { label: 'tickets page, connected, no ticket yet' });
503. check('tickets: /tickets of a connected repo without tickets says so, has the nav link and the form', (await has(A, '#navtickets')) && (await has(A, '#newticketform')) && !(await has(A, '#ticketlist')));
504. await S.goto(REPO('alpha') + '/tickets');
505. await S.waitFor('!!document.querySelector("#noticketsyet")', { label: 'S: tickets page' });
506. await hydrated(S);
507. check('tickets: a signed-out viewer sees the page with a login hint and no form', (await has(S, '#ticketsloginhint')) && !(await has(S, '#newticketform')));
508. await hydrated(A);
509. await A.evaluate('document.querySelector("#newticket").open = true');
510. await A.type('#ticketsubject', ' ');
511. await A.click('#ticketsave');
512. await A.waitFor('!!document.querySelector("#newticketerror").textContent', { label: 'blank subject refused' });
513. await A.evaluate('document.querySelector("#ticketsubject").value = ""; document.querySelector("#newticket").open = true');
514. check('tickets: a blank subject is refused in words', /subject/.test(await txt(A, '#newticketerror')));
515. await A.type('#ticketsubject', 'First <b>ticket</b>');
516. await A.type('#ticketsummary', 'Some **words**');
517. await A.click('#ticketsave');
518. await A.waitFor('document.querySelectorAll("#ticketlist li").length === 1', { label: 'first ticket listed' });
519. const t1 = (await tickets.api(`/api/projects/${PROJ}/tickets/1`)).json.ticket;
520. check('tickets: a ticket opened in gitoria lands in the connected project, created by the person (alice = the tickets user "gitoria")', t1 && t1.subject === 'First <b>ticket</b>' && t1.state === 'open' && t1.summary === 'Some **words**' && t1.createdBy === 'gitoria', J(t1));
521. check('tickets: the list row = #1, the subject as text (no HTML), state, link into tickets', await A.evaluate(`(() => { const li = document.querySelector('#ticketlist li'); return /#1/.test(li.textContent) && li.textContent.includes('First <b>ticket</b>') && !li.querySelector('b') && /open/.test(li.textContent) && li.querySelector('a.subject').href === ${J(tickets.base + '/projects/' + PROJ + '/1')}; })()`));
522. // the server pushes `ticketOpened` BEFORE it answers the face, so the list row can show up before openIt clears the form
523. // (seen once on hybriel master ff51cf46) — wait for the face's answer, the notice
524. await A.waitFor('!!document.querySelector("#ticketnotice")', { label: 'notice after the face answered' }).catch(() => null);
525. check('tickets: the form is cleared and says "Opened ticket #1"', (await A.evaluate('document.querySelector("#ticketsubject").value')) === '' && /#1/.test(await txt(A, '#ticketnotice')), J({ subject: await A.evaluate('document.querySelector("#ticketsubject").value'), notice: await txt(A, '#ticketnotice') }));
526. await S.waitFor('document.querySelectorAll("#ticketlist li").length === 1', { label: 'S sees it live' });
527. check('live: the signed-out viewer sees the new ticket without a reload', /First/.test(await txt(S, '#ticketlist')) && !(await has(S, '#noticketsyet')));
528. // a ticket opened in tickets itself, and one with a name only tickets knows: shown on the next load
529. const ext = await fetch(tickets.base + '/api/projects/' + PROJ + '/tickets', { method: 'POST', headers: { authorization: 'Bearer ' + tickets.token, 'content-type': 'application/json' }, body: J({ subject: 'From tickets itself' }) });
530. check('tickets: a ticket made on tickets.worldapi.org directly → 201', ext.status === 201);
531. await A.goto(REPO('alpha') + '/tickets');
532. await A.waitFor('document.querySelectorAll("#ticketlist li").length === 2', { label: 'two tickets after reload' });
533. check('tickets: after a reload both are listed, newest update first', /From tickets itself/.test(await txt(A, '#ticketlist li:first-child')) && /First/.test(await txt(A, '#ticketlist li:nth-child(2)')) && (await A.evaluate('document.querySelector("#ticketsall").href')) === tickets.base + '/projects/' + PROJ);
534. check('tickets: another repo has none of them', (await tickets.api('/api/projects/beta-2.gitoria.test/tickets')).status === 404);
535. await S.goto(REPO('beta-2') + '/tickets');
536. await S.waitFor('!!document.querySelector("#ticketsnotconnected")', { label: 'beta-2 is not connected' });
537. check('tickets: beta-2 is not connected and shows none of them', !(await has(S, '#ticketlist')));
538. await S.goto(REPO('nothing-here') + '/tickets');
539. await S.waitFor('!!document.querySelector("#missing")', { label: 'unknown repo tickets' });
540. check('tickets: an address nobody created has no tickets page', true);
541. f = await emitFace('gitoriaOpenTicket', ['alpha', 'anon', '']);
542. check('face: not logged in → a ticket is refused', f.value && /log in/.test(f.value.error || '') && (await tickets.api(`/api/projects/${PROJ}/tickets`)).json.tickets.length === 2, f.raw);
543. f = await emitFace('gitoriaOpenTicket', ['alpha', 'forged', '', { user: { id: 'x' } }]);
544. check('face: a forged trailing session opens nothing', !(f.value && f.value.ticket) && (await tickets.api(`/api/projects/${PROJ}/tickets`)).json.tickets.length === 2, f.raw);
545. f = await emitFace('gitoriaOpenTicket', ['no-such-repo', 'x', '']);
546. check('face: an unknown repo → refused, no project made', f.value && /no such repository/.test(f.value.error || '') && (await tickets.api('/api/projects/no-such-repo.gitoria.test/tickets')).status === 404, f.raw);
547. for (const [w, h, name] of [[390, 844, 'narrow'], [1280, 900, 'wide']]) {
548. await viewport(A, w, h);
549. await A.goto(REPO('alpha') + '/tickets');
550. await A.waitFor('document.querySelectorAll("#ticketlist li").length === 2', { label: 'tickets for layout' });
551. check(`layout ${w}px: /tickets has no horizontal overflow`, await noOverflow(A));
552. await shot(A, `${name}-tickets`);
553. }
554. await viewport(A, 1280, 900);
555. await tickets.stop();
556. await S.goto(REPO('alpha') + '/tickets');
557. await S.waitFor('!!document.querySelector("#ticketserror")', { label: 'tickets down' });
558. check('tickets down: the page says tickets.worldapi.org did not answer', /did not answer/.test(await txt(S, '#ticketserror')));
559. tickets = await startTickets({ ticketsDir: TICKETS_DIR, workDir: join(STORE, 'tickets2'), port: TICKETS_PORT, ident, who: alice, origins: ORIGINS });
561. // ---- #N links both ways (gitoria#18): the tickets copy is new; connect alpha again, then a REAL push over HTTP ----
562. await fetch(tickets.base + '/api/projects', { method: 'POST', headers: { authorization: 'Bearer ' + tickets.token, 'content-type': 'application/json' }, body: J({ title: PROJ, slug: PROJ }) });
563. await fetch(tickets.base + '/api/projects/' + PROJ + '/tickets', { method: 'POST', headers: { authorization: 'Bearer ' + tickets.token, 'content-type': 'application/json' }, body: J({ subject: 'Login is broken' }) });
564. await connectRepo(A, 'alpha', null, null);
565. check('connect: connecting again after tickets was replaced works (new key, page says connected)', /alpha/.test(await txt(A, '#connectedto')));
566. const sid = (await A.cookies([REPO('alpha')])).find(c => /sid$/.test(c.name));
567. const mkTok = await emitFace('gitoriaMakeToken', ['gate push'], sid.name + '=' + sid.value);
568. const PUSHTOKEN = mkTok.value && mkTok.value.token;
569. check('links: a push token for alice', /^gtr_[0-9a-f]{40}$/.test(PUSHTOKEN || ''), mkTok.raw);
570. const lw = join(STORE, 'work-links');
571. rmSync(lw, { recursive: true, force: true });
572. execFileSync('git', ['clone', '-q', join(STORE, 'git', 'alpha.git'), lw], { stdio: 'pipe' });
573. const lg = (...a) => execFileSync('git', ['-C', lw, '-c', 'user.name=alice', '-c', '[email protected]', ...a], { stdio: 'pipe' }).toString();
574. const pushHttp = (...refs) => lg('-c', 'http.extraHeader=Host: alpha.gitoria.test:' + PORT, 'push', '-q', `http://alice:${PUSHTOKEN}@127.0.0.1:${PORT}/alpha.git`, ...refs);
575. const ticketMd = async (n) => (await (await fetch(`${tickets.base}/api/projects/${PROJ}/tickets/${n}`, { headers: { accept: 'text/markdown' } })).text());
576. writeFileSync(join(lw, 'login.txt'), 'x\n'); lg('add', '-A'); lg('commit', '-q', '-m', 'fix login, #1 and a bogus #99');
577. const mentionSha = lg('rev-parse', 'HEAD').trim();
578. pushHttp('HEAD:main');
579. let tmd = '';
580. for (let i = 0; i < 20 && !/Mentioned in commit/.test(tmd); i++) { tmd = await ticketMd(1); if (!/Mentioned in commit/.test(tmd)) await sleep(500); }
581. check('links: a pushed commit "fix login, #1" → ticket 1 in tickets shows "Mentioned in commit" with the commit link', /Mentioned in commit/.test(tmd) && tmd.includes(mentionSha.slice(0, 8)) && tmd.includes('/commit/' + mentionSha), tmd.slice(0, 600));
582. check('links: a ticket that does not exist (#99) is skipped quietly', (await tickets.api(`/api/projects/${PROJ}/tickets/99`)).status === 404);
583. const cnt = (t) => (t.match(/Mentioned in commit/g) || []).length;
584. pushHttp('HEAD:refs/heads/other');
585. await sleep(1500);
586. check('links: pushing the same commit again does not comment twice', cnt(await ticketMd(1)) === 1, String(cnt(await ticketMd(1))));
587. await A.goto(REPO('alpha') + '/commit/' + mentionSha);
588. await A.waitFor('!!document.querySelector("#reponame")', { label: 'commit page' });
589. await sleep(1500);
590. check('links: the commit page shows #1 as a link into the ticket', await A.evaluate(`(() => { const a = [...document.querySelectorAll('a')].filter(x => x.href === ${J(tickets.base + '/projects/' + PROJ + '/1')}); return a.length > 0; })()`), await A.evaluate(`(document.querySelector('#commitsubject') || {}).innerHTML + ' | ' + location.href`));
591. // "fixes #1" in a merged pull request sets the ticket to review
592. lg('checkout', '-q', '-b', 'fixbr'); writeFileSync(join(lw, 'fix.txt'), 'y\n'); lg('add', '-A'); lg('commit', '-q', '-m', '|||PR|main] Fix the login, fixes #1');
593. pushHttp('fixbr');
594. await A.goto(REPO('alpha') + '/pulls');
595. await A.waitFor('!!document.querySelector("#reponame")', { label: 'pulls page' });
596. await sleep(1500);
597. check('links: the open pull request lists #1 as a link', await A.evaluate(`[...document.querySelectorAll('a')].some(x => x.href === ${J(tickets.base + '/projects/' + PROJ + '/1')} && x.closest('#pulllist'))`) || await A.evaluate(`[...document.querySelectorAll('a')].some(x => x.href === ${J(tickets.base + '/projects/' + PROJ + '/1')})`));
598. check('links: an open pull request does not change the ticket', (await tickets.api(`/api/projects/${PROJ}/tickets/1`)).json.ticket.state === 'open');
599. lg('checkout', '-q', 'main'); lg('merge', '-q', '--no-ff', '-m', 'merge the fix', 'fixbr');
600. pushHttp('main');
601. let st = '';
602. for (let i = 0; i < 20 && st !== 'review'; i++) { st = (await tickets.api(`/api/projects/${PROJ}/tickets/1`)).json.ticket.stateSlug; if (st !== 'review') await sleep(500); }
603. check('links: the pull request "fixes #1" is merged (pushed) → ticket 1 is set to review', st === 'review', st);
604. const before2 = cnt(await ticketMd(1));
605. pushHttp('main');
606. await sleep(1000);
607. check('links: a second push comments nothing twice and does not set it again', cnt(await ticketMd(1)) === before2 && before2 === 2 && ((await ticketMd(1)).match(/Fixed by the merged pull request/g) || []).length === 1);
608. // disconnect from gitoria's side, and tickets' side sees it gone
609. await A.goto(REPO('alpha') + '/settings');
610. await A.waitFor('!!document.querySelector("#disconnecttickets")', { label: 'settings, connected' });
611. await hydrated(A);
612. await A.click('#disconnecttickets');
613. await A.waitFor('!!document.querySelector("#notconnected")', { label: 'disconnected' });
614. await A.goto(REPO('alpha') + '/tickets');
615. await A.waitFor('!!document.querySelector("#ticketsnotconnected")', { label: 'tickets page after disconnect' });
616. check('connect: "Forget the connection" → /tickets says not connected again', true);
617. await connectRepo(A, 'alpha', null, null);
619. // ---- pull requests (gitoria#11): /pulls lists the commits that start with |||PR -------------------------------
620. const pw = join(STORE, 'work-pulls');
621. rmSync(pw, { recursive: true, force: true }); mkdirSync(pw, { recursive: true });
622. gitIn(pw, 'init', '-q', '-b', 'main');
623. writeFileSync(join(pw, 'a.txt'), 'base\n'); gitIn(pw, 'add', '-A'); gitIn(pw, 'commit', '-q', '-m', 'base');
624. const baseSha = gitIn(pw, 'rev-parse', 'HEAD').trim();
625. const branchCommit = (name, msg) => { gitIn(pw, 'checkout', '-q', '-b', name, baseSha); writeFileSync(join(pw, name.replace(/\//g, '_') + '.txt'), name + '\n'); gitIn(pw, 'add', '-A'); gitIn(pw, 'commit', '-q', '-m', msg); return gitIn(pw, 'rev-parse', 'HEAD').trim(); };
626. gitIn(pw, 'branch', 'dev');
627. const fixSha = branchCommit('fix-a', '|||PR Fix the <b>thing</b>');
628. gitIn(pw, 'commit', '-q', '--allow-empty', '-m', 'more work on fix-a');
629. branchCommit('topic/one', '|||PR|dev] Topic to dev');
630. branchCommit('ghost', '|||PR|nope] Lost target');
631. branchCommit('plain', 'not a pull request |||PR');
632. branchCommit('nospace', '|||PR|main]glued');
633. branchCommit('old', '|||PR Old work');
634. gitIn(pw, 'checkout', '-q', 'main'); gitIn(pw, 'merge', '-q', '--ff-only', 'old');
635. gitIn(pw, 'push', '-q', '-f', join(STORE, 'git', 'beta-2.git'), 'main', 'dev', 'fix-a', 'topic/one', 'ghost', 'plain', 'nospace', 'old');
636. const pullsReady = (p) => p.waitFor('!document.querySelector("#pullsloading") && (!!document.querySelector("#pullsmessage") || !!document.querySelector("#pullshelp"))', { label: 'pulls answer' });
637. await A.goto(REPO('beta-2') + '/pulls');
638. await pullsReady(A);
639. const rows = await A.evaluate(`[...document.querySelectorAll('#pulllist li')].map(li => [li.querySelector('.subject').textContent, li.querySelector('.open,.merged').textContent, li.querySelector('.branches').textContent.replace(/\\s+/g, ' ').trim()].join(' ~ '))`);
640. check('/pulls: one request per marker commit, title without the marker, source → target, state', rows.length === 4 && rows.includes('Fix the <b>thing</b> ~ open ~ fix-a→main') && rows.includes('Topic to dev ~ open ~ topic/one→dev') && rows.includes('Old work ~ merged ~ old→main') && rows.some(r => r.startsWith('Lost target ~ open ~ ghost→nope (no such branch)')), J(rows));
641. check('/pulls: no request from a marker inside the text or without the space after ]; HTML stays text', !rows.some(r => /Not a pull|glued|plain|nospace/.test(r)) && !(await has(A, '#pulllist b')), J(rows));
642. check('/pulls: the title links to the commit, the branches to their pages, the nav link is there', await A.evaluate(`(() => { const a = [...document.querySelectorAll('#pulllist li')].find(li => li.textContent.includes('Fix the')); return a.querySelector('.subject a').href.endsWith('/commit/${fixSha}') && a.querySelector('a.source').pathname === '/branch/fix-a' && a.querySelector('a.target').pathname === '/branch/main'; })() && !!document.querySelector('#navpulls')`));
643. await A.evaluate(`[...document.querySelectorAll('#pulllist a.source')].find(a => a.textContent === 'fix-a').click()`);
644. await A.waitFor('location.pathname === "/branch/fix-a"', { label: 'source branch link' });
645. await S.goto(REPO('beta-2') + '/pulls');
646. await pullsReady(S);
647. check('/pulls: a signed-out viewer sees the same list', (await S.evaluate('document.querySelectorAll("#pulllist li").length')) === 4);
648. await S.goto(REPO('gamma') + '/pulls');
649. await pullsReady(S);
650. check('/pulls of an empty repo says it has no commits yet', /no commits yet/.test(await txt(S, '#pullsmessage') || ''));
651. await S.goto(REPO('alpha') + '/pulls');
652. await pullsReady(S);
653. check('/pulls of alpha lists just the one request from the #N test (merged, "fixes #1" a link)', (await S.evaluate('document.querySelectorAll("#pulllist li").length')) === 1 && !(await has(S, '#nopulls')) && (await S.evaluate('!!document.querySelector("#pulllist li .merged") && !!document.querySelector("#pulllist a.ticketref")')));
654. await S.goto(REPO('nothing-here') + '/pulls');
655. await S.waitFor('!!document.querySelector("#missing")', { label: 'unknown repo pulls' });
656. const forgedPulls = await emitFace('gitoriaPulls', ['beta-2', 'x', 'evil'], '');
657. check('face: a forged session gets no pull list', !forgedPulls.value || forgedPulls.value.ok !== true, J(forgedPulls));
658. for (const [w, h, name] of [[390, 844, 'narrow'], [1280, 900, 'wide']]) {
659. await viewport(A, w, h);
660. await A.goto(REPO('beta-2') + '/pulls');
661. await pullsReady(A);
662. check(`layout ${w}px: /pulls has no horizontal overflow`, await noOverflow(A));
663. await shot(A, `${name}-pulls`);
664. }
665. await viewport(A, 1280, 900);
667. // ---- merge button (gitoria#17): the owner merges a pull request, only by clicking; a conflict merges nothing ------
668. const mergeBtns = (p) => p.evaluate(`[...document.querySelectorAll('#pulllist li')].filter(li => li.querySelector('button.mergepr')).map(li => li.querySelector('.subject').textContent).join('|')`);
669. await A.goto(REPO('beta-2') + '/pulls');
670. await pullsReady(A);
671. check('merge: the owner sees Merge on the open requests with a source and a target, not on merged / lost ones', (await mergeBtns(A)) === 'Topic to dev|Fix the <b>thing</b>', await mergeBtns(A));
672. await S.goto(REPO('beta-2') + '/pulls');
673. await pullsReady(S);
674. check('merge: a signed-out viewer sees no Merge button', (await S.evaluate('document.querySelectorAll("button.mergepr").length')) === 0);
675. const forgedMerge = await emitFace('gitoriaMergePull', ['beta-2', fixSha, 'evil'], '');
676. check('merge: a forged session cannot merge', !forgedMerge.value || forgedMerge.value.error != null || forgedMerge.value.result == null, J(forgedMerge));
677. // a branch that conflicts with main
678. gitIn(pw, 'checkout', '-q', '-b', 'clash', baseSha); writeFileSync(join(pw, 'a.txt'), 'clash side\n'); gitIn(pw, 'add', '-A'); gitIn(pw, 'commit', '-q', '-m', '|||PR Clashing change');
679. gitIn(pw, 'checkout', '-q', 'main'); writeFileSync(join(pw, 'a.txt'), 'main side\n'); gitIn(pw, 'add', '-A'); gitIn(pw, 'commit', '-q', '-m', 'main edits a.txt');
680. gitIn(pw, 'push', '-q', '-f', join(STORE, 'git', 'beta-2.git'), 'main', 'clash');
681. const mainBefore = gitIn(join(STORE, 'git', 'beta-2.git'), 'rev-parse', 'main').trim();
682. await A.goto(REPO('beta-2') + '/pulls');
683. await pullsReady(A);
684. const clickMerge = (title) => A.evaluate(`(() => { const li = [...document.querySelectorAll('#pulllist li')].find(l => l.querySelector('.subject').textContent === ${J(title)}); li.querySelector('button.mergepr').click(); })()`);
685. await clickMerge('Clashing change');
686. await A.waitFor('/conflicts/.test((document.querySelector("#mergeerror")||{}).textContent||"")', { label: 'conflict message' }).catch(async e => { throw new Error(e.message + ' ' + await A.evaluate('document.querySelector("#pulllist").innerText + document.querySelector("#mergeerror").outerHTML')); });
687. check('merge: a conflict says so, names the file and merges nothing', /a\.txt/.test(await txt(A, '#mergeerror')) && gitIn(join(STORE, 'git', 'beta-2.git'), 'rev-parse', 'main').trim() === mainBefore && (await A.evaluate('document.querySelectorAll("#pulllist li .open").length')) >= 3);
688. await clickMerge('Fix the <b>thing</b>');
689. await A.waitFor('[...document.querySelectorAll("#pulllist li")].some(l => l.querySelector(".subject").textContent === "Fix the <b>thing</b>" && l.querySelector(".merged"))', { label: 'fix-a merged' }).catch(async e => { throw new Error(e.message + ' ' + await A.evaluate('document.querySelector("#pulllist").innerText + document.querySelector("#mergeerror").textContent')); });
690. const bare = join(STORE, 'git', 'beta-2.git');
691. const mainLog = gitIn(bare, 'log', '--format=%s|%an', 'main');
692. check('merge: the click merges the branch into the target: merge commit by the owner, the branch commits are in main', /Merge branch 'fix-a' into main\|/.test(mainLog) && gitIn(bare, 'merge-base', '--is-ancestor', 'fix-a', 'main') !== null && /more work on fix-a/.test(mainLog) && gitIn(bare, 'show', 'main:fix-a.txt').trim() === 'fix-a', mainLog);
693. check('merge: the other side (main\'s own commit) is kept; the merge commit has two parents', /main edits a\.txt/.test(mainLog) && gitIn(bare, 'rev-list', '--parents', '-n1', 'main').trim().split(' ').length === 3);
694. check('merge: the request now shows merged and its Merge button is gone', !(await A.evaluate(`[...document.querySelectorAll('#pulllist li')].some(l => l.querySelector('.subject').textContent === 'Fix the <b>thing</b>' && l.querySelector('button.mergepr'))`)) && !(await txt(A, '#mergeerror')), J([await txt(A, '#mergeerror'), await A.evaluate(`[...document.querySelectorAll('#pulllist li')].filter(l => l.querySelector('.subject').textContent.startsWith('Fix')).map(l => l.innerHTML).join()`)]));
695. await S.goto(REPO('beta-2') + '/pulls');
696. await pullsReady(S);
697. check('merge: a reload (signed out) shows it merged', await S.evaluate(`[...document.querySelectorAll('#pulllist li')].some(l => l.querySelector('.subject').textContent === 'Fix the <b>thing</b>' && l.querySelector('.merged'))`));
698. await viewport(A, 1280, 900);
700. // ---- releases (gitoria#12): /releases lists the |||RL commits of the main branch, versions counted up ---------
701. const rw = join(STORE, 'work-rel');
702. rmSync(rw, { recursive: true, force: true }); mkdirSync(rw, { recursive: true });
703. gitIn(rw, 'init', '-q', '-b', 'main');
704. const rc = (msg) => { gitIn(rw, 'commit', '-q', '--allow-empty', '-m', msg); return gitIn(rw, 'rev-parse', 'HEAD').trim(); };
705. rc('start');
706. rc('|||RL First <b>one</b>');
707. rc('work');
708. rc('|||RL|med Feature drop');
709. rc('|||RL|mj Big one');
710. rc('|||RL');
711. rc('text |||RL not a release');
712. rc('|||RL|nonsense x');
713. rc('|||RL|1.1.1a By hand');
714. const lastSha = rc('|||RL after the hand one');
715. rc('|||RL|1.1.1a again the same');
716. gitIn(rw, 'checkout', '-q', '-b', 'side'); rc('|||RL on a side branch');
717. gitIn(rw, 'push', '-q', '-f', join(STORE, 'git', 'beta-2.git'), 'main', 'side');
718. const relReady = (p) => p.waitFor('!document.querySelector("#releasesloading") && (!!document.querySelector("#releasesmessage") || !!document.querySelector("#releaseshelp"))', { label: 'releases answer' });
719. await A.goto(REPO('beta-2') + '/releases');
720. await relReady(A);
721. const rel = await A.evaluate(`[...document.querySelectorAll('#releaselist li')].map(li => li.querySelector('.version') && li.querySelector('.subject') ? li.querySelector('.version').textContent + ' ~ ' + li.querySelector('.subject').textContent + (li.querySelector('.latest') ? ' ~ latest' : '') : 'HTML ' + li.innerHTML)`);
722. check('/releases: versions counted up (patch, med, mj, by hand, then on), newest first, latest marked', J(rel) === J(['1.1.2 ~ after the hand one ~ latest', '1.1.1a ~ By hand', '1.0.1 ~ ' + rel[2].split(' ~ ')[1], '1.0.0 ~ Big one', '0.1.0 ~ Feature drop', '0.0.1 ~ First <b>one</b>']), J(rel));
723. check('/releases: no release from a marker inside the text, a bad version, a repeated version or another branch; HTML stays text', rel.length === 6 && !(await has(A, '#releaselist b')), J(rel));
724. check('/releases: a release links to its commit, the nav link is there', await A.evaluate(`document.querySelector('#releaselist li a.subject').href.endsWith('/commit/${lastSha}') && !!document.querySelector('#navreleases')`));
725. await S.goto(REPO('gamma') + '/releases');
726. await relReady(S);
727. check('/releases of an empty repo says it has no commits yet', /no commits yet/.test(await txt(S, '#releasesmessage') || ''));
728. await S.goto(REPO('alpha') + '/releases');
729. await relReady(S);
730. check('/releases of a repo without release commits says "No release yet"', (await has(S, '#noreleases')) && !(await has(S, '#releaselist li')));
731. const forgedRel = await emitFace('gitoriaReleases', ['beta-2', 'x', 'evil'], '');
732. check('face: a forged session gets no release list', !forgedRel.value || forgedRel.value.ok !== true, J(forgedRel));
733. for (const [w, h, name] of [[390, 844, 'narrow'], [1280, 900, 'wide']]) {
734. await viewport(A, w, h);
735. await A.goto(REPO('beta-2') + '/releases');
736. await relReady(A);
737. check(`layout ${w}px: /releases has no horizontal overflow`, await noOverflow(A));
738. await shot(A, `${name}-releases`);
739. }
740. await viewport(A, 1280, 900);
742. // ---- gitoria#16: every repo view is its own page, rendered on the SERVER for the request's host ---------------
743. const AH = `alpha.gitoria.test:${PORT}`;
744. // the git views are read on the server too (hl:proc run(), hybriel#80): the FIRST HTML holds the content, no loading step
745. const BH = `beta-2.gitoria.test:${PORT}`;
746. const firstViews = [
747. ['/', AH, (b, t) => /id="homepage"/.test(b) && /Code repo/.test(t), 'Readme: the README (main branch dev)'],
748. ['/code', AH, (b, t) => /id="entries"/.test(b) && /<a class="dir" href="\/code\/src">src<\/a>/.test(b) && /README\.md/.test(t) && /id="coderef">dev</.test(b), 'Code: the file list of the main branch'],
749. ['/code/src', AH, (b, t) => /<a class="dir" href="\/code\/src\/deep">deep<\/a>/.test(b) && /a\.txt/.test(t), 'Code/<path>: the folder (the * part reaches the page)'],
750. ['/code/src/a.txt', AH, (b, t) => /id="lines"/.test(b) && /line one/.test(t), 'Code/<file>: the file lines'],
751. ['/branch/main', AH, (b, t) => /id="coderef">main</.test(b) && /id="entries"/.test(b) && /second on main/.test(t), 'Branch main: its tree and last commit'],
752. ['/branch/feature/x', AH, (b, t) => /id="coderef">feature\/x</.test(b) && /only-feature\.txt/.test(t), 'Branch with a slash'],
753. ['/commit/' + firstSha, AH, (b, t) => /id="codekind"[^>]*>Commit</.test(b) && /id="entries"/.test(b) && /first commit/.test(t), 'Commit: the project at that commit'],
754. ['/pulls', BH, (b, t) => /id="pulllist"/.test(b) && /Fix the/.test(t), 'Pull requests: the list'],
755. ['/releases', BH, (b, t) => /id="releaselist"/.test(b) && /1\.1\.2/.test(t) && /after the hand one/.test(t), 'Releases: the list'],
756. ];
757. for (const [path, host, ok, what] of firstViews) {
758. const f = await firstHtml(path, host);
759. const t = bodyText(f.body);
760. check(`first HTML of ${host.split('.')[0]}${path}: ${what}, no "Loading"`, f.status === 200 && /id="reponame"/.test(f.body) && ok(f.body, t) && !/Loading/i.test(t), t.slice(0, 400));
761. }
762. r = await fetch(API + '/host.js');
763. check('/host.js is gone (404)', r.status === 404, String(r.status));
764. let fh, ft;
765. // (the tickets copy was restarted empty above) one ticket made in tickets itself, then the page from scratch
766. // tickets #20: a ticket needs an existing project, made by its first admin (as gitoria does)
767. await fetch(tickets.base + '/api/projects', { method: 'POST', headers: { authorization: 'Bearer ' + tickets.token, 'content-type': 'application/json' }, body: J({ title: 'alpha.gitoria.test', slug: 'alpha.gitoria.test' }) });
768. await fetch(tickets.base + '/api/projects/alpha.gitoria.test/tickets', { method: 'POST', headers: { authorization: 'Bearer ' + tickets.token, 'content-type': 'application/json' }, body: J({ subject: 'From tickets itself' }) });
769. fh = await firstHtml('/tickets', AH);
770. ft = bodyText(fh.body);
771. check('first HTML of alpha/tickets: the ticket list itself is there (no loading step)', /id="ticketlist"/.test(fh.body) && /From tickets itself/.test(ft) && !/Loading/.test(ft), ft.slice(0, 400));
772. fh = await firstHtml('/', `gitoria.test:${PORT}`);
773. ft = bodyText(fh.body);
774. check('first HTML of the main address: the repo list with every repo (no loading step)', /<h1 id="heading">Repositories<\/h1>/.test(fh.body) && /alpha/.test(ft) && /beta-2/.test(ft) && /gamma/.test(ft) && !/Loading/.test(ft), ft.slice(0, 300));
775. check('first HTML: the hostile description of gamma stays inside the seed string (no second script, no <b id=xss>) — hybriel#34 upstream', !/<b id="xss">/.test(fh.body) && (fh.body.match(/<script\b/g) || []).length === (fh.body.match(/<\/script>/g) || []).length && fh.body.includes('\\u003c/script>'), (fh.body.match(/xss[^,]{0,80}/) || [''])[0]);
776. let allMissing = true, missDetail = '';
777. for (const p of ['/', '/code', '/code/src', '/branch/main', '/commit/abcdef1', '/pulls', '/releases', '/tickets']) {
778. const m = await firstHtml(p, `nothing-here.gitoria.test:${PORT}`);
779. if (m.status !== 200 || !/<h1 id="missing">No such repository<\/h1>/.test(m.body) || /id="reponame"/.test(m.body)) { allMissing = false; missDetail += ' ' + p + ':' + m.status; }
780. }
781. check('unknown repo: every view says "No such repository" in the first HTML', allMissing, missDetail);
782. // direct load of every view in Chrome
783. const views = [
784. ['/', '#homepage, #nohomepage', 'Readme'], ['/code', '#entries', 'Code'], ['/code/src/a.txt', '#lines', 'Code'], ['/branch/feature/x', '#entries', 'Branch'],
785. ['/commit/' + firstSha.slice(0, 8), '#entries', 'Commit'], ['/pulls', '#pullshelp', 'Pull requests'], ['/releases', '#releaseshelp', 'Releases'], ['/tickets', '#ticketlist', 'Tickets'],
786. ];
787. let direct = true, directDetail = '';
788. for (const [p, sel, title] of views) {
789. await A.goto(REPO('alpha') + p);
790. try { await A.waitFor(`!!document.querySelector(${J(sel)}) && !!document.querySelector('#reponame')`, { label: 'direct ' + p, timeout: 6000 }); } catch { direct = false; directDetail += ' ' + p + ' (no ' + sel + ')'; continue; }
791. const t = await A.evaluate('document.title');
792. if (!t.startsWith(title === 'Readme' ? 'alpha' : title) || !t.includes('alpha')) { direct = false; directDetail += ` ${p} title ${J(t)}`; }
793. }
794. check('direct load of every view (Readme, Code, a file, Branch, Commit, Pulls, Releases, Tickets): its content, its tab title', direct, directDetail);
795. // hl:web navigation: Readme → Code → Releases → Tickets → Pulls → Readme without a page load
796. await A.goto(REPO('alpha') + '/');
797. await A.waitFor('!!document.querySelector("#homepage, #nohomepage")', { label: 'nav start: Readme' });
798. await hydrated(A);
799. await A.evaluate('window.__navMarker = 42');
800. const navSteps = [['#navcode', '/code', '#entries'], ['#navreleases', '/releases', '#releaseshelp'], ['#navtickets', '/tickets', '#ticketlist'], ['#navpulls', '/pulls', '#pullshelp'], ['#navhome', '/', '#homepage, #nohomepage']];
801. let navOk = true, navDetail = '';
802. for (const [link, path, sel] of navSteps) {
803. await A.click(link);
804. try { await A.waitFor(`location.pathname === ${J(path)} && !!document.querySelector(${J(sel)})`, { label: 'nav to ' + path, timeout: 6000 }); } catch { navOk = false; navDetail += ` ${path}: ${await A.evaluate('location.pathname + " " + document.body.innerText.slice(0, 120)')}`; continue; }
805. if ((await A.evaluate('window.__navMarker')) !== 42) { navOk = false; navDetail += ` ${path}: page reloaded`; }
806. if ((await txt(A, '#reponame')) !== 'alpha' || (await A.evaluate('location.host')) !== AH) { navOk = false; navDetail += ` ${path}: wrong repo/host`; }
807. }
808. check('navigation Readme → Code → Releases → Tickets → Pulls → Readme: no full page load (window marker survives), the address bar follows, content right', navOk, navDetail);
809. await A.click('#navcode');
810. await A.waitFor('location.pathname === "/code" && !!document.querySelector("#entries a.dir")', { label: 'code for folder nav' });
811. await A.click('#entries a.dir');
812. await A.waitFor('location.pathname === "/code/src" && !!document.querySelector("#crumbs strong") && document.querySelector("#crumbs strong").textContent === "src"', { label: 'folder via nav' });
813. check('navigation inside Code (a folder) keeps the page too, and the browser Back button goes back to /code', (await A.evaluate('window.__navMarker')) === 42 && await (async () => { await A.evaluate('history.back()'); await A.waitFor('location.pathname === "/code" && [...document.querySelectorAll("#entries a")].some(x => x.textContent === "src")', { label: 'back to /code' }); return (await A.evaluate('window.__navMarker')) === 42; })());
814. // NAVIGATION WHILE LOGGED IN (the creator saw full page loads): a fresh browser, logged in through the button on the
815. // repo address like a person, then Readme → Code → Releases → Pulls → Tickets → Code → a folder with real clicks
816. const L = await newPage();
817. { const [lk, lv] = alice.cookie.split('='); await L.send('Network.enable'); await L.send('Network.setCookie', { name: lk, value: lv, url: IDENT_B + '/' }); }
818. await L.goto(REPO('alpha') + '/');
819. await L.waitFor('!!document.querySelector("#loginbutton") && !!document.querySelector("#reponame")', { label: 'L: repo, signed out' });
820. await hydrated(L);
821. await buttonLogin(L);
822. await L.waitFor(`location.href === ${J(REPO('alpha') + '/')} && !!document.querySelector("#whoami") && !!document.querySelector("#homepage")`, { label: 'L: back logged in' });
823. await hydrated(L);
824. await L.evaluate('window.__navMarker = 99');
825. // the folder step waits for '#crumbs a' (only inside a folder): '#crumbs strong' is already on /code, so it passed with /code/src still in flight
826. const loggedSteps = [['#navhome', '/', '#homepage'], ['#navcode', '/code', '#entries'], ['#navreleases', '/releases', '#releaseshelp'], ['#navpulls', '/pulls', '#pullshelp'], ['#navtickets', '/tickets', '#ticketlist'], ['#navcode', '/code', '#entries'], ['#entries a.dir', '/code/src', '#crumbs a']];
827. let liOk = true, liDetail = '';
828. for (const [link, path, sel] of loggedSteps) {
829. await L.click(link);
830. try { await L.waitFor(`location.pathname === ${J(path)} && !!document.querySelector(${J(sel)}) && !!document.querySelector('#whoami')`, { label: 'L nav ' + path, timeout: 6000 }); } catch { liOk = false; liDetail += ` ${path}: ${await L.evaluate('location.pathname + " " + document.body.innerText.slice(0, 120)')}`; continue; }
831. if ((await L.evaluate('window.__navMarker')) !== 99) { liOk = false; liDetail += ` ${path}: FULL PAGE LOAD`; await L.evaluate('window.__navMarker = 99'); await hydrated(L); }
832. if ((await txt(L, '#reponame')) !== 'alpha' || (await txt(L, '#whoami')) !== 'alice') { liOk = false; liDetail += ` ${path}: wrong repo/user`; }
833. }
834. check('navigation LOGGED IN (button login on the repo address): Readme → Code → Releases → Pulls → Tickets → Code → a folder, real clicks: no full page load, content right, still logged in', liOk, liDetail);
835. // the same on an EMPTY repo the user owns (like the creator's live repos: no commit yet)
836. const emptySteps = [['#navcode', '/code', '#codemessage'], ['#navreleases', '/releases', '#releasesmessage'], ['#navpulls', '/pulls', '#pullsmessage'], ['#navtickets', '/tickets', '#ticketsnotconnected'], ['#navhome', '/', '#nohomepage']];
837. await L.goto(REPO('gamma') + '/');
838. await L.waitFor('!!document.querySelector("#nohomepage") && !!document.querySelector("#whoami")', { label: 'L: gamma' });
839. await hydrated(L);
840. await L.evaluate('window.__navMarker = 98');
841. let emOk = true, emDetail = '';
842. for (const [link, path, sel] of emptySteps) {
843. await L.click(link);
844. try { await L.waitFor(`location.pathname === ${J(path)} && !!document.querySelector(${J(sel)}) && !!document.querySelector('#whoami')`, { label: 'L gamma ' + path, timeout: 6000 }); } catch { emOk = false; emDetail += ` ${path}: ${await L.evaluate('location.pathname + " " + document.body.innerText.slice(0, 120)')}`; continue; }
845. if ((await L.evaluate('window.__navMarker')) !== 98) { emOk = false; emDetail += ` ${path}: FULL PAGE LOAD`; await L.evaluate('window.__navMarker = 98'); await hydrated(L); }
846. }
847. check('navigation LOGGED IN on an empty repo the user owns: Code → Releases → Pulls → Tickets → Readme, no full page load', emOk, emDetail);
848. // the socket gone (Cloudflare closes an idle WebSocket after ~100 s): navigation rides the POST fallback
849. await L.goto(REPO('alpha') + '/');
850. await L.waitFor('!!document.querySelector("#homepage") && !!document.querySelector("#whoami")', { label: 'L: alpha again' });
851. await hydrated(L);
852. await L.evaluate('window.__hl.socket.close(); window.__navMarker = 97');
853. await L.waitFor('!window.__hl.socket', { label: 'L: socket gone' });
854. let pfOk = true, pfDetail = '';
855. for (const [link, path, sel] of [['#navcode', '/code', '#entries'], ['#navreleases', '/releases', '#releaseshelp'], ['#navhome', '/', '#homepage']]) {
856. await L.click(link);
857. try { await L.waitFor(`location.pathname === ${J(path)} && !!document.querySelector(${J(sel)}) && !!document.querySelector('#whoami')`, { label: 'L post ' + path, timeout: 6000 }); } catch { pfOk = false; pfDetail += ` ${path}: timeout`; continue; }
858. if ((await L.evaluate('window.__navMarker')) !== 97) { pfOk = false; pfDetail += ` ${path}: FULL PAGE LOAD`; break; }
859. }
860. check('navigation LOGGED IN with the socket closed (POST fallback): no full page load, still logged in', pfOk, pfDetail);
862. // THE SAME IN A REAL FIREFOX (the creator's browser; tests/firefox.mjs, WebDriver BiDi, real pointer clicks)
863. ff = await launchFirefox({ port: FIREFOX_PORT, hosts: ['gitoria.test', 'alpha.gitoria.test', 'beta-2.gitoria.test', 'gamma.gitoria.test', 'ident.gitoria.test'] });
864. { const [fk, fv] = alice.cookie.split('='); await ff.setCookie(fk, fv, 'ident.gitoria.test'); }
865. const ffLive = () => ff.waitFor('!!window.__hl && window.__hl.socket && window.__hl.socket.readyState === 1', { label: 'firefox: page hydrated' });
866. await ff.goto(REPO('alpha') + '/');
867. await ff.waitFor('!!document.querySelector("#loginbutton") && !!document.querySelector("#reponame")', { label: 'firefox: repo, signed out' });
868. await ffLive();
869. await ff.click('#loginbutton');
870. await ff.waitFor('!!document.querySelector("#chooselist li .choose")', { label: 'firefox: ident chooser' });
871. await ffLive();
872. await ff.click('#chooselist li:nth-child(1) .choose');
873. await ff.waitFor(`location.href === ${J(REPO('alpha') + '/')} && !!document.querySelector("#whoami") && !!document.querySelector("#homepage")`, { label: 'firefox: back logged in', timeout: 30000 });
874. await ffLive();
875. await ff.evaluate('window.__navMarker = 99');
876. let ffOk = true, ffDetail = '';
877. for (const [link, path, sel] of loggedSteps) {
878. await ff.click(link);
879. try { await ff.waitFor(`location.pathname === ${J(path)} && !!document.querySelector(${J(sel)}) && !!document.querySelector('#whoami')`, { label: 'firefox nav ' + path, timeout: 8000 }); } catch { ffOk = false; ffDetail += ` ${path}: ${await ff.evaluate('location.pathname + " " + document.body.innerText.slice(0, 120)')}`; continue; }
880. if ((await ff.evaluate('window.__navMarker')) !== 99) { ffOk = false; ffDetail += ` ${path}: FULL PAGE LOAD`; await ff.evaluate('window.__navMarker = 99'); await ffLive(); }
881. if ((await ff.evaluate('document.querySelector("#reponame").textContent + "/" + document.querySelector("#whoami").textContent')) !== 'alpha/alice') { ffOk = false; ffDetail += ` ${path}: wrong repo/user`; }
882. }
883. check('FIREFOX, navigation LOGGED IN: Readme → Code → Releases → Pulls → Tickets → Code → a folder, real clicks: no full page load, content right, still logged in', ffOk, ffDetail);
884. await ff.goto(REPO('gamma') + '/');
885. await ff.waitFor('!!document.querySelector("#nohomepage") && !!document.querySelector("#whoami")', { label: 'firefox: gamma' });
886. await ffLive();
887. await ff.evaluate('window.__navMarker = 98');
888. let ffeOk = true, ffeDetail = '';
889. for (const [link, path, sel] of emptySteps) {
890. await ff.click(link);
891. try { await ff.waitFor(`location.pathname === ${J(path)} && !!document.querySelector(${J(sel)}) && !!document.querySelector('#whoami')`, { label: 'firefox gamma ' + path, timeout: 8000 }); } catch { ffeOk = false; ffeDetail += ` ${path}: ${await ff.evaluate('location.pathname + " " + document.body.innerText.slice(0, 120)')}`; continue; }
892. if ((await ff.evaluate('window.__navMarker')) !== 98) { ffeOk = false; ffeDetail += ` ${path}: FULL PAGE LOAD`; await ff.evaluate('window.__navMarker = 98'); await ffLive(); }
893. }
894. check('FIREFOX, navigation LOGGED IN on an empty repo the user owns, no full page load', ffeOk, ffeDetail);
895. check('FIREFOX: no console errors', ff.errors.length === 0, ff.errors.join(' | '));
896. await ff.close(); ff = null;
898. await A.goto(BASE + '/');
899. await A.waitFor('document.querySelectorAll("#repos li").length === 3', { label: 'list with gamma' });
900. check('the hostile description shows as text on the list, nothing of it ran (hybriel#34 upstream)', (await A.evaluate('!window.__xss && !document.querySelector("#xss")')) && (await txt(A, '#repos')).includes(XSS), await txt(A, '#repos'));
902. // ---- layout ------------------------------------------------------------------------------------------------
903. for (const [w, h, name] of [[390, 844, 'narrow'], [1280, 900, 'wide']]) {
904. await viewport(A, w, h);
905. await A.goto(BASE + '/');
906. await A.waitFor('document.querySelectorAll("#repos li").length === 3', { label: 'list for layout' });
907. check(`layout ${w}px: main address has no horizontal overflow`, await noOverflow(A));
908. await shot(A, `${name}-main`);
909. await A.goto(REPO('alpha') + '/');
910. await A.waitFor('!!document.querySelector("#reponame")');
911. check(`layout ${w}px: repo address has no horizontal overflow`, await noOverflow(A));
912. await shot(A, `${name}-repo`);
913. }
915. // ---- the identity selector (gitoria#14): choose an identity on the main address, no reload ------------------------
916. const C = await newPage();
917. // alice is already signed in to ident (over REST, ident allows only 3 codes per address): hand C that ident session
918. const [ck, cv] = alice.cookie.split('=');
919. await C.send('Network.enable');
920. await C.send('Network.setCookie', { name: ck, value: cv, url: IDENT_B + '/' });
921. await C.goto(BASE + '/');
922. await C.waitFor('!!document.querySelector("#heading")', { label: 'C: main address' });
923. await hydrated(C);
924. await C.evaluate('window.__loginMarker = 1');
925. // hybriel#43: a second tab of the SAME browser (same session) on a code view — the login/logout flip of the shell
926. // must leave the page in the slot alone (no re-creation, no "Loading")
927. const C2 = patient(await browsers[browsers.length - 1].newPage());
928. await C2.goto(REPO('alpha') + '/code');
929. await C2.waitFor('!!document.querySelector("#entries") && !!document.querySelector("#loginbutton")', { label: 'C2: code view' });
930. await hydrated(C2);
931. await C2.evaluate('window.__flipMarker = 7; document.querySelector("#entries").dataset.keep = "1"');
932. const codeKept = async () => C2.evaluate('window.__flipMarker === 7 && !!document.querySelector("#entries[data-keep]") && [...document.querySelectorAll("#entries a")].some(a => a.textContent === "src") && !/Loading/i.test(document.body.innerText)');
933. check('selector: signed out, ident\'s "choose ident" sits beside the login button', await C.evaluate(`(() => { const s = document.querySelector('#selector'); const r = s && s.shadowRoot; return !!r && /choose/.test(r.querySelector('#choose').textContent) && !s.hasAttribute('logged-in') && !!document.querySelector('#loginbutton'); })()`));
934. await shClick(C, '#choose');
935. await C.waitFor(sh(`r.querySelectorAll('[part~="identity"]').length > 0`), { label: 'selector list' });
936. await shClick(C, '[part~="identity"]', 'Default');
937. await C.waitFor('!!document.querySelector("#logout")', { label: 'C: logged in after the selector login' });
938. check('selector login: no reload, logged in, the button is gone, the selector says so', (await C.evaluate('window.__loginMarker')) === 1 && await has(C, '#logout') && !(await has(C, '#loginbutton')) && await C.evaluate('document.querySelector("#selector").hasAttribute("logged-in")') && !(await has(C, '#loginerror')));
939. await C.waitFor('!!document.querySelector("#createform")', { label: 'C: create form after the selector login' });
940. check('selector login: the page follows (create form), the same session as after the button', await has(C, '#createform') && (await txt(C, '#whoami')) === 'alice');
941. await C2.waitFor('!!document.querySelector("#whoami")', { label: 'C2: logged in by the other tab' });
942. check('hybriel#43: a code view in another tab of the session flips to logged in, the code stays (same elements, no "Loading", no reload)', await codeKept(), await C2.evaluate('document.body.innerText.slice(0, 300)'));
943. await C.click('#logout');
944. await C.waitFor('!!document.querySelector("#loginbutton")', { label: 'C: logged out' });
945. await C.waitFor(sh(`/choose/.test(r.querySelector('#choose').textContent)`), { label: 'selector reset' });
946. await C2.waitFor('!!document.querySelector("#loginbutton")', { label: 'C2: logged out by the other tab' });
947. check('hybriel#43: … and back to logged out, the code still stays', await codeKept(), await C2.evaluate('document.body.innerText.slice(0, 300)'));
948. check('selector: logout resets it to "choose ident"', await C.evaluate('!document.querySelector("#selector").hasAttribute("logged-in")') && (await C.evaluate('document.querySelectorAll("ident-selector").length')) === 1);
949. await C.goto(REPO('alpha') + '/');
950. await C.waitFor('!!document.querySelector("#loginbutton") && !!document.querySelector("#reponame")', { label: 'C: repo address' });
951. await hydrated(C);
952. const repoSel = await firstHtml('/', `alpha.gitoria.test:${PORT}`);
953. check('repo address: the selector is hidden (class onrepo from the server\'s host, ident knows only the main origin), the button stays', /<ident-selector[^>]*class="out onrepo"/.test(repoSel.body) && await C.evaluate('getComputedStyle(document.querySelector("#selector")).display === "none"') && await has(C, '#loginbutton'));
954. const loginFx = await fetch(API + '/login.js');
955. check('/login.js is served', loginFx.status === 200 && /ident-login/.test(await loginFx.text()));
957. // ---- logout, then the data survives a restart --------------------------------------------------------------
958. await A.goto(BASE + '/');
959. await A.waitForSelector('#logout');
960. await hydrated(A);
961. await A.click('#logout');
962. await A.waitFor('!!document.querySelector("#loginbutton") && !document.querySelector("#createform")', { label: 'logged out' });
963. await A.waitFor('!!document.querySelector("#loginhint")', { label: 'A: list after the logout' });
964. check('logout: the button and the create form switch without a reload', await has(A, '#loginhint'), await A.evaluate('document.body.innerText.slice(0, 300)'));
965. await stopServer();
966. startServer(env);
967. await serverUp();
968. const again = await (await fetch(API + '/api/repos')).json();
969. check('restart: all repos are still there (storage/mpackdb/repos.db)', again.repos.length === 3 && again.repos.map(x => x.slug).join() === 'gamma,beta-2,alpha', J(again));
970. check('storage: the tables are in <store>/mpackdb/', ['repos', 'users'].every(t => readdirSync(join(STORE, 'mpackdb')).some(n => n.startsWith(t + '.'))), J(readdirSync(join(STORE, 'mpackdb'))));
971. const problems = [A, B, C, C2, S, L].flatMap(p => p.problems().filter(m => !/favicon|ERR_|Failed to load resource/.test(m.text)));
972. check('browsers: no console errors', problems.length === 0, problems.map(m => m.text).join(" | "));
973. check('server log: no error other than absorbed ones', !/error(?!: absorbed)/i.test(log.replace(/error absorbed[^\n]*/g, '')), log.split('\n').filter(l => /error/i.test(l)).slice(0, 5).join(" | "));
975. // ==== mission 046: THE INSTALLABLE APP — hl:web's own manifest + service worker (project.hl appIcons / offline =
976. // [ Index ]). Last, so every check above ran on the gate's usual Chromes: those are closed now and ONE fresh Chrome
977. // treats the two test origins as secure (a service worker needs a secure context; plain-http *.gitoria.test is not
978. // one — https / localhost are, so the live site needs no flag). The manifest and every icon over HTTP; Chrome's own
979. // verdict; the worker registered and controlling; then OFFLINE: the tab loses the network (the note appears), the
980. // server is stopped too (CDP's offline emulation does not reach the worker's own fetches — measured in tracker's
981. // gate — so only a dead server proves the cache), and `/` still opens from the cache: header + note + the list as
982. // last seen. A data page gets hl:web's "Unavailable offline" page. The same on a repo address (its own origin).
983. const html = await (await fetch(API + '/')).text();
984. const mhref = (html.match(/<link rel="manifest" href="([^"]+)"/) || [])[1];
985. check('pwa: every page head links the manifest, the apple-touch-icon, the favicon and the theme colour (the token `darker`)',
986. mhref === '/__hl/manifest.webmanifest' && html.includes('<link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">')
987. && html.includes('<link rel="icon" href="/icons/favicon.svg">') && html.includes('<meta name="theme-color" content="rgb(15, 20, 25)">'), html.slice(0, 900));
988. const mres = await fetch(API + mhref);
989. const man = await mres.json();
990. check('pwa: the manifest is served as application/manifest+json: name "gitoria", start_url /, scope /, display standalone, the token colours',
991. /manifest\+json/.test(mres.headers.get('content-type') || '') && man.name === 'gitoria' && man.short_name === 'gitoria' && man.start_url === '/' && man.scope === '/'
992. && man.display === 'standalone' && man.theme_color === 'rgb(15, 20, 25)' && man.background_color === 'rgb(25, 30, 35)', J(man));
993. const iconOk = [];
994. for (const ic of man.icons || []) {
995. const ir = await fetch(API + ic.src);
996. const b = Buffer.from(await ir.arrayBuffer());
997. iconOk.push(ir.ok && ic.type === 'image/png' && b.readUInt32BE(16) === Number(ic.sizes.split('x')[0]) && b.readUInt32BE(20) === Number(ic.sizes.split('x')[1]));
998. }
999. check('pwa: every manifest icon loads and is a real PNG of its declared size (192 + 512, any + maskable)',
1000. 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));
1001. const touch = await fetch(API + '/icons/apple-touch-icon.png');
1002. const touchBytes = Buffer.from(await touch.arrayBuffer());
1003. const fav = await fetch(API + '/icons/favicon.svg');
1004. const favText = await fav.text();
1005. const ico = await fetch(API + '/favicon.ico');
1006. const icoBytes = Buffer.from(await ico.arrayBuffer());
1007. check('pwa: apple-touch-icon is a 180×180 PNG, the favicon an SVG in gitoria blue, /favicon.ico a real icon file',
1008. touch.ok && touchBytes.readUInt32BE(16) === 180 && fav.ok && /image\/svg\+xml/.test(fav.headers.get('content-type') || '') && favText.includes('#569bd4')
1009. && ico.ok && icoBytes.readUInt32BE(0) === 0x00000100, `${touch.status} ${fav.status} ${ico.status}`);
1010. const repoMan = await (await fetch(API + '/__hl/manifest.webmanifest', { headers: { Host: `alpha.gitoria.test:${PORT}` } })).json();
1011. check('pwa: a repo address serves the same manifest (its own origin, start_url / = its Readme)', repoMan.name === 'gitoria' && repoMan.start_url === '/', J(repoMan));
1013. for (const b of browsers) { try { await b.close(); } catch {} }
1014. browsers.length = 0;
1015. process.env.HL_CHROME_ARGS += `|--unsafely-treat-insecure-origin-as-secure=${BASE},${REPO('alpha')}`;
1016. const P = await newPage();
1017. const pev = (e) => P.evaluate(e);
1018. await P.send('Emulation.setDeviceMetricsOverride', { width: 390, height: 844, deviceScaleFactor: 2, mobile: true });
1019. const workerOn = async (label) => {
1020. await hydrated(P);
1021. await P.waitFor(`navigator.serviceWorker.getRegistration().then(r => !!(r && r.active))`, { timeout: 15000, label: label + ': service worker active' });
1022. await P.waitFor(`!!navigator.serviceWorker.controller`, { timeout: 10000, label: label + ': page controlled by the worker' });
1023. };
1024. await P.goto(BASE + '/');
1025. await P.waitFor('document.querySelectorAll("#repos li").length === 3', { label: 'pwa: list' });
1026. await workerOn('main');
1027. const inst = await P.send('Page.getInstallabilityErrors');
1028. check('pwa: Chrome reports no installability error', (inst.installabilityErrors || []).length === 0, J(inst));
1029. const am = await P.send('Page.getAppManifest');
1030. check('pwa: Chrome parses the manifest without errors', am.url && am.url.endsWith('/__hl/manifest.webmanifest') && (am.errors || []).length === 0, J(am.errors));
1031. check('pwa: hl:web\'s service worker is registered for the whole app (scope /) and controls the page',
1032. (await pev(`navigator.serviceWorker.getRegistration().then(r => new URL(r.scope).pathname + ' ' + new URL(r.active.scriptURL).pathname)`)) === '/ /__hl/sw.js' && (await pev('!!navigator.serviceWorker.controller')));
1033. check('pwa: online, no offline note', !(await has(P, '#offline')));
1034. await shot(P, 'pwa-phone-online');
1035. // a repo address: its own origin → its own worker, `/` (the Readme) kept there too
1036. await P.goto(REPO('alpha') + '/');
1037. await P.waitFor('!!document.querySelector("#reponame")', { label: 'pwa: alpha readme' });
1038. await workerOn('alpha');
1039. check('pwa: a repo address registers its own worker too (scope /)', (await pev(`navigator.serviceWorker.getRegistration().then(r => location.host + ' ' + new URL(r.scope).pathname)`)) === `alpha.gitoria.test:${PORT} /`);
1040. await P.goto(BASE + '/');
1041. await P.waitFor('document.querySelectorAll("#repos li").length === 3', { label: 'pwa: list again' });
1042. await hydrated(P);
1044. await P.setOffline(true);
1045. await P.waitFor(`!!document.querySelector('#offline')`, { timeout: 5000, label: 'offline note (live)' }).catch(() => {});
1046. check('offline: the open page says so within seconds (the shell\'s tick)', (await txt(P, '#offline')) === 'You are offline. Repositories and code need the network.');
1047. await stopServer();
1048. let down = false;
1049. try { await fetch(API + '/api/repos'); } catch { down = true; }
1050. await P.goto(BASE + '/');
1051. await P.waitFor(`!!document.querySelector('#offline')`, { timeout: 8000, label: 'offline note after reload' }).catch(() => {});
1052. check('offline: with the server gone too, a reload of / still opens the shell from the worker\'s cache — header, brand, the note, the list as last seen',
1053. down && (await txt(P, 'application-header .brand')) === 'gitoria' && await has(P, '#offline')
1054. && (await pev('document.querySelectorAll("#repos li").length')) === 3
1055. && (await pev(`getComputedStyle(document.querySelector('application-header')).backgroundColor`)) === 'rgb(15, 20, 25)', 'server down: ' + down + ' ' + (await pev('document.body.innerText.slice(0, 200)')));
1056. await shot(P, 'pwa-phone-offline');
1057. await P.goto(REPO('alpha') + '/');
1058. await P.waitFor(`!!document.querySelector('#offline')`, { timeout: 8000, label: 'offline note on alpha' }).catch(() => {});
1059. check('offline: a repo address\'s / (the Readme) opens from its own cache, with the note', (await txt(P, '#reponame')) !== null && await has(P, '#offline'), await pev('document.body.innerText.slice(0, 200)'));
1060. await P.goto(REPO('alpha') + '/code');
1061. check('offline: a data page (/code) is not kept — hl:web\'s "Unavailable offline" page', (await pev(`!!document.querySelector('main[data-hl-offline]') && document.querySelector('h1').textContent`)) === 'Unavailable offline');
1063. await P.setOffline(false);
1064. startServer(env);
1065. await serverUp();
1066. await P.goto(BASE + '/');
1067. await hydrated(P);
1068. await P.waitFor(`!document.querySelector('#offline')`, { timeout: 5000, label: 'note gone' }).catch(() => {});
1069. check('back online: / from the server again, no offline note', !(await has(P, '#offline')) && (await pev('document.querySelectorAll("#repos li").length')) === 3);
1070. } catch (e) {
1071. failures++;
1072. console.log('FAIL gate crashed — ' + (e && e.stack || e));
1073. } finally {
1074. for (const b of browsers) { try { await b.close(); } catch {} }
1075. if (ff) { try { await ff.close(); } catch {} }
1076. await stopServer();
1077. if (tickets) await tickets.stop();
1078. if (ident) await ident.stop();
1079. writeFileSync(join(SCRATCH, 'gate-server.log'), log);
1080. console.log(`${passes} passed, ${failures} failed`);
1081. process.exit(failures ? 1 : 0);
1082. }