@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/test/unit/selector-visibility-resolver.spec.js

@@ -0,0 +1,209 @@
+"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 });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const typedi_1 = require("typedi");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+const selector_health_fixture_1 = require("../helpers/selector-health-fixture");
+const SelectorVisibilityResolver_1 = require("../../src/services/selector-health/SelectorVisibilityResolver");
+const KEY = { strategy: 'xpath', selector: '//x' };
+const MEMBER_A = { userId: 'u-a', teamIds: ['team-a'] };
+describe('SelectorVisibilityResolver: who may see a selector, for its live events', () => {
+    it('TypeDI builds it, as the socket server gets it (Container.get)', () => {
+        // A function-typed constructor parameter would make Container.get throw.
+        const restore = (0, container_registration_1.saveRegistrations)(SelectorVisibilityResolver_1.SelectorVisibilityResolver);
+        try {
+            (0, chai_1.expect)(typedi_1.Container.get(SelectorVisibilityResolver_1.SelectorVisibilityResolver)).to.be.instanceOf(SelectorVisibilityResolver_1.SelectorVisibilityResolver);
+        }
+        finally {
+            restore();
+        }
+    });
+    describe('caching', () => {
+        let clock;
+        let scopes;
+        let checks;
+        let visible;
+        function resolver(over = {}) {
+            return new SelectorVisibilityResolver_1.SelectorVisibilityResolver(Object.assign({ sessionScope: (viewer) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    scopes.push((_a = viewer.userId) !== null && _a !== void 0 ? _a : '');
+                    return { OR: [{ device_udid: { in: viewer.teamIds } }] };
+                }), healedIn: (key) => __awaiter(this, void 0, void 0, function* () {
+                    checks.push(key.selector);
+                    return visible;
+                }), now: () => clock }, over));
+        }
+        beforeEach(() => {
+            clock = 1000000;
+            scopes = [];
+            checks = [];
+            visible = true;
+        });
+        it('asks once per viewer and selector while the answer is fresh, then again', () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = resolver();
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A)).to.equal(true);
+            visible = false;
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A), 'still the cached answer').to.equal(true);
+            (0, chai_1.expect)(checks).to.have.length(1);
+            clock += SelectorVisibilityResolver_1.SELECTOR_VISIBILITY_TTL_MS;
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A), 'asked again after the TTL').to.equal(false);
+            (0, chai_1.expect)(checks).to.have.length(2);
+        }));
+        it('concurrent questions share one lookup', () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = resolver();
+            const answers = yield Promise.all([
+                r.canSee(KEY, MEMBER_A),
+                r.canSee(KEY, { userId: 'u-a', teamIds: ['team-a'] }),
+                r.canSee(KEY, MEMBER_A),
+            ]);
+            (0, chai_1.expect)(answers).to.deep.equal([true, true, true]);
+            (0, chai_1.expect)(checks).to.have.length(1);
+            (0, chai_1.expect)(scopes).to.have.length(1);
+        }));
+        it("a viewer's sessions are read once for all their selectors", () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = resolver();
+            yield r.canSee(KEY, MEMBER_A);
+            yield r.canSee({ strategy: 'id', selector: 'other' }, MEMBER_A);
+            (0, chai_1.expect)(scopes).to.deep.equal(['u-a']);
+            (0, chai_1.expect)(checks).to.deep.equal(['//x', 'other']);
+        }));
+        it('the same teams in another order are the same viewer; another user or team is not', () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = resolver();
+            yield r.canSee(KEY, { userId: 'u-a', teamIds: ['team-a', 'team-b'] });
+            yield r.canSee(KEY, { userId: 'u-a', teamIds: ['team-b', 'team-a'] });
+            (0, chai_1.expect)(checks, 'team order').to.have.length(1);
+            yield r.canSee(KEY, { userId: 'u-b', teamIds: ['team-a', 'team-b'] });
+            yield r.canSee(KEY, { userId: 'u-a', teamIds: ['team-a'] });
+            (0, chai_1.expect)(checks, 'another user, other teams').to.have.length(3);
+        }));
+        it('a selector with no strategy is its own selector, not one with the same text', () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = resolver();
+            yield r.canSee({ strategy: '', selector: '//x' }, MEMBER_A);
+            yield r.canSee({ strategy: 'xpath', selector: '//x' }, MEMBER_A);
+            (0, chai_1.expect)(checks).to.have.length(2);
+        }));
+        it('a lookup that fails answers no, and is asked again next time', () => __awaiter(void 0, void 0, void 0, function* () {
+            let fail = true;
+            const r = resolver({
+                healedIn: (key) => __awaiter(void 0, void 0, void 0, function* () {
+                    checks.push(key.selector);
+                    if (fail)
+                        throw new Error('database gone');
+                    return true;
+                }),
+            });
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A)).to.equal(false);
+            fail = false;
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A)).to.equal(true);
+            (0, chai_1.expect)(checks).to.have.length(2);
+        }));
+        it("a viewer's sessions that can't be read answer no, and are read again next time", () => __awaiter(void 0, void 0, void 0, function* () {
+            let fail = true;
+            const r = resolver({
+                sessionScope: (viewer) => __awaiter(void 0, void 0, void 0, function* () {
+                    var _a;
+                    scopes.push((_a = viewer.userId) !== null && _a !== void 0 ? _a : '');
+                    if (fail)
+                        throw new Error('database gone');
+                    return undefined;
+                }),
+            });
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A)).to.equal(false);
+            fail = false;
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A)).to.equal(true);
+            (0, chai_1.expect)(scopes).to.have.length(2);
+        }));
+        it('a lookup that hangs answers no after the timeout, and is asked again next time', () => __awaiter(void 0, void 0, void 0, function* () {
+            let hang = true;
+            const r = resolver({
+                healedIn: (key) => {
+                    checks.push(key.selector);
+                    return hang ? new Promise(() => undefined) : Promise.resolve(true);
+                },
+                lookupTimeoutMs: 20,
+            });
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A)).to.equal(false);
+            hang = false;
+            (0, chai_1.expect)(yield r.canSee(KEY, MEMBER_A)).to.equal(true);
+            (0, chai_1.expect)(checks).to.have.length(2);
+        }));
+    });
+    describe("REST's rule, on a real database (Selector Health's own fixture)", () => {
+        const scratch = (0, scratch_database_1.useScratchDatabase)({ wholeSuite: true });
+        const UNPLUGGED = 'sh-phone-unplugged';
+        before(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, selector_health_fixture_1.seedSelectorHealth)(scratch.db);
+            // Priya's session on a phone that has since gone: no Device row.
+            yield scratch.db.session.create({
+                data: {
+                    id: 'sh-s-unplugged',
+                    device_udid: UNPLUGGED,
+                    device_name: 'Gone',
+                    device_platform: 'android',
+                    desired_capabilities: '{}',
+                    session_capabilities: '{}',
+                    node_id: 'localhost',
+                    has_live_video: false,
+                    device_version: '14',
+                    status: 'passed',
+                    user_id: selector_health_fixture_1.USER.priya,
+                },
+            });
+            yield scratch.db.sessionLog.create({
+                data: {
+                    session_id: 'sh-s-unplugged',
+                    url: '/element',
+                    method: 'POST',
+                    title: 'findElement',
+                    response: '{}',
+                    command_name: 'findElement',
+                    is_healed: true,
+                    original_strategy: 'xpath',
+                    original_selector: '//unplugged/only',
+                },
+            });
+        }));
+        const xpath = (selector) => ({ strategy: 'xpath', selector });
+        const teamA = { userId: selector_health_fixture_1.USER.priya, teamIds: [selector_health_fixture_1.TEAM.a] };
+        const teamB = { userId: selector_health_fixture_1.USER.alex, teamIds: [selector_health_fixture_1.TEAM.b] };
+        const noTeam = { userId: 'sh-u-nobody', teamIds: [] };
+        it("a team's member sees the selectors healed on their team's phone or a shared one, not another team's", () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = new SelectorVisibilityResolver_1.SelectorVisibilityResolver();
+            (0, chai_1.expect)(yield r.canSee({ strategy: 'id', selector: selector_health_fixture_1.SEL.warm }, teamA), 'team A phone').to.equal(true);
+            (0, chai_1.expect)(yield r.canSee(xpath(selector_health_fixture_1.SEL.hot), teamA), 'shared phone').to.equal(true);
+            (0, chai_1.expect)(yield r.canSee(xpath(selector_health_fixture_1.SEL.bOnly), teamA), "team B's phone").to.equal(false);
+            (0, chai_1.expect)(yield r.canSee(xpath(selector_health_fixture_1.SEL.bOnly), teamB)).to.equal(true);
+            (0, chai_1.expect)(yield r.canSee({ strategy: 'id', selector: selector_health_fixture_1.SEL.warm }, teamB)).to.equal(false);
+        }));
+        it('a member of no team sees only what healed on a shared phone', () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = new SelectorVisibilityResolver_1.SelectorVisibilityResolver();
+            (0, chai_1.expect)(yield r.canSee(xpath(selector_health_fixture_1.SEL.hot), noTeam)).to.equal(true);
+            (0, chai_1.expect)(yield r.canSee(xpath(selector_health_fixture_1.SEL.muted), noTeam)).to.equal(false);
+            (0, chai_1.expect)(yield r.canSee(xpath(selector_health_fixture_1.SEL.mutedB), noTeam)).to.equal(false);
+        }));
+        it('a heal recorded with no strategy is strategy ""', () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = new SelectorVisibilityResolver_1.SelectorVisibilityResolver();
+            (0, chai_1.expect)(yield r.canSee({ strategy: '', selector: selector_health_fixture_1.SEL.legacy }, noTeam)).to.equal(true);
+        }));
+        it("a phone that has gone leaves its sessions' selectors to their owner", () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = new SelectorVisibilityResolver_1.SelectorVisibilityResolver();
+            (0, chai_1.expect)(yield r.canSee(xpath('//unplugged/only'), teamA), 'Priya owns it').to.equal(true);
+            (0, chai_1.expect)(yield r.canSee(xpath('//unplugged/only'), teamB)).to.equal(false);
+        }));
+        it('an unknown selector is seen by no one', () => __awaiter(void 0, void 0, void 0, function* () {
+            const r = new SelectorVisibilityResolver_1.SelectorVisibilityResolver();
+            (0, chai_1.expect)(yield r.canSee(xpath('//never/healed'), teamA)).to.equal(false);
+        }));
+    });
+});

