@xenon-device-management/xenon 2.4.0 → 2.6.0

package/lib/src/app/routers/dashboard.js

@@ -65,6 +65,7 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../../config");
 const sessionVisibility_1 = require("../../services/device-access/sessionVisibility");
 const HealEtalonService_1 = require("../../services/healing/HealEtalonService");
+const sessionInsights_1 = require("./sessionInsights");
 const logger_1 = __importDefault(require("../../logger"));
 const MJPEG_PROXY_CACHE = new Map();
 const authOf = (request) => request.auth;
@@ -100,10 +101,29 @@ function isValidSession(request, response, next) {
         }
     });
 }
+// A `since` that isn't a date is refused, rather than ignored into a list
+// of every session.
+function sinceOf(request, response) {
+    try {
+        return (0, sessionInsights_1.parseSince)(request.query.since);
+    }
+    catch (err) {
+        if (!(err instanceof sessionInsights_1.InvalidSinceError))
+            throw err;
+        response.status(400).json({ error: 'invalid_since', message: err.message });
+        return undefined;
+    }
+}
 function getSessions(request, response) {
     return __awaiter(this, void 0, void 0, function* () {
         const { buildId, query, status, platform } = request.query;
+        const since = sinceOf(request, response);
+        if (since === undefined)
+            return;
         const where = {};
+        if (since) {
+            where.createdAt = { gte: since };
+        }
         if (buildId) {
             where.build_id = buildId;
         }
@@ -132,7 +152,26 @@ function getSessions(request, response) {
             where: visible ? { AND: [where, visible] } : where,
             take: 500,
         });
-        return response.status(200).json(sessions);
+        return response.status(200).json(yield (0, sessionInsights_1.describeSessions)(sessions));
+    });
+}
+// The Sessions page's summary strip: the period since `since` (all time
+// without it) and the one before it, over the sessions the caller may see,
+// of one build when `buildId` is given.
+function getSessionSummary(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const since = sinceOf(request, response);
+        if (since === undefined)
+            return;
+        const { buildId } = request.query;
+        const visible = yield (0, sessionVisibility_1.visibleSessionWhere)(authOf(request));
+        const scope = {
+            AND: [
+                ...(visible ? [visible] : []),
+                ...(typeof buildId === 'string' && buildId ? [{ build_id: buildId }] : []),
+            ],
+        };
+        return response.status(200).json(yield (0, sessionInsights_1.summarizeSessions)(scope, since));
     });
 }
 function getBuilds(request, response) {
@@ -154,7 +193,7 @@ function getBuilds(request, response) {
         });
         const visibleBuilds = visible ? builds.filter((b) => b.sessions.length > 0) : builds;
         // Principal formatting: Add a flat summary object for the frontend
-        const formattedBuilds = visibleBuilds.map((b) => (Object.assign(Object.assign({}, b), { _count: { sessions: b.sessions.length }, sessionCount: b.sessions.length, passedCount: b.sessions.filter((s) => ['success', 'passed'].includes(s.status)).length, failedCount: b.sessions.filter((s) => s.status === 'failed').length, runningCount: b.sessions.filter((s) => s.status === 'running').length, sessions: undefined })));
+        const formattedBuilds = visibleBuilds.map((b) => (Object.assign(Object.assign({}, b), { _count: { sessions: b.sessions.length }, sessionCount: b.sessions.length, passedCount: b.sessions.filter((s) => (0, sessionInsights_1.sessionOutcome)(s.status) === 'passed').length, failedCount: b.sessions.filter((s) => (0, sessionInsights_1.sessionOutcome)(s.status) === 'failed').length, runningCount: b.sessions.filter((s) => (0, sessionInsights_1.sessionOutcome)(s.status) === 'running').length, sessions: undefined })));
         return response.status(200).json(formattedBuilds);
     });
 }
