@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/test/unit/dashboard-plugin-link.spec.js

@@ -0,0 +1,213 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const index_1 = require("../../src/app/index");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const InternalHttpClient_1 = require("../../src/InternalHttpClient");
+const config_1 = require("../../src/config");
+const device_store_1 = require("../../src/data-service/device-store");
+const dashboardPluginLink_1 = require("../../src/app/dashboardPluginLink");
+const grid_1 = __importDefault(require("../../src/app/routers/grid"));
+// The store grid.ts took when it was loaded (it keeps the one it got then).
+const gridStore = device_store_1.DeviceStoreFactory.getStore();
+/**
+ * Where Xenon looks for the appium-dashboard-plugin, and the `dashboard_link`
+ * it hands back with each device.
+ *
+ * Through 2.14 both came from the Host header of the first /xenon/api request
+ * after startup, before the login (a GET /xenon/api/health was enough):
+ * Xenon sent a GET to `<that host>/dashboard/api/ping`, and if the answer had
+ * `pong`, kept `<that host>/dashboard` for the life of the process. From then
+ * on every device list fetched `<that host>/dashboard/api/sessions`, and gave
+ * every user a `dashboard_link` to that host. A forged Host made Xenon call a
+ * server of the sender's choosing (blind SSRF) and point everyone at it.
+ *
+ * Both now come from configuration: the plugin is reached on this server's own
+ * address and port, and the link is `/dashboard` under XENON_PUBLIC_URL, or a
+ * path on the server the dashboard is open on.
+ */
+describe('the dashboard-plugin link never comes from a request', () => {
+    const EVIL = 'attacker.example:8080';
+    let calls;
+    let authDisabledBefore;
+    let publicUrlBefore;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        authDisabledBefore = config_1.config.authDisabled;
+        publicUrlBefore = config_1.config.publicUrl;
+        config_1.config.authDisabled = true;
+        calls = [];
+        sinon_1.default.stub(InternalHttpClient_1.InternalHttpClient, 'get').callsFake(((url) => __awaiter(void 0, void 0, void 0, function* () {
+            calls.push(url);
+            if (url.endsWith('/dashboard/api/ping'))
+                return { pong: true };
+            return { result: { rows: [] } };
+        })));
+        sinon_1.default
+            .stub(gridStore, 'getAllDevices')
+            .resolves([{ udid: 'phone-1', host: 'http://127.0.0.1:4723', platform: 'android' }]);
+    }));
+    afterEach(() => {
+        config_1.config.authDisabled = authDisabledBefore;
+        config_1.config.publicUrl = publicUrlBefore;
+        sinon_1.default.restore();
+    });
+    // This server's own address, as ServerManager passes it from Appium's CLI
+    // arguments. InternalHttpClient is stubbed, so nothing is sent anywhere.
+    function app() {
+        const a = (0, express_1.default)();
+        a.use('/xenon', (0, index_1.createRouter)(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }), {
+            address: '0.0.0.0',
+            port: 4999,
+        }));
+        return a;
+    }
+    // The old check was a layer ahead of the login, first on the router, so a
+    // public request was enough: GET /xenon/api/health with a forged Host made
+    // Xenon ping that host. Now a public request makes no outbound call at all.
+    it('asks nothing of anyone for a public request, whatever Host it names', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, loopbackRequest_1.default)(app()).get('/xenon/api/health').set('Host', EVIL);
+        (0, chai_1.expect)(calls).to.deep.equal([]);
+    }));
+    // Lets the middleware's ping (started by a request, never awaited by one)
+    // finish.
+    const settle = () => new Promise((resolve) => setImmediate(resolve));
+    // The middleware ServerManager installs, with the device list, on a router
+    // of their own: the process-wide /xenon router may already answer /device
+    // from a layer another spec put ahead of it.
+    describe('the device list', () => {
+        function gridApp(ownServer) {
+            const r = express_1.default.Router();
+            r.use((req, _res, next) => {
+                req.auth = {
+                    kind: 'user-session',
+                    userId: 'u1',
+                    role: 'SUPER_ADMIN',
+                    scopes: 'admin',
+                };
+                next();
+            });
+            r.use((0, dashboardPluginLink_1.dashboardPluginMiddlewareFor)(ownServer));
+            grid_1.default.register(r, Object.assign({}, IPluginArgs_1.DefaultPluginArgs));
+            const a = (0, express_1.default)();
+            a.use('/xenon/api', r);
+            return a;
+        }
+        /** A first request starts the ping; the second sees what it found. */
+        function devices(a) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield (0, loopbackRequest_1.default)(a).get('/xenon/api/device').set('Host', EVIL);
+                yield settle();
+                return (0, loopbackRequest_1.default)(a).get('/xenon/api/device').set('Host', EVIL);
+            });
+        }
+        it("fetches the plugin's sessions from this server, never the request's host", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield devices(gridApp({ address: '0.0.0.0', port: 4999 }));
+            (0, chai_1.expect)(calls.length, 'the ping and the sessions fetch ran').to.be.greaterThan(1);
+            (0, chai_1.expect)(calls[0]).to.equal('http://127.0.0.1:4999/dashboard/api/ping');
+            for (const url of calls.slice(1)) {
+                (0, chai_1.expect)(url).to.match(/^http:\/\/127\.0\.0\.1:4999\/dashboard\/api\/sessions\?/);
+            }
+        }));
+        it('links a device to /dashboard under XENON_PUBLIC_URL, or on the server it is open on', () => __awaiter(void 0, void 0, void 0, function* () {
+            config_1.config.publicUrl = 'https://xenon.example.com';
+            const withPublic = yield devices(gridApp({ port: 4999 }));
+            const phone = withPublic.body.find((d) => d.udid === 'phone-1');
+            (0, chai_1.expect)(phone.dashboard_link).to.match(/^https:\/\/xenon\.example\.com\/dashboard\?device_udid=phone-1&/);
+            config_1.config.publicUrl = undefined;
+            const without = yield devices(gridApp({ port: 4999 }));
+            (0, chai_1.expect)(without.body.find((d) => d.udid === 'phone-1').dashboard_link).to.match(/^\/dashboard\?device_udid=phone-1&/);
+        }));
+        // Appium serves HTTPS with --ssl-certificate-path and --ssl-key-path. A
+        // plain-HTTP ping got ECONNRESET, retried three times (about 4 s) while
+        // every signed-in request waited on it, every 30 s once the back-off
+        // capped, and the plugin's link was lost.
+        it('pings over HTTPS when Appium serves it, once, with a short time limit', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield devices(gridApp({ address: '0.0.0.0', port: 4999, tls: true }));
+            const ping = InternalHttpClient_1.InternalHttpClient.get.firstCall;
+            (0, chai_1.expect)(ping.args[0]).to.equal('https://127.0.0.1:4999/dashboard/api/ping');
+            (0, chai_1.expect)(ping.args[1]).to.include({ retry: false, timeout: dashboardPluginLink_1.DASHBOARD_PING_TIMEOUT_MS });
+            (0, chai_1.expect)(dashboardPluginLink_1.DASHBOARD_PING_TIMEOUT_MS).to.be.at.most(2000);
+        }));
+    });
+    describe('dashboardPluginMiddleware', () => {
+        const run = (mw_1, ...args_1) => __awaiter(void 0, [mw_1, ...args_1], void 0, function* (mw, host = EVIL) {
+            const req = { headers: { host }, get: () => host, protocol: 'http' };
+            yield new Promise((resolve) => mw(req, {}, resolve));
+            return req;
+        });
+        it('reaches the plugin on the server it is given, whatever the request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const got = [];
+            const mw = (0, dashboardPluginLink_1.dashboardPluginMiddleware)({
+                ownServerOrigin: 'http://127.0.0.1:4723',
+                get: (url) => __awaiter(void 0, void 0, void 0, function* () {
+                    got.push(url);
+                    return { pong: true };
+                }),
+                publicBase: () => null,
+            });
+            yield run(mw);
+            yield settle();
+            const req = yield run(mw);
+            (0, chai_1.expect)(got).to.deep.equal(['http://127.0.0.1:4723/dashboard/api/ping']);
+            (0, chai_1.expect)(req['dashboard-plugin-url']).to.equal('http://127.0.0.1:4723/dashboard');
+            (0, chai_1.expect)(req['dashboard-plugin-link']).to.equal('/dashboard');
+            yield run(mw, 'other.example');
+            (0, chai_1.expect)(got, 'pinged once, while it answers').to.have.length(1);
+        }));
+        // A request never waits for the ping: one the plugin doesn't answer
+        // (a hung server, the wrong scheme) would hold every signed-in request.
+        it('never holds a request while the ping is out', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mw = (0, dashboardPluginLink_1.dashboardPluginMiddleware)({
+                ownServerOrigin: 'http://127.0.0.1:4723',
+                get: () => new Promise(() => undefined),
+            });
+            const outcome = yield Promise.race([
+                run(mw).then(() => 'answered'),
+                new Promise((resolve) => setTimeout(() => resolve('held'), 200)),
+            ]);
+            (0, chai_1.expect)(outcome).to.equal('answered');
+        }));
+        it('backs off after a failed ping, and links nothing meanwhile', () => __awaiter(void 0, void 0, void 0, function* () {
+            let t = 0;
+            const get = sinon_1.default.stub().rejects(new Error('ECONNREFUSED'));
+            const mw = (0, dashboardPluginLink_1.dashboardPluginMiddleware)({
+                ownServerOrigin: 'http://127.0.0.1:4723',
+                get,
+                now: () => t,
+            });
+            yield run(mw);
+            yield settle();
+            const req = yield run(mw);
+            (0, chai_1.expect)(req['dashboard-plugin-url']).to.equal('');
+            (0, chai_1.expect)(req['dashboard-plugin-link']).to.equal('');
+            (0, chai_1.expect)(get.callCount, 'no second ping inside the back-off').to.equal(1);
+            t = 1000;
+            yield run(mw);
+            (0, chai_1.expect)(get.callCount).to.equal(2);
+        }));
+        it('finds the server on 127.0.0.1 for a wildcard bind address, over HTTPS when asked', () => {
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('0.0.0.0', 4723)).to.equal('http://127.0.0.1:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)(undefined, 4723)).to.equal('http://127.0.0.1:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('::', 4723)).to.equal('http://127.0.0.1:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('10.0.0.5', 4723)).to.equal('http://10.0.0.5:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('fe80::1', 4723)).to.equal('http://[fe80::1]:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('0.0.0.0', 4723, true)).to.equal('https://127.0.0.1:4723');
+        });
+    });
+});

