@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/test/unit/session-create-credential-owner.spec.js

@@ -0,0 +1,242 @@
+"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 fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const typedi_1 = require("typedi");
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const ApiKeyService_1 = require("../../src/services/ApiKeyService");
+const JwtKeyService_1 = require("../../src/services/token/JwtKeyService");
+const UserService_1 = require("../../src/services/UserService");
+const config_1 = require("../../src/config");
+const prisma_1 = require("../../src/prisma");
+const container_registration_1 = require("../helpers/container-registration");
+const sessionCredentials_1 = require("../../src/services/session/sessionCredentials");
+/**
+ * Session create judges the credentials it is given by REST's rule: a key
+ * pair or session token says who the caller is only while that user exists
+ * and is ACTIVE. Through 2.14 the pair was checked against the key alone
+ * (ApiKeyService.verifyPair) and the session token against its signature
+ * alone, so a user set to Inactive, or deleted, kept creating sessions as
+ * themselves, past XENON_REQUIRE_SESSION_TOKEN too.
+ *
+ * Such credentials now count as wrong ones: with the gate on the session is
+ * refused, with it off it runs with no owner, like any session presenting
+ * credentials that don't check out.
+ *
+ * A session token also has to carry the `sessions` scope, as a key pair
+ * must: POST /auth/token gave one to any credential, a read-only one
+ * included.
+ */
+// authorizeSessionRequest is private: the single place a create's identity is
+// decided. It is handed the credentials createSession took out of the caps.
+const invoke = (svc, caps) => svc.authorizeSessionRequest(caps, (0, sessionCredentials_1.takeSessionCredentials)(caps));
+const capsWith = (options) => ({
+    alwaysMatch: { 'xe:options': options },
+    firstMatch: [{}],
+});
+function refusalOf(promise) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            yield promise;
+            return null;
+        }
+        catch (err) {
+            return String((_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err);
+        }
+    });
+}
+describe('session create: the credentials of an inactive or deleted user', () => {
+    let svc;
+    let dir;
+    let keys;
+    let restore;
+    let authDisabledBefore;
+    let gateBefore;
+    let users;
+    let findById;
+    const keyRow = { id: 'key_alice', userId: 'usr_alice', scopes: 'sessions', teamId: null };
+    const alice = () => users.usr_alice;
+    const pair = () => capsWith({ accessKey: 'xen_alice', token: 'tk' });
+    const token = (claims = { sub: 'usr_alice', scopes: 'sessions' }) => keys.sign(claims, { audience: 'xenon-session', ttlSeconds: 600 });
+    const gate = (on) => {
+        if (on)
+            process.env.XENON_REQUIRE_SESSION_TOKEN = 'true';
+        else
+            delete process.env.XENON_REQUIRE_SESSION_TOKEN;
+    };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        authDisabledBefore = config_1.config.authDisabled;
+        config_1.config.authDisabled = false;
+        gateBefore = process.env.XENON_REQUIRE_SESSION_TOKEN;
+        restore = (0, container_registration_1.saveRegistrations)(ApiKeyService_1.ApiKeyService, JwtKeyService_1.JwtKeyService, UserService_1.UserService);
+        dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-create-owner-'));
+        keys = new JwtKeyService_1.JwtKeyService();
+        yield keys.init(dir);
+        typedi_1.Container.set(JwtKeyService_1.JwtKeyService, keys);
+        typedi_1.Container.set(ApiKeyService_1.ApiKeyService, {
+            verifyPair: sinon_1.default.stub().resolves(keyRow),
+            hasScope: (row, req) => {
+                const owned = row.scopes.split(',');
+                return owned.includes('admin') || req.some((s) => owned.includes(s));
+            },
+        });
+        users = { usr_alice: { id: 'usr_alice', role: 'MEMBER', status: 'ACTIVE' } };
+        findById = sinon_1.default.stub().callsFake((id) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = users[id]) !== null && _a !== void 0 ? _a : null; }));
+        typedi_1.Container.set(UserService_1.UserService, { findById });
+        sinon_1.default.stub(prisma_1.prisma.teamMember, 'findMany').resolves([]);
+        svc = new SessionLifecycleService_1.SessionLifecycleService();
+    }));
+    afterEach(() => {
+        config_1.config.authDisabled = authDisabledBefore;
+        if (gateBefore === undefined)
+            delete process.env.XENON_REQUIRE_SESSION_TOKEN;
+        else
+            process.env.XENON_REQUIRE_SESSION_TOKEN = gateBefore;
+        sinon_1.default.restore();
+        restore();
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    describe('with XENON_REQUIRE_SESSION_TOKEN on', () => {
+        beforeEach(() => gate(true));
+        it("refuses an Inactive user's access key and token", () => __awaiter(void 0, void 0, void 0, function* () {
+            alice().status = 'INACTIVE';
+            (0, chai_1.expect)(yield refusalOf(invoke(svc, pair()))).to.match(/session rejected/);
+        }));
+        it("refuses a deleted user's key, whose row outlived them", () => __awaiter(void 0, void 0, void 0, function* () {
+            users.usr_alice = undefined;
+            (0, chai_1.expect)(yield refusalOf(invoke(svc, pair()))).to.match(/session rejected/);
+        }));
+        it("refuses an Inactive user's session token", () => __awaiter(void 0, void 0, void 0, function* () {
+            alice().status = 'INACTIVE';
+            const caps = capsWith({ sessionToken: yield token() });
+            (0, chai_1.expect)(yield refusalOf(invoke(svc, caps))).to.match(/session rejected/);
+        }));
+        it("refuses a deleted user's session token, which is still within its lifetime", () => __awaiter(void 0, void 0, void 0, function* () {
+            users.usr_alice = undefined;
+            const caps = capsWith({ sessionToken: yield token() });
+            (0, chai_1.expect)(yield refusalOf(invoke(svc, caps))).to.match(/session rejected/);
+        }));
+        it("still admits an Active user's key and token, and their session token", () => __awaiter(void 0, void 0, void 0, function* () {
+            const byPair = yield invoke(svc, pair());
+            (0, chai_1.expect)(byPair).to.include({ apiKeyId: 'key_alice', userId: 'usr_alice' });
+            const byToken = yield invoke(svc, capsWith({ sessionToken: yield token() }));
+            (0, chai_1.expect)(byToken).to.include({ apiKeyId: null, userId: 'usr_alice' });
+        }));
+        it('looks the owner up once, though the gate and attribution both verify the token', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield invoke(svc, capsWith({ sessionToken: yield token() }));
+            (0, chai_1.expect)(findById.callCount).to.equal(1);
+        }));
+    });
+    describe('with XENON_REQUIRE_SESSION_TOKEN off', () => {
+        beforeEach(() => gate(false));
+        it("gives no owner to a session made with an Inactive user's key", () => __awaiter(void 0, void 0, void 0, function* () {
+            alice().status = 'INACTIVE';
+            const res = yield invoke(svc, pair());
+            (0, chai_1.expect)(res).to.include({ apiKeyId: null, userId: null });
+        }));
+        it("gives no owner to a session made with a deleted user's session token", () => __awaiter(void 0, void 0, void 0, function* () {
+            users.usr_alice = undefined;
+            const res = yield invoke(svc, capsWith({ sessionToken: yield token() }));
+            (0, chai_1.expect)(res).to.include({ apiKeyId: null, userId: null });
+        }));
+        it('looks an Active owner up once for a key and token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield invoke(svc, pair());
+            yield res.leaseAccess();
+            (0, chai_1.expect)(res.userId).to.equal('usr_alice');
+            (0, chai_1.expect)(findById.callCount).to.equal(1);
+        }));
+    });
+    describe('a session token needs the `sessions` scope', () => {
+        for (const on of [false, true]) {
+            describe(`(gate ${on ? 'on' : 'off'})`, () => {
+                beforeEach(() => gate(on));
+                it('refuses one minted for a read-only credential', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const caps = capsWith({
+                        sessionToken: yield token({ sub: 'usr_alice', scopes: 'devices' }),
+                    });
+                    (0, chai_1.expect)(yield refusalOf(invoke(svc, caps))).to.match(/sessions` scope/);
+                }));
+                it('refuses one minted before session tokens carried their scopes, saying so', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const caps = capsWith({ sessionToken: yield token({ sub: 'usr_alice' }) });
+                    const refusal = yield refusalOf(invoke(svc, caps));
+                    (0, chai_1.expect)(refusal).to.match(/carries no `sessions` scope/);
+                    (0, chai_1.expect)(refusal).to.match(/minted by Xenon 2\.14 or earlier carry none/);
+                    (0, chai_1.expect)(refusal).to.match(/mint a new one/);
+                }));
+                it('admits one with `sessions` or `admin`', () => __awaiter(void 0, void 0, void 0, function* () {
+                    for (const scopes of ['sessions', 'admin', 'devices,sessions']) {
+                        const caps = capsWith({ sessionToken: yield token({ sub: 'usr_alice', scopes }) });
+                        (0, chai_1.expect)((yield invoke(svc, caps)).userId).to.equal('usr_alice');
+                    }
+                }));
+            });
+        }
+    });
+    // Taking over a lease someone else created is an ownership override: a
+    // SUPER_ADMIN, or a credential with the `admin` scope. A session token was
+    // judged by its user's role alone, so an ADMIN's key without the admin
+    // scope, which may not override, minted a session token that could.
+    describe('a session token overrides a lease only as the credential that minted it could', () => {
+        beforeEach(() => gate(false));
+        const overrideWith = (role, scopes) => __awaiter(void 0, void 0, void 0, function* () {
+            alice().role = role;
+            const caps = capsWith({ sessionToken: yield token({ sub: 'usr_alice', scopes }) });
+            return (yield (yield invoke(svc, caps)).leaseAccess()).canOverride;
+        });
+        it("is refused for an ADMIN's token minted without the admin scope", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield overrideWith('ADMIN', 'sessions')).to.equal(false);
+        }));
+        it("is allowed for an ADMIN's or SUPER_ADMIN's token minted with the admin scope", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield overrideWith('ADMIN', 'admin,sessions')).to.equal(true);
+            (0, chai_1.expect)(yield overrideWith('SUPER_ADMIN', 'admin,sessions')).to.equal(true);
+        }));
+        // As the SUPER_ADMIN's key pair and Bearer token override.
+        it("is allowed for a SUPER_ADMIN's token minted without it", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield overrideWith('SUPER_ADMIN', 'sessions')).to.equal(true);
+        }));
+        // The scope is fixed when the token is minted; the role is read now. An
+        // admin demoted after minting overrides no more.
+        it('is refused once the admin who minted it is a member', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield overrideWith('MEMBER', 'admin,sessions')).to.equal(false);
+        }));
+        it("is refused for a member's token", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield overrideWith('MEMBER', 'sessions')).to.equal(false);
+        }));
+    });
+    // The owner lookup that fails is not a token that doesn't check out: the
+    // create is refused, as for a key whose owner can't be looked up. It ran
+    // with no owner (gate off) or was refused as "invalid or expired" (gate on).
+    describe('a session token whose owner cannot be looked up', () => {
+        for (const on of [false, true]) {
+            it(`refuses the create (gate ${on ? 'on' : 'off'})`, () => __awaiter(void 0, void 0, void 0, function* () {
+                gate(on);
+                findById.rejects(new Error('db down'));
+                const caps = capsWith({ sessionToken: yield token() });
+                (0, chai_1.expect)(yield refusalOf(invoke(svc, caps))).to.equal('db down');
+            }));
+        }
+        it('still counts a token that does not check out as none (gate off)', () => __awaiter(void 0, void 0, void 0, function* () {
+            gate(false);
+            const res = yield invoke(svc, capsWith({ sessionToken: 'not-a-jwt' }));
+            (0, chai_1.expect)(res).to.include({ apiKeyId: null, userId: null });
+            (0, chai_1.expect)(findById.called).to.equal(false);
+        }));
+    });
+});

package/lib/test/unit/session-credential-strip.spec.js

@@ -146,7 +146,7 @@ describe('createSession — credentials never reach the driver or storage', () =
             verify: (t) => __awaiter(void 0, void 0, void 0, function* () {
                 if (!t.startsWith('jwt:'))
                     throw new Error('bad token');
-                return { sub: t.slice('jwt:'.length), teamId: null };
+                return { sub: t.slice('jwt:'.length), teamId: null, scopes: 'sessions' };
             }),
         });
         // The owner's teams: none, and not read from the developer's database.

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

@@ -0,0 +1,180 @@
+"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 supertest_1 = __importDefault(require("supertest"));
+const SessionDeviceLogs_1 = require("../../src/services/logcat/SessionDeviceLogs");
+const deviceLogBook_1 = require("../../src/services/logcat/deviceLogBook");
+const scratch_database_1 = require("../helpers/scratch-database");
+const selector_health_fixture_1 = require("../helpers/selector-health-fixture");
+// The driver's own log class (test/helpers/driver-log.ts): an iPhone's and a
+// simulator's `logs.syslog` extend it, so what Xenon reads is what the driver keeps.
+const driver_log_1 = require("../helpers/driver-log");
+// How the Device logs tab reads an iPhone line's level (web log-derive.ts).
+const DASHBOARD_SYSLOG = /<(Error|Fault|Warning)>/;
+class TestDeviceLogs extends SessionDeviceLogs_1.SessionDeviceLogs {
+    context() {
+        return { pluginArgs: { bindHostOrIp: '127.0.0.1' }, port: 4723, nodeId: 'this-server' };
+    }
+    flushIntervalMs() {
+        return 60000;
+    }
+}
+const IPHONE = {
+    udid: '00008110-000A',
+    platform: 'ios',
+    realDevice: true,
+    host: 'http://127.0.0.1:4723',
+    nodeId: 'this-server',
+};
+const SIMULATOR = Object.assign(Object.assign({}, IPHONE), { udid: 'SIM-1', realDevice: false });
+const syslog = (n, level = 'Notice') => `Oct  5 20:31:${String(n % 60).padStart(2, '0')} iPhone Shop[4127] <${level}>: line ${n}`;
+function deviceLogs(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield (0, supertest_1.default)((0, selector_health_fixture_1.selectorHealthApp)(selector_health_fixture_1.ADMIN)).get(`/session/${sessionId}/logs/device`);
+        (0, chai_1.expect)(res.status, res.text).to.equal(200);
+        return res.body;
+    });
+}
+describe("An iPhone or simulator session's Device logs", function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let logs;
+    let sessionId;
+    let driverLog;
+    let count = 0;
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        count += 1;
+        sessionId = `dl-ios-${count}`;
+        yield scratch.db.session.create({
+            data: {
+                id: sessionId,
+                device_udid: IPHONE.udid,
+                device_platform: 'ios',
+                device_version: '26.0',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'this-server',
+                has_live_video: false,
+            },
+        });
+        logs = new TestDeviceLogs();
+        driverLog = new driver_log_1.TestDriverLog();
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        yield logs.stop(sessionId);
+    }));
+    it('keeps the lines from the create and from the run, each once, in order', () => __awaiter(this, void 0, void 0, function* () {
+        // Logged during the create, before Xenon could listen: in the driver's buffer.
+        for (let i = 0; i < 3; i++)
+            driverLog.line(syslog(i));
+        yield logs.start({ sessionId, device: IPHONE, since: Date.now() - 60000, driverLog });
+        for (let i = 3; i < 250; i++)
+            driverLog.line(syslog(i));
+        yield logs.stop(sessionId);
+        (0, chai_1.expect)(driverLog.listenerCount('output')).to.equal(0);
+        driverLog.line(syslog(999)); // after the session: not its line
+        const rows = yield deviceLogs(sessionId);
+        (0, chai_1.expect)(rows.map((r) => r.message)).to.deep.equal(Array.from({ length: 250 }, (_, i) => syslog(i)));
+    }));
+    it("leaves the driver's lines to the test that asks for them", () => __awaiter(this, void 0, void 0, function* () {
+        driverLog.line(syslog(1));
+        yield logs.start({ sessionId, device: IPHONE, since: Date.now() - 60000, driverLog });
+        driverLog.line(syslog(2));
+        yield logs.stop(sessionId);
+        const forTheTest = yield driverLog.getLogs();
+        (0, chai_1.expect)(forTheTest.map((e) => e.message)).to.deep.equal([
+            syslog(1),
+            syslog(2),
+        ]);
+    }));
+    it("keeps each line's text, so Errors only finds the phone's errors, at the time it arrived", () => __awaiter(this, void 0, void 0, function* () {
+        yield logs.start({ sessionId, device: IPHONE, since: Date.now() - 60000, driverLog });
+        const before = Date.now();
+        driverLog.line(syslog(1));
+        driverLog.line(syslog(2, 'Error'));
+        driverLog.line(syslog(3, 'Fault'));
+        const after = Date.now();
+        yield logs.stop(sessionId);
+        const rows = yield deviceLogs(sessionId);
+        (0, chai_1.expect)(rows.map((r) => { var _a, _b; return (_b = (_a = DASHBOARD_SYSLOG.exec(r.message)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : null; })).to.deep.equal([
+            null,
+            'Error',
+            'Fault',
+        ]);
+        for (const r of rows) {
+            const t = new Date(r.timestamp).getTime();
+            (0, chai_1.expect)(t).to.be.within(before, after);
+        }
+    }));
+    it("records a simulator's compact lines, without `log stream`'s banner", () => __awaiter(this, void 0, void 0, function* () {
+        driverLog.line('Filtering the log data using "subsystem != \\"com.apple.CoreTelephony\\""');
+        driverLog.line('Timestamp               Ty Process[PID:TID]');
+        yield logs.start({ sessionId, device: SIMULATOR, since: Date.now() - 60000, driverLog });
+        driverLog.line('2026-10-05 20:31:40.123 F  Shop[4127:8812] Terminating app');
+        driverLog.line('\tThread 0 Crashed:');
+        yield logs.stop(sessionId);
+        (0, chai_1.expect)((yield deviceLogs(sessionId)).map((r) => r.message)).to.deep.equal([
+            '2026-10-05 20:31:40.123 F  Shop[4127:8812] Terminating app',
+            '\tThread 0 Crashed:',
+        ]);
+    }));
+    it("keeps the app's own lines, the errors inside it, the app manager's lines and faults, and says so first", () => __awaiter(this, void 0, void 0, function* () {
+        const line = (proc, text, level = 'Notice') => `Oct  5 23:48:33 Rabindras-iPhone ${proc} <${level}>: ${text}`;
+        // From the create, before Xenon listens: the app's first line comes
+        // before the phone announces its pid.
+        driverLog.line(line('Shop[4127]', 'first line'));
+        driverLog.line(line('runningboardd(RunningBoard)[34]', 'Acquiring [app<com.example.shop(UUID)>:4127]'));
+        yield logs.start({
+            sessionId,
+            device: IPHONE,
+            since: Date.now() - 60000,
+            driverLog,
+            appUnderTest: 'com.example.shop',
+        });
+        driverLog.line(line('duetexpertd[412]', 'chatter'));
+        driverLog.line(line('Shop(Networking)[4127]', 'request failed', 'Error'));
+        driverLog.line(line('wifid[61]', 'link lost', 'Fault'));
+        yield logs.stop(sessionId);
+        (0, chai_1.expect)((yield deviceLogs(sessionId)).map((r) => r.message)).to.deep.equal([
+            "Xenon: Kept here: what the app under test (com.example.shop) logs itself, every error inside it, what the phone says about its launch, state, crashes and end, and faults. The rest of the phone's log is left out.",
+            line('Shop[4127]', 'first line'),
+            line('runningboardd(RunningBoard)[34]', 'Acquiring [app<com.example.shop(UUID)>:4127]'),
+            line('Shop(Networking)[4127]', 'request failed', 'Error'),
+            line('wifid[61]', 'link lost', 'Fault'),
+        ]);
+    }));
+    it('records nothing for a session that skips log capture', () => __awaiter(this, void 0, void 0, function* () {
+        yield logs.start({ sessionId, device: IPHONE, since: Date.now(), driverLog: undefined });
+        (0, chai_1.expect)(logs.isRecording(sessionId)).to.equal(false);
+        (0, chai_1.expect)(yield deviceLogs(sessionId)).to.deep.equal([]);
+    }));
+    it(`holds to the same limit as Android, ${deviceLogBook_1.DEVICE_LOG_LINE_LIMIT} lines then errors`, () => __awaiter(this, void 0, void 0, function* () {
+        yield logs.start({ sessionId, device: IPHONE, since: Date.now() - 60000, driverLog });
+        for (let i = 0; i < deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 100; i++) {
+            driverLog.line(syslog(i, i >= deviceLogBook_1.DEVICE_LOG_LINE_LIMIT && i % 2 === 0 ? 'Error' : 'Notice'));
+        }
+        yield logs.stop(sessionId);
+        const rows = yield deviceLogs(sessionId);
+        (0, chai_1.expect)(rows).to.have.length(deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 1 + 50 + 1);
+        (0, chai_1.expect)(rows[deviceLogBook_1.DEVICE_LOG_LINE_LIMIT].message).to.match(/^Xenon: This session reached 10,000/);
+        (0, chai_1.expect)(rows[rows.length - 1].message).to.match(/^Xenon: 50 device log lines were left out/);
+    }));
+    it("doesn't record a node's iPhone, whose driver is the node's", () => {
+        (0, chai_1.expect)(logs.appliesTo(IPHONE)).to.equal(true);
+        (0, chai_1.expect)(logs.appliesTo(SIMULATOR)).to.equal(true);
+        (0, chai_1.expect)(logs.appliesTo(Object.assign(Object.assign({}, IPHONE), { nodeId: 'a-node' }))).to.equal(false);
+    });
+});