@@ -168,7 +207,9 @@ function getSessionById(request, response) {
         if (!session) {
             return response.status(404).json({ error: true, message: 'Session not found' });
         }
-        return response.status(200).json(session);
+        // Who ran it and where, as the list says (describeSessions).
+        const [described] = yield (0, sessionInsights_1.describeSessions)([session]);
+        return response.status(200).json(described);
     });
 }
 function getSessionLogs(request, response) {
@@ -1074,6 +1115,7 @@ function register(router) {
     router.use('/session/:sessionId', isValidSession);
     router.use((0, roleGuard_1.roleGuard)('MEMBER'));
     router.get('/session', getSessions);
+    router.get('/session-summary', getSessionSummary);
     router.get('/session/:sessionId', getSessionById);
     router.get('/build', getBuilds);
     build_export_1.default.register(router);

package/lib/src/app/routers/sessionInsights.js

@@ -0,0 +1,221 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSinceError = void 0;
+exports.sessionOutcome = sessionOutcome;
+exports.parseSince = parseSince;
+exports.describeSessions = describeSessions;
+exports.percentile = percentile;
+exports.summarizeSessions = summarizeSessions;
+const typedi_1 = require("typedi");
+const prisma_1 = require("../../prisma");
+const PluginContext_1 = require("../../PluginContext");
+const localDeviceHosts_1 = require("../../device-managers/localDeviceHosts");
+/**
+ * The verdict of a persisted `Session.status`. The dashboard's
+ * `sessionStatusBucket` (web/src/components/builds/derive.ts) is the same
+ * rule, so a build's counts and its rows agree.
+ */
+function sessionOutcome(status) {
+    switch (status) {
+        case 'success':
+        case 'passed':
+        case 'ended':
+            return 'passed';
+        case 'failed':
+        case 'error':
+        case 'timeout':
+            return 'failed';
+        case 'running':
+            return 'running';
+        default:
+            return 'other';
+    }
+}
+class InvalidSinceError extends Error {
+    constructor() {
+        super('since must be an ISO 8601 date');
+    }
+}
+exports.InvalidSinceError = InvalidSinceError;
+/** The `since` query parameter: null when absent; a date, or InvalidSinceError. */
+function parseSince(raw) {
+    if (raw === undefined || raw === '')
+        return null;
+    const at = typeof raw === 'string' ? Date.parse(raw) : NaN;
+    if (!Number.isFinite(at))
+        throw new InvalidSinceError();
+    return new Date(at);
+}
+/**
+ * Each listed session with who ran it (`owner`) and where (`ranOn`): 'here'
+ * for this server, the node's host for another server's phone, null when
+ * that isn't known any more. Four queries for the whole list, never one per
+ * row. Members can't read the users list, so the dashboard can't name owners
+ * itself.
+ */
+function describeSessions(rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [owners, places] = yield Promise.all([ownersOf(rows), placesOf(rows)]);
+        return rows.map((row) => {
+            var _a, _b;
+            return (Object.assign(Object.assign({}, row), { owner: (_a = owners.get(row.id)) !== null && _a !== void 0 ? _a : null, ranOn: (_b = places.get(row.id)) !== null && _b !== void 0 ? _b : null }));
+        });
+    });
+}
+// SessionOwnerResolver.ownerOf's rule, for a list: the row's user, else, for
+// a row written before user_id existed, its key's owner.
+function ownersOf(rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const legacyKeyIds = [
+            ...new Set(rows.filter((r) => !r.user_id && r.api_key_id).map((r) => r.api_key_id)),
+        ];
+        const keyOwner = new Map();
+        if (legacyKeyIds.length > 0) {
+            const keys = yield prisma_1.prisma.apiKey.findMany({
+                where: { id: { in: legacyKeyIds } },
+                select: { id: true, userId: true },
+            });
+            for (const key of keys)
+                keyOwner.set(key.id, key.userId);
+        }
+        const ownerId = (r) => { var _a; return (_a = r.user_id) !== null && _a !== void 0 ? _a : (r.api_key_id ? keyOwner.get(r.api_key_id) : undefined); };
+        const userIds = [...new Set(rows.map(ownerId).filter((id) => !!id))];
+        const users = userIds.length > 0
+            ? yield prisma_1.prisma.user.findMany({
+                where: { id: { in: userIds } },
+                select: { id: true, name: true, email: true },
+            })
+            : [];
+        const byId = new Map(users.map((u) => [u.id, { name: u.name || u.email, email: u.email }]));
+        const out = new Map();
+        for (const row of rows) {
+            const owner = byId.get((_a = ownerId(row)) !== null && _a !== void 0 ? _a : '');
+            if (owner)
+                out.set(row.id, owner);
+        }
+        return out;
+    });
+}
+// Node ids are new on every boot, so a session's node_id names its server
+// only until that server restarts. Past that, its phone's row says where it
+// is: the row of that node id, else the phone's only row. A udid on more than
+// one server (an emulator's) with no row of that node id isn't guessed.
+function placesOf(rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        const nodeIds = [...new Set(rows.map((r) => r.node_id).filter(Boolean))];
+        const udids = [...new Set(rows.map((r) => r.device_udid).filter(Boolean))];
+        if (udids.length === 0 && nodeIds.length === 0)
+            return new Map();
+        const devices = yield prisma_1.prisma.device.findMany({
+            where: { OR: [{ nodeId: { in: nodeIds } }, { udid: { in: udids } }] },
+            select: { udid: true, host: true, nodeId: true },
+        });
+        const local = (0, localDeviceHosts_1.localDeviceHosts)(context.pluginArgs, context.port);
+        const out = new Map();
+        for (const row of rows) {
+            if (row.node_id && row.node_id === context.nodeId) {
+                out.set(row.id, 'here');
+                continue;
+            }
+            const sameUdid = devices.filter((d) => d.udid === row.device_udid);
+            const device = (_a = sameUdid.find((d) => d.nodeId && d.nodeId === row.node_id)) !== null && _a !== void 0 ? _a : (sameUdid.length === 1 ? sameUdid[0] : undefined);
+            if (!device)
+                continue;
+            out.set(row.id, (0, localDeviceHosts_1.isOwnDevice)(local, context.nodeId, device) ? 'here' : hostLabel(device.host));
+        }
+        return out;
+    });
+}
+/** A host as people read it: no scheme, no trailing slash. */
+function hostLabel(host) {
+    return host.replace(/^[a-z][a-z0-9+.-]*:\/\//i, '').replace(/\/+$/, '');
+}
+/**
+ * Durations come from at most this many of the period's newest ended
+ * sessions, so a long period costs one bounded read; past it they are an
+ * estimate from the newest.
+ */
+const DURATION_SAMPLE = 10000;
+/** Nearest-rank percentile of ascending values; null for none. */
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return null;
+    const rank = Math.max(1, Math.ceil((p / 100) * sorted.length));
+    return sorted[rank - 1];
+}
+/**
+ * The Sessions page's summary strip: the period from `since` to now, the
+ * period of the same length before it, and what runs now, over the sessions
+ * `scope` admits (the caller's visibility, and a build when one is chosen).
+ * Without `since` the period is all time and there is none before it.
+ */
+function summarizeSessions(scope_1, since_1) {
+    return __awaiter(this, arguments, void 0, function* (scope, since, now = Date.now()) {
+        const within = (from, to) => {
+            const createdAt = {};
+            if (from)
+                createdAt.gte = from;
+            if (to)
+                createdAt.lt = to;
+            return Object.keys(createdAt).length ? { AND: [scope, { createdAt }] } : scope;
+        };
+        const counts = (where) => __awaiter(this, void 0, void 0, function* () {
+            // groupBy's generated type can't be satisfied with a `where` built at
+            // run time; the result's shape is fixed by `by` and `_count`.
+            const groups = (yield prisma_1.prisma.session.groupBy({
+                by: ['status'],
+                where,
+                _count: { _all: true },
+            }));
+            const out = { total: 0, passed: 0, failed: 0, running: 0 };
+            for (const g of groups) {
+                out.total += g._count._all;
+                const outcome = sessionOutcome(g.status);
+                if (outcome !== 'other')
+                    out[outcome] += g._count._all;
+            }
+            return out;
+        });
+        const current = within(since, null);
+        const previousFrom = since ? new Date(since.getTime() - (now - since.getTime())) : null;
+        const [currentCounts, previous, ended, running] = yield Promise.all([
+            counts(current),
+            since ? counts(within(previousFrom, since)) : Promise.resolve(null),
+            prisma_1.prisma.session.findMany({
+                where: { AND: [current, { endTime: { not: null } }, { status: { not: 'running' } }] },
+                select: { startTime: true, endTime: true },
+                orderBy: { createdAt: 'desc' },
+                take: DURATION_SAMPLE,
+            }),
+            prisma_1.prisma.session.findMany({
+                where: { AND: [scope, { status: 'running' }] },
+                select: { device_udid: true },
+            }),
+        ]);
+        const durations = ended
+            .map((s) => (s.endTime ? s.endTime.getTime() - s.startTime.getTime() : -1))
+            .filter((ms) => ms >= 0)
+            .sort((a, b) => a - b);
+        return {
+            since: since ? since.toISOString() : null,
+            current: Object.assign(Object.assign({}, currentCounts), { medianMs: percentile(durations, 50), p90Ms: percentile(durations, 90) }),
+            previous,
+            runningNow: {
+                sessions: running.length,
+                devices: new Set(running.map((s) => s.device_udid)).size,
+            },
+        };
+    });
+}