package/lib/test/unit/database-check.spec.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const config_1 = require("../../src/config");
+const logger_1 = __importDefault(require("../../src/logger"));
+const database_check_1 = require("../../src/scripts/database-check");
+// The published plugin ships a database client generated for SQLite. Through
+// 2.13.1, `databaseProvider: postgresql` with a SQLite file URL quietly ran on
+// SQLite (Xenon Control profiles did exactly this), and a postgres URL stopped
+// the server with Prisma's "the URL must start with the protocol `file:`" under
+// a hint about adding a column to a table with rows.
+describe('checkDatabase', () => {
+    const sqliteFile = 'file:/Users/me/.cache/xenon/xenon.db';
+    const postgresUrl = 'postgresql://xenon:s3cret@db.example.com:5432/xenon';
+    it('accepts a SQLite file with a SQLite client and says nothing', () => {
+        (0, chai_1.expect)((0, database_check_1.checkDatabase)({ configured: 'sqlite', url: sqliteFile, client: 'sqlite' })).to.deep.equal({});
+    });
+    it('runs a SQLite file on a SQLite client when configured for postgresql, with a warning', () => {
+        const { warning } = (0, database_check_1.checkDatabase)({
+            configured: 'postgresql',
+            url: sqliteFile,
+            client: 'sqlite',
+        });
+        (0, chai_1.expect)(warning).to.be.a('string');
+        (0, chai_1.expect)(warning).to.match(/databaseProvider/);
+        (0, chai_1.expect)(warning).to.match(/SQLite/);
+        (0, chai_1.expect)(warning).to.include('/Users/me/.cache/xenon/xenon.db');
+    });
+    it('refuses a postgres URL when the client is built for SQLite, without printing the password', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'postgresql', url: postgresUrl, client: 'sqlite' }))
+            .to.throw(/SQLite/)
+            .with.property('message')
+            .that.does.not.include('s3cret');
+    });
+    it('refuses a postgres URL even when databaseProvider says sqlite', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'sqlite', url: postgresUrl, client: 'sqlite' })).to.throw(/db\.example\.com/);
+    });
+    it('accepts a postgres URL when the client was generated for PostgreSQL', () => {
+        (0, chai_1.expect)((0, database_check_1.checkDatabase)({ configured: 'postgresql', url: postgresUrl, client: 'postgresql' })).to.deep.equal({});
+    });
+    it('refuses a SQLite file when the client was generated for PostgreSQL', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'postgresql', url: sqliteFile, client: 'postgresql' })).to.throw(/PostgreSQL/);
+    });
+    it('refuses a URL it cannot place', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'sqlite', url: 'mysql://h/db', client: 'sqlite' })).to.throw(/mysql:/);
+    });
+});
+describe('clientProviderFromSchema', () => {
+    it("reads the datasource's provider, not the generator's", () => {
+        const schema = [
+            'generator client {',
+            '  provider      = "prisma-client-js"',
+            '}',
+            '',
+            'datasource db {',
+            '  provider = "postgresql"',
+            '  url      = env("DATABASE_URL")',
+            '}',
+        ].join('\n');
+        (0, chai_1.expect)((0, database_check_1.clientProviderFromSchema)(schema)).to.equal('postgresql');
+    });
+    it('returns null when there is no datasource', () => {
+        (0, chai_1.expect)((0, database_check_1.clientProviderFromSchema)('generator client {}')).to.equal(null);
+    });
+});
+describe('describeDatabaseUrl', () => {
+    it('keeps a SQLite path and drops credentials from a server URL', () => {
+        (0, chai_1.expect)((0, database_check_1.describeDatabaseUrl)('file:/data/xenon.db')).to.equal('/data/xenon.db');
+        (0, chai_1.expect)((0, database_check_1.describeDatabaseUrl)('postgresql://u:p@h:5432/db?schema=x')).to.equal('postgresql://h:5432/db');
+    });
+});
+describe('assertSupportedDatabase', () => {
+    let saved;
+    beforeEach(() => {
+        saved = { provider: config_1.config.databaseProvider, url: config_1.config.databaseUrl };
+    });
+    afterEach(() => {
+        config_1.config.databaseProvider = saved.provider;
+        config_1.config.databaseUrl = saved.url;
+        sinon_1.default.restore();
+    });
+    // These read the generated client this repo ships (src/generated/client),
+    // which is built for SQLite.
+    it('stops a server whose URL is a postgres database', () => {
+        config_1.config.databaseProvider = 'postgresql';
+        config_1.config.databaseUrl = 'postgresql://xenon:pw@127.0.0.1:5432/xenon';
+        (0, chai_1.expect)(() => (0, database_check_1.assertSupportedDatabase)()).to.throw(/built for SQLite/);
+    });
+    it('starts a postgresql-labelled server on its SQLite file, and says so once', () => {
+        const warn = sinon_1.default.stub(logger_1.default, 'warn');
+        config_1.config.databaseProvider = 'postgresql';
+        config_1.config.databaseUrl = 'file:/tmp/xenon-check.db';
+        (0, database_check_1.assertSupportedDatabase)();
+        (0, chai_1.expect)(warn.callCount).to.equal(1);
+        (0, chai_1.expect)(String(warn.firstCall.args[0])).to.include('/tmp/xenon-check.db');
+    });
+    it('is silent for the default SQLite setup', () => {
+        const warn = sinon_1.default.stub(logger_1.default, 'warn');
+        config_1.config.databaseProvider = 'sqlite';
+        config_1.config.databaseUrl = 'file:/tmp/xenon-check.db';
+        (0, database_check_1.assertSupportedDatabase)();
+        (0, chai_1.expect)(warn.called).to.equal(false);
+    });
+});