package/lib/test/unit/session-device-logs-hub-node.spec.js

@@ -0,0 +1,340 @@
+"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 });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const SessionDeviceLogs_1 = require("../../src/services/logcat/SessionDeviceLogs");
+const NodeDeviceLogStore_1 = require("../../src/services/logcat/NodeDeviceLogStore");
+const NodeDeviceLogsCollector_1 = require("../../src/services/logcat/NodeDeviceLogsCollector");
+const nodeDeviceLogs_1 = require("../../src/services/logcat/nodeDeviceLogs");
+const deviceLogBook_1 = require("../../src/services/logcat/deviceLogBook");
+const scratch_database_1 = require("../helpers/scratch-database");
+const fake_logcat_1 = require("../helpers/fake-logcat");
+const driver_log_1 = require("../helpers/driver-log");
+const quiet = { info: () => undefined, warn: () => undefined, debug: () => undefined };
+/** A node's service: its own phone's log stream fake, its rows held in `store`. */
+class NodeSideDeviceLogs extends SessionDeviceLogs_1.SessionDeviceLogs {
+    constructor(logcat, store, unclaimed = 60000) {
+        super();
+        this.logcat = logcat;
+        this.store = store;
+        this.unclaimed = unclaimed;
+        this.writes = 0;
+    }
+    context() {
+        return {
+            pluginArgs: { bindHostOrIp: '127.0.0.1', hub: 'http://127.0.0.1:4724' },
+            port: 4725,
+            nodeId: 'node-1',
+        };
+    }
+    streams() {
+        return this.logcat;
+    }
+    readClock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return deviceLogBook_1.UNKNOWN_CLOCK;
+        });
+    }
+    nodeStore() {
+        return this.store;
+    }
+    unclaimedMs() {
+        return this.unclaimed;
+    }
+    writeLines() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.writes += 1;
+        });
+    }
+}
+/** A hub's service: no phone of its own here; it asks a node every 20 ms. */
+class HubSideDeviceLogs extends SessionDeviceLogs_1.SessionDeviceLogs {
+    context() {
+        return { pluginArgs: { bindHostOrIp: '127.0.0.1' }, port: 4724, nodeId: 'hub-1' };
+    }
+    collectorFor(source, onLines, storedTail) {
+        return new NodeDeviceLogsCollector_1.NodeDeviceLogsCollector({
+            source,
+            onLines,
+            storedTail,
+            support: new nodeDeviceLogs_1.NodeDeviceLogsSupport(),
+            logger: quiet,
+            intervalMs: 20,
+        });
+    }
+}
+/** The phone as the node files it, and as the hub has it from the node's report. */
+const NODE_PHONE = {
+    udid: 'phone-1',
+    platform: 'android',
+    host: 'http://127.0.0.1:4725',
+    nodeId: 'node-1',
+};
+/** The node as the hub's collector sees it: the node's own store, behind its route. */
+const nodeAt = (store, sessionId) => ({
+    nodeOrigin: () => 'http://127.0.0.1:4725',
+    nodeDeviceLogs: (after) => __awaiter(void 0, void 0, void 0, function* () { return ({ kind: 'answer', answer: store.read(sessionId, after) }); }),
+});
+const row = (n) => ({
+    message: `line ${n}`,
+    timestamp: new Date(1700000000000 + n),
+});
+describe('A node records its phone’s device log for its hub', function () {
+    this.timeout(60000);
+    let logcat;
+    let store;
+    beforeEach(() => {
+        logcat = new fake_logcat_1.FakeLogcatStreams();
+        store = new NodeDeviceLogStore_1.NodeDeviceLogStore();
+    });
+    afterEach(() => logcat.cleanup());
+    it('holds the lines for the hub, whatever its dashboard setting, and writes none', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store);
+        const since = Date.now() - 60000;
+        yield logs.start({ sessionId: 'n1', device: NODE_PHONE, since });
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since - 600000, 'before the session'));
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 1000, 'first'));
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 2000, 'FATAL EXCEPTION: main', 'E', 'AndroidRuntime'));
+        yield (0, fake_logcat_1.settle)();
+        const held = store.read('n1', null);
+        (0, chai_1.expect)(held.state).to.equal('recording');
+        (0, chai_1.expect)(held.lines.map((l) => l.seq)).to.deep.equal([1, 2]);
+        (0, chai_1.expect)(held.lines[1].message).to.match(/ E AndroidRuntime: FATAL EXCEPTION: main$/);
+        (0, chai_1.expect)(held.lines[1].timestamp).to.equal(since + 2000);
+        yield logs.stop('n1');
+        (0, chai_1.expect)(store.read('n1', 2).state).to.equal('ended');
+        (0, chai_1.expect)(logs.writes).to.equal(0);
+    }));
+    it('holds an iPhone’s lines from its driver’s log, for the hub', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store);
+        const driverLog = new driver_log_1.TestDriverLog();
+        const iphone = Object.assign(Object.assign({}, NODE_PHONE), { udid: '00008110-000A', platform: 'ios', realDevice: true });
+        yield logs.start({
+            sessionId: 'n-ios',
+            device: iphone,
+            since: Date.now() - 1000,
+            driverLog,
+        });
+        driverLog.line('Oct  5 20:31:07 iPhone Shop[4127] <Error>: payment failed');
+        const held = store.read('n-ios', null);
+        (0, chai_1.expect)(held.state).to.equal('recording');
+        (0, chai_1.expect)(held.lines.map((l) => l.message)).to.deep.equal([
+            'Oct  5 20:31:07 iPhone Shop[4127] <Error>: payment failed',
+        ]);
+        (0, chai_1.expect)(logs.writes).to.equal(0);
+        yield logs.stop('n-ios');
+        (0, chai_1.expect)(store.read('n-ios', 1).state).to.equal('ended');
+    }));
+    it('keeps the session’s line limit, so a hub is sent no more than its own phone’s session keeps', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store);
+        const since = Date.now() - 60000;
+        yield logs.start({ sessionId: 'n2', device: NODE_PHONE, since });
+        for (let i = 0; i < deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 5; i++) {
+            logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 1000 + i, `line ${i}`));
+        }
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 30000, 'the end', 'E', 'AndroidRuntime'));
+        const held = () => store.entries.get('n2').lines.length;
+        yield (0, fake_logcat_1.until)(() => held() === deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 2, 20000);
+        yield logs.stop('n2');
+        let after = null;
+        const all = [];
+        for (;;) {
+            const page = store.read('n2', after);
+            all.push(...page.lines.map((l) => l.message));
+            if (!page.more)
+                break;
+            after = page.lines[page.lines.length - 1].seq;
+        }
+        // The limit, a note that only errors are kept from there, the error, and
+        // a note that the 5 other lines were left out.
+        (0, chai_1.expect)(all).to.have.length(deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 3);
+        (0, chai_1.expect)(all[deviceLogBook_1.DEVICE_LOG_LINE_LIMIT]).to.contain('only errors are kept');
+        (0, chai_1.expect)(all[deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 1]).to.match(/ E AndroidRuntime: the end$/);
+        (0, chai_1.expect)(all[deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 2]).to.contain('5 device log lines were left out');
+    }));
+    it('stops recording a session no hub has asked about', () => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const logs = new NodeSideDeviceLogs(logcat, store, 30);
+        yield logs.start({ sessionId: 'n3', device: NODE_PHONE, since: Date.now() });
+        (0, chai_1.expect)((_a = logcat.getMultiplexer(NODE_PHONE.udid)) === null || _a === void 0 ? void 0 : _a.clientCount).to.equal(1);
+        yield (0, fake_logcat_1.until)(() => !logs.isRecording('n3'));
+        (0, chai_1.expect)((_c = (_b = logcat.getMultiplexer(NODE_PHONE.udid)) === null || _b === void 0 ? void 0 : _b.clientCount) !== null && _c !== void 0 ? _c : 0).to.equal(0);
+        (0, chai_1.expect)(store.read('n3', null)).to.deep.equal({ state: 'off', lines: [], more: false });
+        // Ending it later does nothing more.
+        yield logs.stop('n3');
+        (0, chai_1.expect)(store.read('n3', null).state).to.equal('off');
+    }));
+    it('records to the end once a hub has asked', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store, 30);
+        const since = Date.now() - 1000;
+        yield logs.start({ sessionId: 'n4', device: NODE_PHONE, since });
+        store.read('n4', null);
+        yield new Promise((r) => setTimeout(r, 80));
+        (0, chai_1.expect)(logs.isRecording('n4')).to.equal(true);
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(Date.now(), 'still here'));
+        yield (0, fake_logcat_1.settle)();
+        (0, chai_1.expect)(store.read('n4', null).lines.map((l) => l.message)).to.have.length(1);
+        yield logs.stop('n4');
+    }));
+    it('keeps a session that ended before any hub asked, for the hub’s last ask', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store, 30);
+        const since = Date.now() - 1000;
+        yield logs.start({ sessionId: 'n5', device: NODE_PHONE, since });
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(Date.now(), 'a short session'));
+        yield (0, fake_logcat_1.settle)();
+        yield logs.stop('n5');
+        yield new Promise((r) => setTimeout(r, 80));
+        const held = store.read('n5', null);
+        (0, chai_1.expect)(held.state).to.equal('ended');
+        (0, chai_1.expect)(held.lines).to.have.length(1);
+    }));
+});
+describe('A hub writes a node session’s device log', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let node;
+    let count = 0;
+    let sessionId;
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        count += 1;
+        sessionId = `hub-dl-${count}`;
+        node = new NodeDeviceLogStore_1.NodeDeviceLogStore();
+        node.begin(sessionId);
+        yield scratch.db.session.create({
+            data: {
+                id: sessionId,
+                device_udid: NODE_PHONE.udid,
+                device_platform: 'android',
+                device_version: '10',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-1',
+                has_live_video: false,
+            },
+        });
+    }));
+    const stored = () => scratch.db.log.findMany({
+        where: { session_id: sessionId, log_type: 'DEVICE' },
+        orderBy: { createdAt: 'asc' },
+    });
+    it('collects only a node’s phone, through its session, and never a cloud provider’s', () => {
+        const hub = new HubSideDeviceLogs();
+        const source = nodeAt(node, sessionId);
+        (0, chai_1.expect)(hub.appliesTo(NODE_PHONE, source)).to.equal(true);
+        (0, chai_1.expect)(hub.appliesTo(NODE_PHONE)).to.equal(false);
+        (0, chai_1.expect)(hub.appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { cloud: 'browserstack' }), source)).to.equal(false);
+        (0, chai_1.expect)(hub.appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { platform: 'ios' }), source)).to.equal(true);
+        (0, chai_1.expect)(hub.appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { platform: 'windows' }), source)).to.equal(false);
+        // A node never collects from another server.
+        (0, chai_1.expect)(new NodeSideDeviceLogs(new fake_logcat_1.FakeLogcatStreams(), node).appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { nodeId: 'node-2', host: 'http://10.0.0.9:4725' }), source)).to.equal(false);
+    });
+    it('writes the lines as the node gives them, in its order, and the last ones at the end', () => __awaiter(this, void 0, void 0, function* () {
+        const hub = new HubSideDeviceLogs();
+        node.add(sessionId, [row(1), row(2)]);
+        yield hub.start({ sessionId, device: NODE_PHONE, source: nodeAt(node, sessionId) });
+        yield (0, fake_logcat_1.until)(() => node.claimed(sessionId));
+        yield new Promise((r) => setTimeout(r, 50));
+        (0, chai_1.expect)((yield stored()).map((r) => r.message)).to.deep.equal(['line 1', 'line 2']);
+        // The node's last lines, then its session ends before the hub's.
+        node.add(sessionId, [row(3), row(4)]);
+        node.end(sessionId);
+        yield hub.stop(sessionId);
+        const rows = yield stored();
+        (0, chai_1.expect)(rows.map((r) => r.message)).to.deep.equal(['line 1', 'line 2', 'line 3', 'line 4']);
+        // Each line keeps the node's time; each row its own `createdAt`, in order.
+        (0, chai_1.expect)(rows.map((r) => r.timestamp.getTime())).to.deep.equal([1, 2, 3, 4].map((n) => row(n).timestamp.getTime()));
+        const created = rows.map((r) => r.createdAt.getTime());
+        (0, chai_1.expect)(created.every((t, i) => i === 0 || t > created[i - 1]), String(created)).to.equal(true);
+    }));
+    it('goes on after a restart after the newest line stored, without writing it twice', () => __awaiter(this, void 0, void 0, function* () {
+        // Before the restart the hub wrote lines 1 to 3, the last two from an
+        // answer whose lines the node still holds: it drops them only when the
+        // next ask names them.
+        const later = Date.now() + 60000;
+        yield scratch.db.log.createMany({
+            data: [1, 2, 3].map((n) => ({
+                session_id: sessionId,
+                log_type: 'DEVICE',
+                message: row(n).message,
+                timestamp: row(n).timestamp,
+                createdAt: new Date(later + n),
+            })),
+        });
+        node.add(sessionId, [1, 2, 3, 4, 5].map(row));
+        node.read(sessionId, 1);
+        const hub = new HubSideDeviceLogs();
+        yield hub.start({
+            sessionId,
+            device: NODE_PHONE,
+            source: nodeAt(node, sessionId),
+            resume: true,
+        });
+        node.end(sessionId);
+        yield hub.stop(sessionId);
+        const rows = yield stored();
+        (0, chai_1.expect)(rows.map((r) => r.message)).to.deep.equal([1, 2, 3, 4, 5].map((n) => `line ${n}`));
+        (0, chai_1.expect)(rows[3].createdAt.getTime()).to.be.greaterThan(later + 3);
+    }));
+    it('a second stop waits for the first one’s last lines', () => __awaiter(this, void 0, void 0, function* () {
+        // A node slow to answer: the first stop is still in its last ask.
+        const slow = nodeAt(node, sessionId);
+        const source = {
+            nodeOrigin: slow.nodeOrigin,
+            nodeDeviceLogs: (after) => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((r) => setTimeout(r, 50));
+                return slow.nodeDeviceLogs(after);
+            }),
+        };
+        const hub = new HubSideDeviceLogs();
+        node.add(sessionId, [row(1)]);
+        yield hub.start({ sessionId, device: NODE_PHONE, source });
+        yield (0, fake_logcat_1.until)(() => node.claimed(sessionId));
+        node.add(sessionId, [row(2)]);
+        node.end(sessionId);
+        const first = hub.stop(sessionId);
+        // The failure analysis, after a second ending's stop, reads them all.
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)((yield stored()).map((r) => r.message)).to.deep.equal(['line 1', 'line 2']);
+        yield first;
+    }));
+    it('takes the node’s last lines though the session ends while collection resumes', () => __awaiter(this, void 0, void 0, function* () {
+        class SlowToResume extends HubSideDeviceLogs {
+            storedTail(id) {
+                const _super = Object.create(null, {
+                    storedTail: { get: () => super.storedTail }
+                });
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((r) => setTimeout(r, 50));
+                    return _super.storedTail.call(this, id);
+                });
+            }
+        }
+        const hub = new SlowToResume();
+        node.add(sessionId, [row(1), row(2)]);
+        node.end(sessionId);
+        void hub.start({
+            sessionId,
+            device: NODE_PHONE,
+            source: nodeAt(node, sessionId),
+            resume: true,
+        });
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)((yield stored()).map((r) => r.message)).to.deep.equal(['line 1', 'line 2']);
+    }));
+    it('collects nothing from a node that doesn’t record the session', () => __awaiter(this, void 0, void 0, function* () {
+        const hub = new HubSideDeviceLogs();
+        node.forget(sessionId);
+        yield hub.start({ sessionId, device: NODE_PHONE, source: nodeAt(node, sessionId) });
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)(yield stored()).to.deep.equal([]);
+    }));
+});