tickets

22.6 KB

1. // tests/short-id-switch.mjs — THE SHORT-ID SWITCH GATE of tickets.worldapi.org (mission 039, ident#23), all over HTTP, no browser:
2. // 1. the OLD ident (the pre-ident#23 build, a copy of its code: OLD_IDENT_DIR, default
3. // ident.worldapi.org/.scratch/pre-023-ident) + this app on a fresh store: alice (Default AND a second identity
4. // "Work") and bob log in and make data; alice's "Work" identity is deleted in ident afterwards;
5. // 2. both stop; the ident store and the app store are COPIED (the originals stay as they were);
6. // 3. the NEW ident (ident#23's dev build, a copy of ident.worldapi.org's code: NEW_IDENT_DIR) on the ident copy;
7. // 4. CONTROL: the app on an UNMIGRATED copy → alice comes back as a NEW user (why the migration is needed);
8. // 5. tools/migrate-short-ids.hl on the other copy, TWICE: counts; the second run changes nothing;
9. // 6. the app on the migrated copy with the new ident: alice's OLD app session still works; a fresh login through the
10. // new ident finds the SAME user with the SAME data; bob too; nobody sees the other's data.
11. // Ports 8726, 8727 (ident, app). Work dir .scratch/m039-switch (wiped at start). Every process started is stopped by PID.
12. // node tests/short-id-switch.mjs
14. import { spawn, execFileSync } from 'node:child_process';
15. import { cpSync, mkdirSync, readFileSync, rmSync, existsSync, writeFileSync } from 'node:fs';
16. import { dirname, join, resolve } from 'node:path';
17. import { fileURLToPath } from 'node:url';
18. import { copyIdent } from './identkit.mjs';
20. const HERE = dirname(fileURLToPath(import.meta.url));
21. const APP = resolve(HERE, '..');
22. const BIN = join(APP, 'bin/hybriel');
23. const PROJECTS = resolve(APP, '..');
24. const NEW_IDENT_DIR = process.env.NEW_IDENT_DIR || join(PROJECTS, 'ident.worldapi.org');
25. const OLD_IDENT_DIR = process.env.OLD_IDENT_DIR || join(PROJECTS, 'ident.worldapi.org/.scratch/pre-023-ident');
26. const IDENT_PORT = Number(process.env.SWITCH_IDENT_PORT || 8706), PORT = Number(process.env.SWITCH_PORT || 8707);
27. const ID = `http://127.0.0.1:${IDENT_PORT}`;
28. const BASE = `http://127.0.0.1:${PORT}`;
29. const W = join(APP, '.scratch/m039-switch');
30. const J = JSON.stringify;
31. const sleep = (ms) => new Promise(r => setTimeout(r, ms));
32. const SHORT = /^[2-9a-hj-km-np-z]{5}$/;
33. const OLD = /^[0-9a-f]{32}$/;
35. let passed = 0, failed = 0;
36. const check = (name, ok, detail = '') => {
37. if (ok) { passed++; console.log(' ok ' + name); } else { failed++; console.log(' FAIL ' + name + (detail ? ' — ' + detail : '')); }
38. };
39. let log = '';
40. const procs = new Set();
41. function start(label, bin, args, cwd, env) {
42. log += `\n==== ${label}\n`;
43. const p = spawn(bin, args, { cwd, env: { ...process.env, ...env }, stdio: ['ignore', 'pipe', 'pipe'] });
44. p.stdout.on('data', d => log += d); p.stderr.on('data', d => log += d);
45. procs.add(p);
46. return p;
47. }
48. async function stop(p) {
49. if (!p) return;
50. try { p.kill('SIGTERM'); } catch {}
51. await new Promise(r => { if (p.exitCode !== null || p.signalCode !== null) return r(); p.once('exit', r); setTimeout(r, 3000); });
52. procs.delete(p);
53. }
54. async function up(url, what) {
55. for (let i = 0; i < 120; i++) { try { const r = await fetch(url, { redirect: 'manual' }); if (r.status < 500) return; } catch {} await sleep(250); }
56. throw new Error(what + ' did not come up\n' + log.slice(-3000));
57. }
59. // ---- ident (old or new code, on a given data dir; codes go to a mail sink — never real mail) -------------------
60. async function startIdentOn(codeDir, dataDir) {
61. mkdirSync(dataDir, { recursive: true });
62. const sink = join(dataDir, 'mail.txt');
63. if (!existsSync(sink)) writeFileSync(sink, '');
64. const p = start('ident ' + codeDir, join(codeDir, 'bin/hybriel'), ['project.hl'], codeDir, {
65. IDENT_PORT: String(IDENT_PORT), IDENT_STORAGE: join(dataDir, 'mpackdb'), IDENT_SESSIONS: join(dataDir, 'sessions') + '/',
66. IDENT_MAIL_SINK: sink, IDENT_IP_LIMIT: '1000', IDENT_IP_DAY_LIMIT: '1000', IDENT_WATCH: '0', HL_HOST: '127.0.0.1',
67. SMTP_HOST: '', SMTP_USER: '', SMTP_PASSWORD: '' });
68. await up(ID + '/', 'ident');
69. return { p, sink };
70. }
71. let iemitI = 0;
72. async function identEmit(event, payload, cookie) {
73. const r = await fetch(ID + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', ...(cookie ? { cookie } : {}) }, body: J({ t: 'emit', i: ++iemitI, event, payload }) });
74. const t = await r.text(); let j = null; try { j = JSON.parse(t); } catch {}
75. return { value: j && j.value, raw: t, setCookie: (r.headers.get('set-cookie') || '').split(';')[0] };
76. }
77. async function identSignIn(sink, email) {
78. const c = await fetch(ID + '/api/code', { method: 'POST', headers: { 'content-type': 'application/json' }, body: J({ email }) });
79. if (c.status !== 200) throw new Error('ident code refused: ' + c.status);
80. const code = readFileSync(sink, 'utf8').trim().split('\n').filter(l => l.startsWith(email + ' ')).pop().split(' ')[1];
81. const v = await identEmit('verifyCode', [email, code, 'Europe/Vienna']);
82. if (!v.value || !v.value.account) throw new Error('ident sign-in failed: ' + v.raw);
83. return { email, cookie: v.setCookie, identities: v.value.identities };
84. }
85. // the selector's path: identities (as the app's page asks) → choose → one-time code
86. async function selectorCode(who, app, identityName = null) {
87. const l = await (await fetch(ID + '/api/selector/identities?key=' + app.key, { headers: { origin: BASE, cookie: who.cookie } })).json();
88. if (!l.identities || !l.identities.length) throw new Error('no identities: ' + J(l));
89. const pick = identityName ? l.identities.find(i => i.name === identityName) : l.identities[0];
90. if (!pick) throw new Error('no identity named ' + identityName + ': ' + J(l));
91. const c = await (await fetch(ID + '/api/selector/choose?key=' + app.key, { method: 'POST', headers: { origin: BASE, cookie: who.cookie, 'content-type': 'application/json' }, body: J({ identity: pick.id }) })).json();
92. if (!c.code) throw new Error('choose failed: ' + J(c));
93. return c.code;
94. }
96. // ---- the app -----------------------------------------------------------------------------------------------------
97. async function startApp(codeDir, store, app, extra = {}) {
98. const p = start('tickets.worldapi.org on ' + store, join(codeDir, 'bin/hybriel'), ['project.hl'], codeDir, {
99. ...appEnv(store), HL_HOST: '127.0.0.1', IDENT_URL: ID, IDENT_EXCHANGE_URL: ID, IDENT_API_KEY: app.key, IDENT_API_SECRET: app.secret, ...extra });
100. await up(BASE + '/', 'tickets.worldapi.org');
101. return p;
102. }
103. // the login button's / selector's landing: <app>/login/callback?ident_code= → the app's session cookie
104. async function appLogin(who, app, identityName = null, cookie = null) {
105. const code = await selectorCode(who, app, identityName);
106. const r = await fetch(BASE + '/login/callback?ident_code=' + code, { redirect: 'manual', headers: cookie ? { cookie } : {} });
107. const loc = r.headers.get('location') || '';
108. if (r.status !== 302 || loc.startsWith('/login/failed')) {
109. let why = r.status !== 302 ? (await r.text()).replace(/<(style|script)[\s\S]*?<\/(style|script)>/g, " ").replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 200) : '';
110. const sc = (r.headers.get('set-cookie') || '').split(';')[0] || cookie;
111. if (r.status === 302) try { why = await (await fetch(BASE + '/login/failed', { headers: sc ? { cookie: sc } : {} })).text(); why = (why.match(/login failed[^<]*|ident refused[^<]*|that is not[^<]*/i) || [why.slice(0, 200)])[0]; } catch {}
112. return { error: 'login failed (' + r.status + ' → ' + loc + ') ' + why };
113. }
114. return { cookie: (r.headers.get('set-cookie') || '').split(';')[0] || cookie };
115. }
116. let aemitI = 0;
117. async function appEmit(cookie, event, payload) {
118. const r = await fetch(BASE + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', cookie }, body: J({ t: 'emit', i: ++aemitI, event, payload }) });
119. const t = await r.text(); let j = null; try { j = JSON.parse(t); } catch {}
120. return j && j.value !== undefined ? j.value : { error: 'no value: ' + t.slice(0, 300) };
121. }
122. const runTool = (store, app) => execFileSync(BIN, ['tools/migrate-short-ids.hl'], { cwd: APP, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
123. env: { ...process.env, ...appEnv(store), IDENT_EXCHANGE_URL: ID, IDENT_URL: ID, IDENT_API_KEY: app.key, IDENT_API_SECRET: app.secret } });
124. const counts = (out) => { const m = out.match(/users seen (\d+), mapped (\d+), already short (\d+), unmapped (\d+), conflicts (\d+), failed (\d+)/); return m ? m.slice(1).map(Number) : null; };
126. import { readdirSync } from 'node:fs';
127. // ---- tickets: what a user has — display name, tickets written (events/links `user` = users @id), API tokens, and the
128. // CREATOR role (env TICKETS_CREATOR_IDENTITY = an ident id → the tool prints its new value) ------------------------------
129. // tickets' users.hl (NOT changed by mission 039: the folder holds held tickets#20 work) refuses an exchange answer that is
130. // not hex (`!isHex(j.identity, 64)`) — a short id like `a68sz` is refused. So the app runs from a COPY of its code in
131. // which that one check is widened the way gitoria/notes/calendar were (unless the folder already has it); the gate ALSO
132. // shows that the unchanged code cannot log anyone in after the switch.
133. let creatorOld = null;
134. let appCode = null;
135. const HEX_CHECK = '!isHex(j.identity, 64)';
136. const appEnv = (store) => ({ TICKETS_PORT: String(PORT), TICKETS_STORAGE: join(store, 'mpackdb'), TICKETS_SESSIONS: join(store, 'sessions'),
137. TICKETS_WATCH: '0', TICKETS_PUBLIC_URL: BASE, TICKETS_CREATOR_IDENTITY: creatorOld || '' });
138. const SKIP_CODE = new Set(['.env', 'storage', '.sessions', '.scratch', 'server.log', 'server.pid', '.git']);
139. const unpatched = () => readFileSync(join(APP, 'lib/users.hl'), 'utf8').includes(HEX_CHECK);
140. async function prepareCode() {
141. if (!unpatched()) { console.log(' (tickets\' users.hl already accepts short ids — running the folder itself)'); appCode = APP; return APP; }
142. const to = join(W, 'tickets-code');
143. mkdirSync(to, { recursive: true });
144. for (const e of readdirSync(APP)) if (!SKIP_CODE.has(e)) cpSync(join(APP, e), join(to, e), { recursive: true });
145. if (existsSync(join(to, '.env'))) throw new Error('a .env was copied — refusing');
146. const u = readFileSync(join(to, 'lib/users.hl'), 'utf8');
147. const fn = `static isIdentId = (s) => {
148. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > 64) { return false }
149. let i = 0
150. while (i < s.length) {
151. let c = s.charCodeAt(i)
152. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 122))) { return false }
153. i = i + 1
154. }
155. return true
156. }
157. `;
158. writeFileSync(join(to, 'lib/users.hl'), u.replace(HEX_CHECK, '!isIdentId(j.identity)').replace('// THE EXCHANGE:', fn + '// THE EXCHANGE:'));
159. console.log(' (tickets runs from a COPY whose users.hl accepts short ids: ' + to + ')');
160. appCode = to;
161. return to;
162. }
163. const firstEnv = async () => ({});
164. const laterEnv = async (mig) => ({ TICKETS_CREATOR_IDENTITY: (mig.ids || {})[creatorOld] || '' });
165. const wapi = async (method, path, token, body) => {
166. const r = await fetch(BASE + path, { method, headers: { ...(body ? { 'content-type': 'application/json' } : {}), ...(token ? { authorization: 'Bearer ' + token } : {}) }, body: body ? J(body) : undefined });
167. let json = null; try { json = await r.json(); } catch {}
168. return { status: r.status, json };
169. };
170. async function makeData(ca, cb, cw) {
171. const out = {};
172. // ticket #20: a ticket needs a role — alice opens the project m039 (its admin) and makes bob and Workname `edit`
173. for (const [who, cookie, name] of [['alice', ca, 'Alice'], ['bob', cb, 'Bob'], ['work', cw, 'Workname']]) {
174. const n = await appEmit(cookie, 'saveDisplayName', [name]);
175. const k = await appEmit(cookie, 'tokenCreate', ['laptop']);
176. const y = await appEmit(cookie, 'youData', []);
177. out[who] = { name, token: k && k.token, oldId: y && y.identity, ok: n && !n.error && k && !k.error };
178. }
179. const pr = await wapi('POST', '/api/projects', out.alice.token, { title: 'm039' });
180. const m1 = await wapi('POST', '/api/projects/m039/members', out.alice.token, { user: 'Bob', role: 'edit' });
181. const m2 = await wapi('POST', '/api/projects/m039/members', out.alice.token, { user: 'Workname', role: 'edit' });
182. for (const w of ['alice', 'bob', 'work']) {
183. const t = await wapi('POST', '/api/projects/m039/tickets', out[w].token, { subject: out[w].name + '\'s ticket', summary: 'written before the switch' });
184. out[w].ticket = t.json && t.json.ticket && t.json.ticket.id;
185. out[w].ok = out[w].ok && !!out[w].ticket;
186. }
187. out.alice.ok = out.alice.ok && pr.status === 201 && m1.status < 300 && m2.status < 300;
188. out.alice.other = out.bob.ticket; out.bob.other = out.alice.ticket;
189. creatorOld = out.alice.oldId; // alice is the creator from now on
190. check('old world: three users with names, a ticket and a token each; /you shows the OLD per-app id (32 hex)',
191. ['alice', 'bob', 'work'].every(w => out[w].ok && /^tkt_/.test(out[w].token || '') && OLD.test(out[w].oldId || '')), J(out).slice(0, 600));
192. return out;
193. }
194. async function toolExtra(r1, r2, mig, app, alice) {
195. const want = (mig.ids || {})[creatorOld];
196. check('the tool prints TICKETS_CREATOR_IDENTITY\'s new value (alice\'s short id), both runs',
197. !!want && r1.includes('set TICKETS_CREATOR_IDENTITY=' + want + ' in .env') && r2.includes('set TICKETS_CREATOR_IDENTITY=' + want + ' in .env'), (r1.match(/TICKETS_CREATOR_IDENTITY.*/) || [''])[0]);
198. if (!unpatched()) return;
199. // the UNCHANGED tickets code on a throw-away copy of the migrated store: the new ident's answer is refused
200. cpSync(join(W, 'app-store-migrated'), join(W, 'app-store-unpatched'), { recursive: true });
201. const p = await startApp(APP, join(W, 'app-store-unpatched'), app, await laterEnv(mig));
202. const l = await appLogin(alice, app);
203. await stop(p);
204. if (/^[0-9a-f]+$/.test(want)) { console.log(' skip the unchanged-code check: alice\'s short id ' + want + ' happens to be hex'); return; }
205. check('the UNCHANGED tickets code (users.hl isHex) can NOT log alice in after the switch — tickets needs the users.hl change first',
206. !!l.error, J(l).slice(0, 300));
207. console.log(' | unchanged code: ' + (l.error || 'logged in?!'));
208. }
209. async function isNewEmptyUser(cookie, before) {
210. const y = await appEmit(cookie, 'youData', []);
211. return y && y.named === false && SHORT.test(y.identity || '') && y.identity !== before.alice.oldId;
212. }
213. async function sameUser(label, cookie, who, mig) {
214. const y = await appEmit(cookie, 'youData', []);
215. // ticket #20: the token made before still acts as the same user — with the same role in m039 (alice admin, the others edit)
216. const members = (await wapi('GET', '/api/projects/m039')).json.members || [];
217. const role = (members.find(m => m.name === who.name) || {}).role;
218. const edit = await wapi('POST', `/api/tickets/${who.ticket}/edit`, who.token, { summary: 'edited after the switch: ' + label });
219. const other = who.name === 'Bob' ? await wapi('POST', `/api/tickets/${who.other}/edit`, who.token, { summary: 'bob edits alice\'s (role edit): ' + label }) : { status: 200 };
220. const want = mig ? mig.ids[who.oldId] : null;
221. check(label + ': the SAME user — name ' + who.name + ', the token made before still works, role ' + (who.name === 'Alice' ? 'admin' : 'edit') + ' kept' + (mig ? ', /you shows the short id' : ''),
222. y && y.name === who.name && (y.tokens || []).some(t => t.label === 'laptop') && role === (who.name === 'Alice' ? 'admin' : 'edit') && edit.status < 300 && other.status < 300 && (!mig || y.identity === want),
223. J([y, role, edit, other, want]).slice(0, 500));
224. }
227. let identP = null, appP = null;
228. try {
229. rmSync(W, { recursive: true, force: true });
230. mkdirSync(W, { recursive: true });
231. const oldCode = join(W, 'ident-old-code'), newCode = join(W, 'ident-new-code');
232. copyIdent(OLD_IDENT_DIR, oldCode);
233. copyIdent(NEW_IDENT_DIR, newCode);
234. const oldIsOld = !readFileSync(join(oldCode, 'store.hl'), 'utf8').includes('shortId');
235. const newIsNew = readFileSync(join(newCode, 'project.hl'), 'utf8').includes('migrate-ids');
236. check('the old ident has no short ids, the new one has /api/migrate-ids', oldIsOld && newIsNew);
237. const CODE = await prepareCode();
239. // ---- 1. the OLD world -------------------------------------------------------------------------------------------
240. console.log('# 1. old ident + tickets.worldapi.org, data made');
241. let id = await startIdentOn(oldCode, join(W, 'ident-data'));
242. identP = id.p;
243. const alice = await identSignIn(id.sink, '[email protected]');
244. const bob = await identSignIn(id.sink, '[email protected]');
245. const added = await identEmit('addIdentity', [{ identityName: 'Work' }], alice.cookie);
246. const work = added.value && added.value.identities ? added.value.identities.find(i => i.identityName === 'Work') : null;
247. const reg = await identEmit('appCreate', [{ name: 'tickets.worldapi.org', origins: [BASE] }], alice.cookie);
248. if (!reg.value || !reg.value.secret) throw new Error('appCreate failed: ' + reg.raw);
249. const app = { key: reg.value.app.apiKey, secret: reg.value.secret };
250. writeFileSync(join(W, 'test-app-key.json'), J(app)); // the THROW-AWAY test app's key (for a by-hand rerun of the tool)
251. appP = await startApp(CODE, join(W, 'app-store'), app, await firstEnv());
252. const a1 = await appLogin(alice, app), b1 = await appLogin(bob, app);
253. const w1 = await appLogin(alice, app, 'Work');
254. check('old ident: alice, bob and alice\'s "Work" log in to tickets.worldapi.org', !a1.error && !b1.error && !w1.error && work != null, J([a1.error, b1.error, w1.error]));
255. const before = await makeData(a1.cookie, b1.cookie, w1.cookie);
256. await stop(appP); appP = null;
257. const dropped = await identEmit('dropIdentity', [work.id], alice.cookie);
258. check('alice deletes her "Work" identity in ident (its app user becomes UNMAPPED)', dropped.value && !dropped.value.error, dropped.raw.slice(0, 200));
259. await stop(identP); identP = null;
261. // ---- 2. copies --------------------------------------------------------------------------------------------------
262. cpSync(join(W, 'ident-data'), join(W, 'ident-data-new'), { recursive: true });
263. cpSync(join(W, 'app-store'), join(W, 'app-store-control'), { recursive: true });
264. cpSync(join(W, 'app-store'), join(W, 'app-store-migrated'), { recursive: true });
266. // ---- 3. the NEW ident on the copy -------------------------------------------------------------------------------
267. console.log('# 2. new ident (ident#23) on a copy of the old ident store');
268. id = await startIdentOn(newCode, join(W, 'ident-data-new'));
269. identP = id.p;
270. const mig = await (await fetch(ID + '/api/migrate-ids', { method: 'POST', headers: { 'content-type': 'application/json' }, body: J(app) })).json();
271. const olds = Object.keys(mig.ids || {});
272. check('new ident: migrate-ids maps 2 old ids (alice Default, bob) to short ids; the deleted identity is left out; not finished',
273. olds.length === 2 && olds.every(k => OLD.test(k)) && Object.values(mig.ids).every(v => SHORT.test(v)) && mig.finished === false, J(mig));
275. // ---- 4. CONTROL: unmigrated store ---------------------------------------------------------------------------------
276. console.log('# 3. control: the app on an UNMIGRATED copy');
277. appP = await startApp(CODE, join(W, 'app-store-control'), app, await laterEnv(mig));
278. const c1 = await appLogin(alice, app);
279. if (c1.error) check('control: login through the new ident fails or …', false, c1.error);
280. else check('control (not migrated): alice comes back as a NEW, EMPTY user — this is what the migration prevents', await isNewEmptyUser(c1.cookie, before), '');
281. await stop(appP); appP = null;
283. // ---- 5. the migration, twice --------------------------------------------------------------------------------------
284. console.log('# 4. tools/migrate-short-ids.hl on the other copy, twice');
285. const r1 = runTool(join(W, 'app-store-migrated'), app);
286. writeFileSync(join(W, 'migrate-run1.txt'), r1);
287. console.log(r1.trim().split('\n').map(l => ' | ' + l).join('\n'));
288. check('run 1: users seen 3, mapped 2, already short 0, unmapped 1 (deleted identity), conflicts 0, failed 0', J(counts(r1)) === J([3, 2, 0, 1, 0, 0]), J(counts(r1)));
289. const shorts = [...r1.matchAll(/MAPPED user \S+ → (\S+)/g)].map(m => m[1]).sort();
290. check('run 1: the users now hold exactly the short ids ident mapped', J(shorts) === J(Object.values(mig.ids).sort()), J([shorts, mig.ids]));
291. check('run 1 never prints the key or the secret', !r1.includes(app.secret) && !r1.includes(app.key));
292. const r2 = runTool(join(W, 'app-store-migrated'), app);
293. writeFileSync(join(W, 'migrate-run2.txt'), r2);
294. check('run 2 (idempotent): seen 3, mapped 0, already short 2, unmapped 1', J(counts(r2)) === J([3, 0, 2, 1, 0, 0]), J(counts(r2)));
295. await toolExtra(r1, r2, mig, app, alice);
296. const badSecret = (() => { try { runTool(join(W, 'app-store-migrated'), { key: app.key, secret: 'sk_' + '0'.repeat(48) }); return 'ran'; } catch (e) { return String(e.stdout || '') + String(e.stderr || ''); } })();
297. // the control copy: the app ran with the new ident BEFORE the migration and made a new user for alice's short id
298. const rc = (() => { try { return 'exit 0: ' + runTool(join(W, 'app-store-control'), app); } catch (e) { return String(e.stdout || '') + String(e.stderr || ''); } })();
299. writeFileSync(join(W, 'migrate-control.txt'), rc);
300. check('the tool on the control copy (app ran before the migration): alice = CONFLICT, left alone, exit non-zero',
301. J(counts(rc)) === J([4, 1, 1, 1, 1, 0]) && /CONFLICT user/.test(rc) && /CONFLICTS:/.test(rc) && !rc.startsWith('exit 0'), rc.slice(0, 400));
302. check('a wrong secret: the tool stops with ident\'s 401, changes nothing', /401/.test(badSecret), badSecret.slice(0, 300));
304. // ---- 6. the app on the migrated store ------------------------------------------------------------------------------
305. console.log('# 5. the app on the MIGRATED copy with the new ident');
306. appP = await startApp(CODE, join(W, 'app-store-migrated'), app, await laterEnv(mig));
307. await sameUser('alice, OLD app session (no new login)', a1.cookie, before.alice);
308. const a2 = await appLogin(alice, app);
309. check('alice logs in again through the new ident', !a2.error, a2.error);
310. if (!a2.error) await sameUser('alice, fresh login through the new ident', a2.cookie, before.alice, mig);
311. const b2 = await appLogin(bob, app);
312. check('bob logs in again through the new ident', !b2.error, b2.error);
313. if (!b2.error) await sameUser('bob, fresh login through the new ident', b2.cookie, before.bob, mig);
314. await stop(appP); appP = null;
315. const r3 = runTool(join(W, 'app-store-migrated'), app);
316. writeFileSync(join(W, 'migrate-run3.txt'), r3);
317. check('after the logins: still 3 users (no new one was made), all short or unmapped as before', J(counts(r3)) === J([3, 0, 2, 1, 0, 0]), J(counts(r3)));
318. await stop(identP); identP = null;
319. } catch (err) {
320. failed++; console.log(' FAIL (aborted) ' + (err.stack || err));
321. } finally {
322. for (const p of [...procs]) await stop(p);
323. mkdirSync(W, { recursive: true });
324. writeFileSync(join(W, 'servers.log'), log);
325. }
326. console.log(`\n${passed} passed, ${failed} failed`);
327. process.exit(failed ? 1 : 0);