package/lib/test/unit/default-plugin-args.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const schema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', '..', 'schema.json'), 'utf8'));
+/**
+ * Appium fills every default schema.json declares, so a server started the
+ * normal way runs on those. DefaultPluginArgs (the block in
+ * scripts/generate-types-from-schema.js) is the copy the plugin merges under
+ * its options, and used to say 86400000 ms for the health check while the
+ * schema, and so the running server, said 300000. A second copy that can
+ * disagree is how the Settings page came to show a third number.
+ */
+describe('DefaultPluginArgs', () => {
+    it('agrees with every default schema.json declares', () => {
+        const disagreements = Object.entries(schema.properties)
+            .filter(([key, prop]) => 'default' in prop && key in IPluginArgs_1.DefaultPluginArgs)
+            .filter(([key, prop]) => IPluginArgs_1.DefaultPluginArgs[key] !== undefined &&
+            JSON.stringify(IPluginArgs_1.DefaultPluginArgs[key]) !==
+                JSON.stringify(prop.default))
+            .map(([key, prop]) => ({
+            key,
+            schema: prop.default,
+            defaultPluginArgs: IPluginArgs_1.DefaultPluginArgs[key],
+        }));
+        (0, chai_1.expect)(disagreements).to.deep.equal([]);
+    });
+});

