@xenon-device-management/xenon 2.0.0 → 2.2.0

package/lib/test/unit/hub-remote-session-heartbeat.spec.js

@@ -0,0 +1,277 @@
+"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 fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const defaultGateway_1 = require("../../src/gateway/defaultGateway");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const nodeSessionStatus_1 = require("../../src/gateway/nodeSessionStatus");
+const JwtKeyService_1 = require("../../src/services/token/JwtKeyService");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const device_managers_1 = require("../../src/device-managers");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const RemoteSession_1 = require("../../src/sessions/RemoteSession");
+const appiumUmbrella_1 = require("../../src/sessions/appiumUmbrella");
+const XenonSession_1 = require("../../src/sessions/XenonSession");
+const config_1 = require("../../src/config");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+const appium_umbrella_1 = require("../helpers/appium-umbrella");
+/**
+ * The hub's heartbeat on a session a node runs (RemoteSession.checkHealth),
+ * against a node in Appium 3's own server(): Appium's umbrella with Xenon's
+ * plugin, the production node gateway, and the node's session-status route.
+ *
+ * The heartbeat runs every ~30 s. Sent as a WebDriver command, it restarted
+ * the node driver's new-command timeout and Xenon's idle clock, so a session
+ * its client abandoned was never ended, and its phone never freed. It asks the
+ * node's umbrella instead, which runs no command. An older node without that
+ * route is still probed the old way, and the hub says so once.
+ */
+const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+const NODE_ID = 'node-1';
+describe('the hub’s heartbeat on a node’s session', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const servers = [];
+    let dirs;
+    let hubKeys;
+    let appiumLogs;
+    let restore;
+    let saved;
+    let authDisabledBefore;
+    let commandAuthBefore;
+    let umbrella;
+    let hubUrl;
+    let nodeOrigin;
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        appiumLogs = (0, appium_umbrella_1.quietAppiumLogs)();
+        dirs = [fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-heartbeat-keys-'))];
+        hubKeys = new JwtKeyService_1.JwtKeyService();
+        yield hubKeys.init(dirs[0]);
+    }));
+    after(() => {
+        appiumLogs.restore();
+        for (const dir of dirs)
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer, device_managers_1.XenonManager, appiumUmbrella_1.AppiumUmbrella, nodeSessionStatus_1.NodeSessionProbeSupport);
+        // One process plays both sides: the hub's keys sign, the node checks them.
+        typedi_1.Container.set(JwtKeyService_1.JwtKeyService, hubKeys);
+        typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, new hubSessionToken_1.HubSessionTokenIssuer());
+        typedi_1.Container.set(appiumUmbrella_1.AppiumUmbrella, new appiumUmbrella_1.AppiumUmbrella());
+        typedi_1.Container.set(nodeSessionStatus_1.NodeSessionProbeSupport, new nodeSessionStatus_1.NodeSessionProbeSupport());
+        typedi_1.Container.set(device_managers_1.XenonManager, {
+            getMaxSessionCount: () => undefined,
+            deviceInstances: () => __awaiter(this, void 0, void 0, function* () { return []; }),
+        });
+        const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = {
+            store: device_store_1.DeviceStoreFactory._deviceStore,
+            pending: device_store_1.DeviceStoreFactory._pendingSessionStore,
+            context: Object.assign({}, context),
+        };
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        device_store_1.DeviceStoreFactory._pendingSessionStore = new prisma_store_1.PrismaPendingSessionStore();
+        authDisabledBefore = config_1.config.authDisabled;
+        config_1.config.authDisabled = false;
+        // Per-command auth on: the node then takes the hub's token and nothing else.
+        commandAuthBefore = process.env.XENON_REQUIRE_COMMAND_AUTH;
+        process.env.XENON_REQUIRE_COMMAND_AUTH = '1';
+        yield scratch.db.pendingSession.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+        device_store_1.DeviceStoreFactory._deviceStore = saved.store;
+        device_store_1.DeviceStoreFactory._pendingSessionStore = saved.pending;
+        Object.assign(typedi_1.Container.get(PluginContext_1.PluginContext), saved.context);
+        config_1.config.authDisabled = authDisabledBefore;
+        if (commandAuthBefore === undefined)
+            delete process.env.XENON_REQUIRE_COMMAND_AUTH;
+        else
+            process.env.XENON_REQUIRE_COMMAND_AUTH = commandAuthBefore;
+        sinon_1.default.restore();
+        restore();
+        for (const s of servers.splice(0)) {
+            s.closeAllConnections();
+            yield new Promise((resolve) => http_1.default.Server.prototype.close.call(s, () => resolve()));
+        }
+    }));
+    const port = (s) => s.address().port;
+    /** A hub (its public keys) and a node; `withRoute: false` is an older node. */
+    function boot() {
+        return __awaiter(this, arguments, void 0, function* ({ withRoute = true } = {}) {
+            const baseDriver = (0, appium_umbrella_1.appiumBaseDriver)();
+            const hubServer = yield baseDriver.server({
+                routeConfiguringFunction: baseDriver.routeConfiguringFunction((0, appium_umbrella_1.umbrellaWith)([])),
+                port: 0,
+                hostname: '127.0.0.1',
+                basePath: '/wd/hub',
+                cliArgs: { basePath: '/wd/hub' },
+                serverUpdaters: [
+                    (app) => {
+                        app.get('/xenon/api/auth/jwks.json', (_req, res) => res.json(hubKeys.jwks()));
+                    },
+                ],
+            });
+            servers.push(hubServer);
+            hubUrl = `http://127.0.0.1:${port(hubServer)}`;
+            const pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { hub: hubUrl, bindHostOrIp: '127.0.0.1', enableDashboard: false, deviceAvailabilityTimeoutMs: 1000, deviceAvailabilityQueryIntervalMs: 100 });
+            umbrella = (0, appium_umbrella_1.umbrellaWith)([[plugin_1.XenonPlugin, 'xenon']]);
+            const nodeServer = yield baseDriver.server({
+                routeConfiguringFunction: baseDriver.routeConfiguringFunction(umbrella),
+                port: 0,
+                hostname: '127.0.0.1',
+                basePath: '/node',
+                cliArgs: { basePath: '/node' },
+                serverUpdaters: [
+                    (app) => {
+                        (0, registerCommandAuth_1.registerSessionGateway)(app, { basePath: '/node' }, (0, registerCommandAuth_1.commandAuthDeps)({ enabled: () => true, authDisabled: () => false, logger: quiet }), (0, defaultGateway_1.nodeGatewayOptions)(hubUrl));
+                        // What ServerManager mounts under /xenon/api on a node.
+                        const api = express_1.default.Router();
+                        (0, nodeSessionStatus_1.registerNodeSessionStatus)(api, withRoute ? pluginArgs : Object.assign(Object.assign({}, pluginArgs), { hub: undefined }));
+                        app.use('/xenon/api', api);
+                    },
+                ],
+            });
+            servers.push(nodeServer);
+            nodeOrigin = `http://127.0.0.1:${port(nodeServer)}`;
+            typedi_1.Container.get(PluginContext_1.PluginContext).setContext(pluginArgs, port(nodeServer), NODE_ID, '/node');
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'phone-1',
+                    host: nodeOrigin,
+                    nodeId: NODE_ID,
+                    platform: 'android',
+                    name: 'phone-1',
+                    sdk: '14',
+                    busy: false,
+                    userBlocked: false,
+                    offline: false,
+                },
+            });
+        });
+    }
+    /** A session on the node, created as the hub creates it. */
+    function nodeSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).createTokenFor({
+                userId: 'alice',
+                udid: 'phone-1',
+                host: nodeOrigin,
+            });
+            const res = yield (0, loopbackRequest_1.default)(nodeOrigin)
+                .post('/node/session')
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, token)
+                .send({
+                capabilities: {
+                    alwaysMatch: {
+                        platformName: 'Android',
+                        'appium:automationName': appium_umbrella_1.FAKE_AUTOMATION,
+                        'appium:newCommandTimeout': 0,
+                        'appium:udid': 'phone-1',
+                        'xe:options': { recordVideo: false },
+                    },
+                    firstMatch: [{}],
+                },
+            });
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            return res.body.value.sessionId;
+        });
+    }
+    /** The hub's object for that session. */
+    const hubSide = (sessionId) => new RemoteSession_1.RemoteSession({
+        sessionId,
+        device: { udid: 'phone-1', host: nodeOrigin, nodeId: NODE_ID, platform: 'android' },
+        sessionResponse: {},
+        xenonOption: {},
+        baseUrl: `${nodeOrigin}/node`,
+    });
+    const idleClock = () => __awaiter(this, void 0, void 0, function* () { var _a; return (_a = (yield scratch.db.device.findFirst({ where: { udid: 'phone-1' } }))) === null || _a === void 0 ? void 0 : _a.lastCmdExecutedAt; });
+    it('asks the node without sending the session a command', () => __awaiter(this, void 0, void 0, function* () {
+        yield boot();
+        const sessionId = yield nodeSession();
+        const driver = umbrella.sessions[sessionId];
+        const restarted = sinon_1.default.spy(driver, 'startNewCommandTimeout');
+        const commands = sinon_1.default.spy(driver, 'executeCommand');
+        const before = yield idleClock();
+        const health = yield hubSide(sessionId).checkHealth();
+        (0, chai_1.expect)(health).to.deep.include({ isHealthy: true, errorType: XenonSession_1.HealthErrorType.NONE });
+        (0, chai_1.expect)(commands.callCount, 'commands the node’s driver ran').to.equal(0);
+        (0, chai_1.expect)(restarted.callCount, 'new-command timeouts restarted').to.equal(0);
+        (0, chai_1.expect)(yield idleClock(), 'the node’s idle clock').to.equal(before);
+    }));
+    it('reports a session the node no longer has as gone', () => __awaiter(this, void 0, void 0, function* () {
+        yield boot();
+        const sessionId = yield nodeSession();
+        yield umbrella.deleteSession(sessionId);
+        const health = yield hubSide(sessionId).checkHealth();
+        (0, chai_1.expect)(health).to.deep.include({
+            isHealthy: false,
+            errorType: XenonSession_1.HealthErrorType.SESSION_NOT_FOUND,
+        });
+    }));
+    it('the node answers only with the hub’s token for that session', () => __awaiter(this, void 0, void 0, function* () {
+        yield boot();
+        const sessionId = yield nodeSession();
+        const other = yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).tokenFor('another-session');
+        const statusOf = (token) => {
+            const req = (0, loopbackRequest_1.default)(nodeOrigin).get(`/xenon/api/node/sessions/${sessionId}`);
+            return token ? req.set(hubSessionToken_1.HUB_TOKEN_HEADER, token) : req;
+        };
+        for (const res of [yield statusOf(), yield statusOf(other)]) {
+            (0, chai_1.expect)(res.status).to.equal(404);
+            (0, chai_1.expect)(res.body.value.error).to.equal('invalid session id');
+            (0, chai_1.expect)(res.headers[nodeSessionStatus_1.NODE_SESSION_STATUS_HEADER]).to.equal('1');
+        }
+        const own = yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).tokenFor(sessionId);
+        const res = yield statusOf(own);
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.body.value).to.deep.equal({ sessionId, exists: true });
+    }));
+    it('asks no more than a command does: with per-command auth off, no token is needed', () => __awaiter(this, void 0, void 0, function* () {
+        yield boot();
+        const sessionId = yield nodeSession();
+        delete process.env.XENON_REQUIRE_COMMAND_AUTH;
+        const res = yield (0, loopbackRequest_1.default)(nodeOrigin).get(`/xenon/api/node/sessions/${sessionId}`);
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.body.value).to.deep.equal({ sessionId, exists: true });
+    }));
+    it('an older node without the route is probed the old way, and the hub says so once', () => __awaiter(this, void 0, void 0, function* () {
+        yield boot({ withRoute: false });
+        const sessionId = yield nodeSession();
+        const warn = sinon_1.default.stub(typedi_1.Container.get(nodeSessionStatus_1.NodeSessionProbeSupport).logger, 'warn');
+        const hub = hubSide(sessionId);
+        (0, chai_1.expect)(yield hub.checkHealth()).to.deep.include({ isHealthy: true });
+        (0, chai_1.expect)(yield hub.checkHealth()).to.deep.include({ isHealthy: true });
+        (0, chai_1.expect)(warn.callCount, 'warnings').to.equal(1);
+        (0, chai_1.expect)(String(warn.firstCall.args[0])).to.include(nodeOrigin);
+    }));
+});