package/lib/test/unit/session-list-insights.spec.js

@@ -0,0 +1,354 @@
+"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 express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const scratch_database_1 = require("../helpers/scratch-database");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const dashboard_1 = __importDefault(require("../../src/app/routers/dashboard"));
+/**
+ * What the Sessions page reads besides the rows themselves: the period filter
+ * on the list, who ran each session and where, the period summary, and the
+ * per-build counts. Real queries against a scratch database, because each of
+ * these is a Prisma filter a stub would only echo.
+ */
+describe('Sessions page data', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const HOUR = 60 * 60 * 1000;
+    const MIN = 60 * 1000;
+    let context;
+    let saved;
+    let now;
+    let caller;
+    // An admin: teamIds undefined, so every session is visible.
+    const ADMIN = { kind: 'user-session', userId: 'admin-1', role: 'SUPER_ADMIN', scopes: 'admin' };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = Object.assign({}, context);
+        context.setContext(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }), 4723, 'hub-1', '');
+        now = Date.now();
+        caller = ADMIN;
+        for (const model of ['session', 'build', 'apiKey', 'user', 'device']) {
+            yield scratch.db[model].deleteMany({});
+        }
+    }));
+    afterEach(() => {
+        Object.assign(context, saved);
+    });
+    const app = () => {
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use((req, _res, next) => {
+            req.auth = caller;
+            next();
+        });
+        dashboard_1.default.register(a);
+        return a;
+    };
+    let seq = 0;
+    const session = (fields) => {
+        seq += 1;
+        return scratch.db.session.create({
+            data: Object.assign({ id: `s-${seq}`, status: 'success', desired_capabilities: '{}', session_capabilities: '{}', node_id: 'hub-1', has_live_video: false, device_udid: 'phone-1', device_platform: 'android', device_version: '14' }, fields),
+        });
+    };
+    const ago = (ms) => new Date(now - ms);
+    const user = (id, name, email) => scratch.db.user.create({
+        data: { id, name, email, passwordHash: 'x', accessKey: `ak-${id}` },
+    });
+    describe('GET /session', () => {
+        it('keeps the sessions created since the given time, newest first', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield session({ id: 'old', createdAt: ago(3 * HOUR) });
+            yield session({ id: 'recent', createdAt: ago(30 * MIN) });
+            yield session({ id: 'newest', createdAt: ago(5 * MIN) });
+            const res = yield (0, loopbackRequest_1.default)(app()).get(`/session?since=${ago(HOUR).toISOString()}`);
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.map((s) => s.id)).to.deep.equal(['newest', 'recent']);
+            const all = yield (0, loopbackRequest_1.default)(app()).get('/session');
+            (0, chai_1.expect)(all.body.map((s) => s.id)).to.deep.equal(['newest', 'recent', 'old']);
+        }));
+        it('refuses a since that is not a date', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session?since=yesterday-ish');
+            (0, chai_1.expect)(res.status).to.equal(400);
+            (0, chai_1.expect)(res.body.error).to.equal('invalid_since');
+        }));
+        it('names who ran each session: its user, or an older row’s key owner', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield user('u-priya', 'Priya Shah', 'priya@example.com');
+            yield user('u-alex', '', 'alex@example.com');
+            yield scratch.db.apiKey.create({
+                data: { id: 'key-1', name: 'ci', keyHash: 'h1', scopes: 'sessions', userId: 'u-alex' },
+            });
+            yield session({ id: 'by-user', user_id: 'u-priya', createdAt: ago(4 * MIN) });
+            yield session({ id: 'by-key', api_key_id: 'key-1', createdAt: ago(3 * MIN) });
+            yield session({ id: 'gone-user', user_id: 'u-deleted', createdAt: ago(2 * MIN) });
+            yield session({ id: 'nobody', createdAt: ago(1 * MIN) });
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session');
+            const owner = Object.fromEntries(res.body.map((s) => [s.id, s.owner]));
+            (0, chai_1.expect)(owner['by-user']).to.deep.equal({ name: 'Priya Shah', email: 'priya@example.com' });
+            // No name on record: the email stands in for it.
+            (0, chai_1.expect)(owner['by-key']).to.deep.equal({
+                name: 'alex@example.com',
+                email: 'alex@example.com',
+            });
+            (0, chai_1.expect)(owner['gone-user']).to.equal(null);
+            (0, chai_1.expect)(owner['nobody']).to.equal(null);
+        }));
+        it('says where each session ran: here, a node by its host, or not known', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'own-phone',
+                    host: 'http://127.0.0.1:4723',
+                    nodeId: 'hub-1',
+                    platform: 'android',
+                },
+            });
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'node-phone',
+                    host: 'http://10.0.0.9:4725',
+                    nodeId: 'node-2',
+                    platform: 'ios',
+                },
+            });
+            yield session({
+                id: 'this-boot',
+                node_id: 'hub-1',
+                device_udid: 'own-phone',
+                createdAt: ago(5 * MIN),
+            });
+            // Node ids are new on every boot, so an older session of this server's
+            // own phone carries an id nothing matches any more; its phone's row says.
+            yield session({
+                id: 'last-boot',
+                node_id: 'old-boot',
+                device_udid: 'own-phone',
+                createdAt: ago(4 * MIN),
+            });
+            yield session({
+                id: 'on-node',
+                node_id: 'node-2',
+                device_udid: 'node-phone',
+                createdAt: ago(3 * MIN),
+            });
+            yield session({
+                id: 'node-restarted',
+                node_id: 'node-2-old',
+                device_udid: 'node-phone',
+                createdAt: ago(2 * MIN),
+            });
+            yield session({
+                id: 'phone-gone',
+                node_id: 'node-9',
+                device_udid: 'unplugged',
+                createdAt: ago(1 * MIN),
+            });
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session');
+            const ranOn = Object.fromEntries(res.body.map((s) => [s.id, s.ranOn]));
+            (0, chai_1.expect)(ranOn).to.deep.equal({
+                'this-boot': 'here',
+                'last-boot': 'here',
+                'on-node': '10.0.0.9:4725',
+                'node-restarted': '10.0.0.9:4725',
+                'phone-gone': null,
+            });
+        }));
+        it('does not guess when the same udid is on more than one server', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'emulator-5554',
+                    host: 'http://127.0.0.1:4723',
+                    nodeId: 'hub-1',
+                    platform: 'android',
+                },
+            });
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'emulator-5554',
+                    host: 'http://10.0.0.9:4725',
+                    nodeId: 'node-2',
+                    platform: 'android',
+                },
+            });
+            yield session({ id: 'which', node_id: 'old-boot', device_udid: 'emulator-5554' });
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session');
+            (0, chai_1.expect)(res.body[0].ranOn).to.equal(null);
+        }));
+    });
+    describe('GET /session/:id', () => {
+        // The detail page's header names who ran the session and where, as its row does.
+        it('says who ran the session and where, as the list does', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield user('u-priya', 'Priya Shah', 'priya@example.com');
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'node-phone',
+                    host: 'http://10.0.0.9:4725',
+                    nodeId: 'node-2',
+                    platform: 'ios',
+                },
+            });
+            yield session({
+                id: 'one',
+                user_id: 'u-priya',
+                node_id: 'node-2',
+                device_udid: 'node-phone',
+            });
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session/one');
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.id).to.equal('one');
+            (0, chai_1.expect)(res.body.owner).to.deep.equal({ name: 'Priya Shah', email: 'priya@example.com' });
+            (0, chai_1.expect)(res.body.ranOn).to.equal('10.0.0.9:4725');
+        }));
+    });
+    describe('GET /session-summary', () => {
+        it('summarizes the period and the one before it, of the same length', () => __awaiter(void 0, void 0, void 0, function* () {
+            const build = yield scratch.db.build.create({ data: { name: 'nightly' } });
+            const inPeriod = (status, minutesAgo, durationS, udid = 'phone-1') => session({
+                status,
+                build_id: build.id,
+                device_udid: udid,
+                createdAt: ago(minutesAgo * MIN),
+                startTime: ago(minutesAgo * MIN),
+                endTime: durationS === undefined ? null : new Date(now - minutesAgo * MIN + durationS * 1000),
+            });
+            // The period: the last hour.
+            yield inPeriod('success', 50, 10);
+            yield inPeriod('passed', 45, 20);
+            yield inPeriod('ended', 40, 30);
+            yield inPeriod('failed', 35, 40);
+            yield inPeriod('error', 30, 50);
+            yield inPeriod('timeout', 25, 600);
+            yield inPeriod('unmarked', 20, 5);
+            yield inPeriod('running', 10, undefined, 'phone-1');
+            yield inPeriod('running', 5, undefined, 'phone-2');
+            // The hour before it.
+            yield inPeriod('success', 90, 10);
+            yield inPeriod('failed', 80, 10);
+            // Older than both, still running: running now, but in neither period.
+            yield inPeriod('running', 300, undefined, 'phone-1');
+            const res = yield (0, loopbackRequest_1.default)(app()).get(`/session-summary?since=${ago(HOUR).toISOString()}`);
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.since).to.equal(ago(HOUR).toISOString());
+            (0, chai_1.expect)(res.body.current).to.deep.equal({
+                total: 9,
+                passed: 3,
+                failed: 3,
+                running: 2,
+                // Of every session in it that has ended, verdict or not: 5, 10, 20,
+                // 30, 40, 50 and 600 s. Nearest rank: the 4th and the 7th of 7.
+                medianMs: 30000,
+                p90Ms: 600000,
+            });
+            (0, chai_1.expect)(res.body.previous).to.deep.equal({ total: 2, passed: 1, failed: 1, running: 0 });
+            (0, chai_1.expect)(res.body.runningNow).to.deep.equal({ sessions: 3, devices: 2 });
+        }));
+        it('covers one build, with no period before it, when asked for a build', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mine = yield scratch.db.build.create({ data: { name: 'mine' } });
+            const other = yield scratch.db.build.create({ data: { name: 'other' } });
+            yield session({
+                build_id: mine.id,
+                status: 'success',
+                startTime: ago(2 * MIN),
+                endTime: ago(MIN),
+            });
+            yield session({ build_id: mine.id, status: 'running' });
+            yield session({ build_id: other.id, status: 'failed' });
+            yield session({ build_id: other.id, status: 'running', device_udid: 'phone-9' });
+            const res = yield (0, loopbackRequest_1.default)(app()).get(`/session-summary?buildId=${mine.id}`);
+            (0, chai_1.expect)(res.body.since).to.equal(null);
+            (0, chai_1.expect)(res.body.current).to.deep.equal({
+                total: 2,
+                passed: 1,
+                failed: 0,
+                running: 1,
+                medianMs: 60000,
+                p90Ms: 60000,
+            });
+            (0, chai_1.expect)(res.body.previous).to.equal(null);
+            (0, chai_1.expect)(res.body.runningNow).to.deep.equal({ sessions: 1, devices: 1 });
+        }));
+        it('has no durations to report when nothing has finished', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield session({ status: 'running' });
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session-summary');
+            (0, chai_1.expect)(res.body.current.medianMs).to.equal(null);
+            (0, chai_1.expect)(res.body.current.p90Ms).to.equal(null);
+        }));
+        it('counts only the sessions the caller may see', () => __awaiter(void 0, void 0, void 0, function* () {
+            const team = yield scratch.db.team.create({ data: { name: 'b-team' } });
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'shared',
+                    host: 'http://127.0.0.1:4723',
+                    nodeId: 'hub-1',
+                    platform: 'android',
+                },
+            });
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'team-b',
+                    host: 'http://127.0.0.1:4723',
+                    nodeId: 'hub-1',
+                    platform: 'android',
+                    teamId: team.id,
+                },
+            });
+            yield session({ device_udid: 'shared', status: 'success' });
+            yield session({ device_udid: 'team-b', status: 'failed' });
+            yield session({ device_udid: 'team-b', status: 'running' });
+            caller = {
+                kind: 'user-session',
+                userId: 'member-1',
+                role: 'MEMBER',
+                scopes: 'sessions',
+                teamIds: [],
+            };
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session-summary');
+            (0, chai_1.expect)(res.body.current).to.include({ total: 1, passed: 1, failed: 0, running: 0 });
+            (0, chai_1.expect)(res.body.runningNow).to.deep.equal({ sessions: 0, devices: 0 });
+        }));
+        it('refuses a since that is not a date', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/session-summary?since=soon');
+            (0, chai_1.expect)(res.status).to.equal(400);
+            (0, chai_1.expect)(res.body.error).to.equal('invalid_since');
+        }));
+    });
+    describe('GET /build', () => {
+        // The page's pass/fail bar and the session rows must agree on a verdict.
+        it('counts every failing status as failed and every passing one as passed', () => __awaiter(void 0, void 0, void 0, function* () {
+            const build = yield scratch.db.build.create({ data: { name: 'nightly' } });
+            for (const status of [
+                'success',
+                'passed',
+                'ended',
+                'failed',
+                'error',
+                'timeout',
+                'running',
+                'unmarked',
+            ]) {
+                yield session({ build_id: build.id, status });
+            }
+            const res = yield (0, loopbackRequest_1.default)(app()).get('/build');
+            (0, chai_1.expect)(res.body[0]).to.include({
+                sessionCount: 8,
+                passedCount: 3,
+                failedCount: 3,
+                runningCount: 1,
+            });
+        }));
+    });
+});