package/lib/test/unit/device-log-book.spec.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const deviceLogBook_1 = require("../../src/services/logcat/deviceLogBook");
+const logcatParse_1 = require("../../src/services/logcat/logcatParse");
+const pad = (n, w = 2) => String(n).padStart(w, '0');
+/** A threadtime line logged at `at` by this machine's local clock. */
+function lineAt(at, level = 'I', msg = 'hello', tag = 'Tag', pid = 4127) {
+    const t = new Date(at);
+    return (`${pad(t.getMonth() + 1)}-${pad(t.getDate())} ${pad(t.getHours())}:${pad(t.getMinutes())}:` +
+        `${pad(t.getSeconds())}.${pad(t.getMilliseconds(), 3)}  ${pid}  ${pid} ${level} ${tag}: ${msg}`);
+}
+function recAt(at, level = 'I', msg = 'hello', tag = 'Tag') {
+    const rec = (0, logcatParse_1.parseThreadtimeLine)(lineAt(at, level, msg, tag), new Date(at));
+    if (!rec)
+        throw new Error('not a line');
+    return rec;
+}
+// The dashboard's own reading of a device log line (web log-derive.ts).
+const DASHBOARD_THREADTIME = /^\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d+\s+\d+\s+\d+\s+([VDIWEF])\s/;
+// Mid-January, midday: no daylight-saving change within hours of it.
+const T0 = new Date(2026, 0, 15, 12, 0, 0, 0).getTime();
+describe('DeviceLogBook', () => {
+    describe('formatThreadtime', () => {
+        it('prints a record as logcat printed it, so it parses back the same', () => {
+            const line = '01-15 12:00:00.120  4127  4130 E AndroidRuntime: FATAL EXCEPTION: main';
+            const rec = (0, logcatParse_1.parseThreadtimeLine)(line, new Date(T0));
+            const printed = (0, deviceLogBook_1.formatThreadtime)(rec);
+            (0, chai_1.expect)(printed).to.equal(line);
+            (0, chai_1.expect)((0, logcatParse_1.parseThreadtimeLine)(printed, new Date(T0))).to.deep.equal(rec);
+        });
+        it("pads a short tag to logcat's eight columns, and the dashboard reads its level", () => {
+            var _a;
+            const printed = (0, deviceLogBook_1.formatThreadtime)(recAt(T0, 'F', 'boom', 'DEBUG'));
+            (0, chai_1.expect)(printed).to.match(/ F DEBUG {3}: boom$/);
+            (0, chai_1.expect)((_a = DASHBOARD_THREADTIME.exec(printed)) === null || _a === void 0 ? void 0 : _a[1]).to.equal('F');
+        });
+        it('keeps a wrapped message whole', () => {
+            const rec = Object.assign(Object.assign({}, recAt(T0)), { message: 'first\nwrapped remainder' });
+            (0, chai_1.expect)((0, deviceLogBook_1.formatThreadtime)(rec)).to.match(/Tag {5}: first\nwrapped remainder$/);
+        });
+    });
+    describe('the session window', () => {
+        it('keeps lines from shortly before the phone was given to the session, and not before', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            (0, chai_1.expect)(book.add(recAt(T0 - deviceLogBook_1.WINDOW_SLACK_MS - 1))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0 - deviceLogBook_1.WINDOW_SLACK_MS))).to.have.length(1);
+            (0, chai_1.expect)(book.add(recAt(T0 + 60000))).to.have.length(1);
+        });
+        it('stamps each line with its own time, and keeps the text the phone printed', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            const [row] = book.add(recAt(T0 + 1234, 'W', 'low memory'));
+            (0, chai_1.expect)(row.timestamp.getTime()).to.equal(T0 + 1234);
+            (0, chai_1.expect)(row.message).to.equal(lineAt(T0 + 1234, 'W', 'low memory').replace('Tag:', 'Tag     :'));
+        });
+        it('reads a phone in another time zone at the moment it logged, not hours off', () => {
+            // The phone is 5 h 30 min ahead: its 17:30 is this server's 12:00.
+            const ahead = 5.5 * 3600000;
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: { zoneShiftMs: -ahead, skewMs: 0 } });
+            // Printed an hour before the session by the phone's clock: left out.
+            (0, chai_1.expect)(book.add(recAt(T0 + ahead - 3600000))).to.deep.equal([]);
+            const [row] = book.add(recAt(T0 + ahead + 5000));
+            (0, chai_1.expect)(row.timestamp.getTime()).to.equal(T0 + 5000);
+            // The text is the phone's own, as it printed it.
+            (0, chai_1.expect)(row.message).to.match(/^01-15 17:30:05\.000 /);
+        });
+        it("cuts and stamps by this server's clock when the phone's runs behind", () => {
+            // The phone's clock is 40 s slow: a line it stamps 30 s before the
+            // session came 10 s after the session began, and one it stamps 43 s
+            // before came 3 s before.
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: { zoneShiftMs: 0, skewMs: 40000 } });
+            (0, chai_1.expect)(book.add(recAt(T0 - 43000))).to.deep.equal([]);
+            const [row] = book.add(recAt(T0 - 30000));
+            (0, chai_1.expect)(row.timestamp.getTime()).to.equal(T0 + 10000);
+            // The text keeps the time the phone printed.
+            (0, chai_1.expect)(row.message).to.match(/^01-15 11:59:30\.000 /);
+        });
+        it("ignores the stream's own notes", () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            (0, chai_1.expect)(book.add(Object.assign(Object.assign({}, recAt(T0)), { tag: 'xenon', synthetic: true }))).to.deep.equal([]);
+        });
+    });
+    describe('after an interruption', () => {
+        it('counts only lines newer than the last it saw, by content at that millisecond', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            book.add(recAt(T0 + 1000, 'I', 'one'));
+            book.add(recAt(T0 + 2000, 'E', 'stack line 1'));
+            book.add(recAt(T0 + 2000, 'E', 'stack line 2'));
+            const [note] = book.interrupted(new Date(T0 + 3000));
+            (0, chai_1.expect)(note.message).to.equal("Xenon: The phone's log was interrupted. Lines may be missing from here.");
+            // The new stream's history repeats what was kept...
+            (0, chai_1.expect)(book.add(recAt(T0 + 1000, 'I', 'one'))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0 + 2000, 'E', 'stack line 1'))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0 + 2000, 'E', 'stack line 2'))).to.deep.equal([]);
+            // ...and has a line of that same millisecond that hadn't arrived yet.
+            (0, chai_1.expect)(book.add(recAt(T0 + 2000, 'E', 'stack line 3'))).to.have.length(1);
+            (0, chai_1.expect)(book.add(recAt(T0 + 4000, 'I', 'after'))).to.have.length(1);
+            (0, chai_1.expect)(book.keptLines).to.equal(5);
+        });
+        it('keeps the session window when nothing had arrived yet', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            book.interrupted(new Date(T0));
+            (0, chai_1.expect)(book.add(recAt(T0 - 60000))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0))).to.have.length(1);
+        });
+    });
+    describe('the limit', () => {
+        it('keeps every line up to the limit, then errors only, then nothing, and says so', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({
+                since: T0,
+                clock: deviceLogBook_1.UNKNOWN_CLOCK,
+                lineLimit: 3,
+                errorLimit: 2,
+            });
+            const kept = [];
+            const add = (level, msg, at) => kept.push(...book.add(recAt(T0 + at, level, msg)).map((r) => r.message));
+            add('D', 'a', 1);
+            add('I', 'b', 2);
+            add('W', 'c', 3);
+            add('I', 'chatter', 4); // past the limit: left out, after the note
+            add('E', 'FATAL EXCEPTION: main', 5);
+            add('D', 'more chatter', 6);
+            add('F', 'abort', 7);
+            add('E', 'one error too many', 8);
+            (0, chai_1.expect)(kept.map((m) => m.replace(/^.*Tag {5}: /, ''))).to.deep.equal([
+                'a',
+                'b',
+                'c',
+                'Xenon: This session reached 3 device log lines. From here on, only errors are kept.',
+                'FATAL EXCEPTION: main',
+                'abort',
+            ]);
+            (0, chai_1.expect)(book.finish(new Date(T0 + 9)).map((r) => r.message)).to.deep.equal([
+                "Xenon: 3 device log lines were left out to keep this session's log within its limit.",
+            ]);
+        });
+        it('says nothing at the end when nothing was left out', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            book.add(recAt(T0));
+            (0, chai_1.expect)(book.finish(new Date(T0))).to.deep.equal([]);
+        });
+        it('is 10,000 lines, then 2,000 errors', () => {
+            (0, chai_1.expect)(deviceLogBook_1.DEVICE_LOG_LINE_LIMIT).to.equal(10000);
+            (0, chai_1.expect)(deviceLogBook_1.DEVICE_LOG_ERROR_LIMIT).to.equal(2000);
+        });
+    });
+    describe('parseDeviceClock', () => {
+        const fields = (at) => {
+            const t = new Date(at);
+            return `${pad(t.getMonth() + 1)}-${pad(t.getDate())}.${pad(t.getHours())}:${pad(t.getMinutes())}:${pad(t.getSeconds())}`;
+        };
+        it("finds a phone's time zone against this server's, to the quarter hour", () => {
+            const secs = Math.floor(T0 / 1000);
+            const ahead = 5.5 * 3600000;
+            // The phone prints its local time, 5 h 30 min ahead of this server's.
+            const out = `${secs}.348157848.${fields(secs * 1000 + ahead)}\n`;
+            const clock = (0, deviceLogBook_1.parseDeviceClock)(out, T0 + 300);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.zoneShiftMs).to.equal(-ahead);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.skewMs).to.equal(300 - 348);
+        });
+        it('finds a phone in the same zone, its clock 2.8 s slow, as the lab S9+ was', () => {
+            const secs = Math.floor(T0 / 1000) - 3;
+            const clock = (0, deviceLogBook_1.parseDeviceClock)(`${secs}.200000000.${fields(secs * 1000)}`, T0);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.zoneShiftMs).to.equal(0);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.skewMs).to.equal(2800);
+        });
+        it("takes the middle of the second when the phone's date prints no nanoseconds", () => {
+            const secs = Math.floor(T0 / 1000) + 7;
+            for (const nanos of ['%N', 'N', '']) {
+                const clock = (0, deviceLogBook_1.parseDeviceClock)(`${secs}.${nanos}.${fields(secs * 1000)}`, T0);
+                (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.skewMs, nanos).to.equal(-7500);
+            }
+        });
+        it("is null for anything that isn't the date it asked for", () => {
+            (0, chai_1.expect)((0, deviceLogBook_1.parseDeviceClock)('', T0)).to.equal(null);
+            (0, chai_1.expect)((0, deviceLogBook_1.parseDeviceClock)('date: bad format', T0)).to.equal(null);
+            (0, chai_1.expect)((0, deviceLogBook_1.parseDeviceClock)('%s.%N.%m-%d.%H:%M:%S', T0)).to.equal(null);
+        });
+    });
+});