package/lib/test/unit/hub-routed-session-recovery.spec.js

@@ -0,0 +1,151 @@
+"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 typedi_1 = require("typedi");
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
+const sessionLocator_1 = require("../../src/gateway/sessionLocator");
+const prisma_1 = require("../../src/prisma");
+const SessionType_1 = __importDefault(require("../../src/enums/SessionType"));
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+/**
+ * A hub finds where a session runs after a restart from the session's row
+ * (SessionLocator, SessionManager.recoverActiveSessions). The row used to be
+ * written only with the dashboard on, and never for a cloud session, so a
+ * hub with the dashboard off lost every node session on restart: its
+ * commands went to the hub's own Appium, which had no such session, while the
+ * node kept it and the phone.
+ *
+ * A session the hub routes to a node or a cloud now always has its row. A
+ * local session's row is still the dashboard's to write.
+ */
+describe('a session the hub routes elsewhere survives a restart, dashboard on or off', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    const HUB_NODE_ID = 'hub-node-id';
+    let context;
+    let saved;
+    let restore;
+    let nodeOrigin;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        node.get('/xenon/api/webdriver', (0, nodeWebDriverUrl_1.webdriverInfoHandler)(() => '/node'));
+        const server = yield loopback.serve(node);
+        nodeOrigin = `http://127.0.0.1:${server.address().port}`;
+        restore = (0, container_registration_1.saveRegistrations)(nodeWebDriverUrl_1.NodeBasePathResolver);
+        typedi_1.Container.set(nodeWebDriverUrl_1.NodeBasePathResolver, new nodeWebDriverUrl_1.NodeBasePathResolver());
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = {
+            context: Object.assign({}, context),
+            store: device_store_1.DeviceStoreFactory._deviceStore,
+            pending: device_store_1.DeviceStoreFactory._pendingSessionStore,
+        };
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        device_store_1.DeviceStoreFactory._pendingSessionStore = new prisma_store_1.PrismaPendingSessionStore();
+        context.pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { enableDashboard: false });
+        context.nodeId = HUB_NODE_ID;
+        context.nodeBasePath = '/wd/hub';
+        yield scratch.db.session.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+        Object.assign(context, saved.context);
+        device_store_1.DeviceStoreFactory._deviceStore = saved.store;
+        device_store_1.DeviceStoreFactory._pendingSessionStore = saved.pending;
+        sinon_1.default.restore();
+        restore();
+        yield loopback.closeAll();
+    }));
+    function phone(udid, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const row = yield scratch.db.device.create({
+                data: Object.assign({ udid, platform: 'android', name: udid, sdk: '14', busy: true, claimedAt: Date.now(), userBlocked: false, offline: false }, fields),
+            });
+            return row;
+        });
+    }
+    const caps = {
+        alwaysMatch: { platformName: 'Android', 'xe:options': { recordVideo: false } },
+        firstMatch: [{}],
+    };
+    /** The session is created on its phone as finalizeSession records it. */
+    function created(sessionId, device, remote) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new SessionLifecycleService_1.SessionLifecycleService().finalizeSession({ protocol: 'W3C', value: [sessionId, { platformName: 'Android' }, 'W3C'] }, device, caps, {}, remote, 'key-1', 'alice');
+        });
+    }
+    /** The hub restarts: nothing in memory survives. */
+    const restart = () => {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+    };
+    const locator = () => new sessionLocator_1.SessionLocator(Object.assign(Object.assign({ getSession: (id) => SessionManager_1.SESSION_MANAGER.getSession(id) }, (0, sessionLocator_1.sessionRowsFrom)(prisma_1.prisma)), { isLocalDevice: (d) => !d.cloud && d.nodeId === HUB_NODE_ID, webDriverUrlOf: (d) => __awaiter(void 0, void 0, void 0, function* () { return `${d.host}/node`; }) }));
+    it('a node’s session is routed to the node again, with the dashboard off', () => __awaiter(void 0, void 0, void 0, function* () {
+        const device = yield phone('node-phone', { host: nodeOrigin, nodeId: 'node-peer' });
+        yield created('remote-1', device, true);
+        restart();
+        (0, chai_1.expect)(yield locator().locate('remote-1')).to.deep.include({
+            kind: 'remote',
+            url: `${nodeOrigin}/node`,
+            cloud: false,
+        });
+    }));
+    it('is rebuilt at boot with its owner, with the dashboard off', () => __awaiter(void 0, void 0, void 0, function* () {
+        const device = yield phone('node-phone', { host: nodeOrigin, nodeId: 'node-peer' });
+        yield created('remote-1', device, true);
+        restart();
+        // SESSION_MANAGER itself: another spec may have replaced the container's
+        // SessionManager, and the gateway reads this one.
+        const recovered = yield SessionManager_1.SESSION_MANAGER.recoverActiveSessions('hub-after-restart', '/wd/hub');
+        (0, chai_1.expect)(recovered).to.equal(1);
+        const session = SessionManager_1.SESSION_MANAGER.getSession('remote-1');
+        (0, chai_1.expect)(session.getType()).to.equal(SessionType_1.default.REMOTE);
+        (0, chai_1.expect)(session.getWebDriverUrl()).to.equal(`${nodeOrigin}/node`);
+        (0, chai_1.expect)(session.userId).to.equal('alice');
+        (0, chai_1.expect)(session.apiKeyId).to.equal('key-1');
+        const row = yield scratch.db.session.findUnique({ where: { id: 'remote-1' } });
+        (0, chai_1.expect)(row).to.include({ user_id: 'alice', api_key_id: 'key-1', status: 'running' });
+    }));
+    it('a cloud session is routed to the cloud again', () => __awaiter(void 0, void 0, void 0, function* () {
+        const device = yield phone('cloud-phone', {
+            host: 'https://hub.cloud.example/wd/hub',
+            // The store keeps the column as JSON (prisma-store.ts).
+            cloud: JSON.stringify('browserstack'),
+        });
+        yield created('cloud-1', Object.assign(Object.assign({}, device), { cloud: 'browserstack' }), true);
+        restart();
+        (0, chai_1.expect)(yield locator().locate('cloud-1')).to.deep.include({ kind: 'remote', cloud: true });
+    }));
+    it('a local session with the dashboard off still writes no row', () => __awaiter(void 0, void 0, void 0, function* () {
+        const device = yield phone('hub-phone', {
+            host: 'http://127.0.0.1:4799',
+            nodeId: HUB_NODE_ID,
+        });
+        yield created('local-1', device, false);
+        (0, chai_1.expect)(yield scratch.db.session.count()).to.equal(0);
+    }));
+});