package/lib/test/unit/device-offline-webhook.spec.js

@@ -0,0 +1,81 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const device_service_1 = require("../../src/data-service/device-service");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const container_registration_1 = require("../helpers/container-registration");
+const loki_stores_1 = require("../helpers/loki-stores");
+/**
+ * The `device_offline` webhook carries the device's name and platform, as its
+ * documented payload says (src/services/webhookEvents.ts). Every caller of
+ * `removeDevice` holds only a udid and a host, so the event used to carry just
+ * those two and `{{name}}` stayed unfilled in a template.
+ */
+describe('device_offline: what the event carries', () => {
+    (0, loki_stores_1.useLokiStores)();
+    let restore;
+    let dispatch;
+    const HOST = 'http://127.0.0.1:4723';
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(NotificationService_1.NotificationService, SocketServer_1.SocketServer);
+        dispatch = sinon_1.default.stub().resolves();
+        typedi_1.Container.set({ id: NotificationService_1.NotificationService, value: { dispatchEvent: dispatch } });
+        typedi_1.Container.set({
+            id: SocketServer_1.SocketServer,
+            value: {
+                emitToDashboard: () => undefined,
+                emitToDashboardForDevices: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+                hasScopedDashboard: () => false,
+            },
+        });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    const phone = () => ({
+        udid: 'R58M123',
+        name: 'Galaxy S9+',
+        platform: 'android',
+        sdk: '10',
+        host: HOST,
+        busy: false,
+        offline: false,
+        userBlocked: false,
+        deviceType: 'real',
+        realDevice: true,
+    });
+    it('names the device and its platform, though the caller passed only a udid and a host', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, device_service_1.addNewDevice)([phone()]);
+        dispatch.resetHistory();
+        yield (0, device_service_1.removeDevice)([{ udid: 'R58M123', host: HOST }]);
+        (0, chai_1.expect)(dispatch.calledOnce).to.equal(true);
+        (0, chai_1.expect)(dispatch.firstCall.args[0]).to.equal('device_offline');
+        (0, chai_1.expect)(dispatch.firstCall.args[1]).to.include({
+            udid: 'R58M123',
+            host: HOST,
+            name: 'Galaxy S9+',
+            platform: 'android',
+        });
+    }));
+    it('still reports a device the store no longer knows, by its udid and host', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, device_service_1.removeDevice)([{ udid: 'gone-1', host: HOST }]);
+        (0, chai_1.expect)(dispatch.firstCall.args[1]).to.deep.include({ udid: 'gone-1', host: HOST });
+    }));
+});