@xenon-device-management/xenon 2.15.0 → 2.16.0

package/lib/test/unit/selector-health-actions.spec.js

@@ -25,7 +25,9 @@ describe('POST /healing/selector/state (real queries)', function () {
     before(() => __awaiter(this, void 0, void 0, function* () {
         yield (0, selector_health_fixture_1.seedSelectorHealth)(scratch.db);
         // The service's transactions use the scratch database's own client.
-        typedi_1.Container.set(SelectorStateService_1.SelectorStateService, new SelectorStateService_1.SelectorStateService(scratch.db, { emitToDashboard: () => undefined }));
+        typedi_1.Container.set(SelectorStateService_1.SelectorStateService, new SelectorStateService_1.SelectorStateService(scratch.db, {
+            emitToDashboardForSelector: () => __awaiter(this, void 0, void 0, function* () { return undefined; }),
+        }));
     }));
     after(() => {
         typedi_1.Container.remove(SelectorStateService_1.SelectorStateService);

package/lib/test/unit/selector-state-service.spec.js

@@ -38,7 +38,7 @@ function buildPrismaStub() {
 }
 function buildSocketStub() {
     return {
-        emitToDashboard: sinon_1.default.stub(),
+        emitToDashboardForSelector: sinon_1.default.stub().resolves(),
     };
 }
 const STRATEGY = 'accessibility id';
@@ -105,8 +105,8 @@ describe('SelectorStateService', () => {
                 selector: SELECTOR,
                 apiKeyId: API_KEY_ID,
             });
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            const [event, payload] = socketStub.emitToDashboard.firstCall.args;
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            const [event, payload] = socketStub.emitToDashboardForSelector.firstCall.args;
             (0, chai_1.expect)(event).to.equal(SocketEvents_1.SocketEvents.SELECTOR_FIXED);
             (0, chai_1.expect)(payload).to.include({
                 original_strategy: STRATEGY,
@@ -133,7 +133,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(err).to.be.instanceOf(SelectorStateService_1.SelectorStateConflictError);
             (0, chai_1.expect)(err.currentStatus).to.equal('muted');
             (0, chai_1.expect)(prismaStub.selectorState.upsert.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
     });
     describe('mute', () => {
@@ -170,8 +170,8 @@ describe('SelectorStateService', () => {
                 selector: SELECTOR,
                 apiKeyId: API_KEY_ID,
             });
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            const [event, payload] = socketStub.emitToDashboard.firstCall.args;
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            const [event, payload] = socketStub.emitToDashboardForSelector.firstCall.args;
             (0, chai_1.expect)(event).to.equal(SocketEvents_1.SocketEvents.SELECTOR_MUTED);
             (0, chai_1.expect)(payload.status).to.equal('muted');
             (0, chai_1.expect)(payload.muted_at).to.equal('2026-04-25T02:00:00.000Z');
@@ -195,8 +195,8 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.calledOnce).to.equal(true);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
         }));
         it('keeps the row and sets status=active when history exists', () => __awaiter(void 0, void 0, void 0, function* () {
             const muted = makeRow({
@@ -217,8 +217,8 @@ describe('SelectorStateService', () => {
             const args = prismaStub.selectorState.update.firstCall.args[0];
             (0, chai_1.expect)(args.data.status).to.equal('active');
             (0, chai_1.expect)(args.data.muted_at).to.equal(null);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
         }));
         it('is a no-op when the row exists but is not muted', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'active' }));
@@ -229,7 +229,7 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.called).to.equal(false);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('is a no-op when no row exists', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(null);
@@ -240,7 +240,7 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.called).to.equal(false);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
     });
     describe('cancelVerification', () => {
@@ -261,7 +261,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(err.currentStatus).to.equal('active');
             (0, chai_1.expect)(prismaStub.selectorState.delete.called).to.equal(false);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('throws SelectorStateConflictError when no row exists', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(null);
@@ -294,8 +294,8 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.calledOnce).to.equal(true);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
         }));
         it('keeps row and clears fixed state when history exists (resolved_at not null)', () => __awaiter(void 0, void 0, void 0, function* () {
             const pending = makeRow({
@@ -318,7 +318,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(args.data.status).to.equal('active');
             (0, chai_1.expect)(args.data.fixed_at).to.equal(null);
             (0, chai_1.expect)(args.data.clean_builds_count).to.equal(0);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
         }));
     });
     describe('onHealRecorded', () => {
@@ -344,8 +344,8 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(args.data.resolved_at).to.equal(null);
             (0, chai_1.expect)(args.data.regression_count).to.deep.equal({ increment: 1 });
             (0, chai_1.expect)(args.data.clean_builds_count).to.equal(0);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
         }));
         it('flips resolved → active, clears resolved_at, and increments regression_count', () => __awaiter(void 0, void 0, void 0, function* () {
             const resolved = makeRow({
@@ -368,7 +368,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(args.data.resolved_at).to.equal(null);
             (0, chai_1.expect)(args.data.fixed_at).to.equal(null);
             (0, chai_1.expect)(args.data.regression_count).to.deep.equal({ increment: 1 });
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
         }));
         it('is a no-op when the row is muted', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'muted' }));
@@ -378,7 +378,7 @@ describe('SelectorStateService', () => {
                 sessionId: SESSION_ID,
             });
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('is a no-op when no row exists', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(null);
@@ -388,7 +388,7 @@ describe('SelectorStateService', () => {
                 sessionId: SESSION_ID,
             });
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('is a no-op when row is already active', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'active' }));
@@ -398,7 +398,7 @@ describe('SelectorStateService', () => {
                 sessionId: SESSION_ID,
             });
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
     });
     describe('getState', () => {
@@ -443,7 +443,7 @@ describe('SelectorStateService', () => {
                 thrown = e;
             }
             (0, chai_1.expect)(thrown.message).to.equal('disk full');
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('records the mute with its reason', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.upsert.resolves(makeRow({ status: 'muted', muted_at: new Date() }));
@@ -483,4 +483,53 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(prismaStub.selectorEvent.create.called).to.equal(false);
         }));
     });
+    // The socket server sends a selector's event only to the dashboards whose
+    // caller may see the selector, so every event names it.
+    describe('each event names its selector, for the socket server to scope it', () => {
+        const KEY = { strategy: STRATEGY, selector: SELECTOR };
+        const ctx = { strategy: STRATEGY, selector: SELECTOR, apiKeyId: API_KEY_ID };
+        const sent = () => socketStub.emitToDashboardForSelector.getCalls().map((c) => [c.args[0], c.args[2]]);
+        it('markFixed and mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(null);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'pending' }));
+            yield svc.markFixed(ctx);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'muted' }));
+            yield svc.mute(ctx);
+            (0, chai_1.expect)(sent()).to.deep.equal([
+                [SocketEvents_1.SocketEvents.SELECTOR_FIXED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_MUTED, KEY],
+            ]);
+        }));
+        it('unmute and cancelVerification, whether the row is kept or deleted', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'muted' }));
+            yield svc.unmute(ctx);
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'muted', regression_count: 1 }));
+            prismaStub.selectorState.update.resolves(makeRow({ status: 'active', regression_count: 1 }));
+            yield svc.unmute(ctx);
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'pending' }));
+            yield svc.cancelVerification(ctx);
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'pending', regression_count: 1 }));
+            yield svc.cancelVerification(ctx);
+            (0, chai_1.expect)(sent()).to.deep.equal([
+                [SocketEvents_1.SocketEvents.SELECTOR_UNMUTED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_UNMUTED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_CANCELLED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_CANCELLED, KEY],
+            ]);
+        }));
+        it('onHealRecorded', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'pending' }));
+            prismaStub.selectorState.update.resolves(makeRow({ status: 'active', regression_count: 1 }));
+            yield svc.onHealRecorded({ strategy: STRATEGY, selector: SELECTOR, sessionId: SESSION_ID });
+            (0, chai_1.expect)(sent()).to.deep.equal([[SocketEvents_1.SocketEvents.SELECTOR_REGRESSED, KEY]]);
+        }));
+        it('a heal recorded with no strategy names strategy ""', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(null);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'muted', original_strategy: '' }));
+            yield svc.mute({ strategy: '', selector: SELECTOR, apiKeyId: API_KEY_ID });
+            (0, chai_1.expect)(sent()).to.deep.equal([
+                [SocketEvents_1.SocketEvents.SELECTOR_MUTED, { strategy: '', selector: SELECTOR }],
+            ]);
+        }));
+    });
 });

package/lib/test/unit/selector-verification-clean-build.spec.js

@@ -59,7 +59,7 @@ describe('SelectorVerificationJob counts only builds where the selector was foun
         yield scratch.db.selectorEvent.deleteMany();
         yield scratch.db.selectorState.deleteMany();
         yield scratch.db.sessionLog.deleteMany();
-        socket = { emitToDashboard: sinon_1.default.stub() };
+        socket = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
         yield scratch.db.selectorState.create({
             data: {
                 original_strategy: 'xpath',

package/lib/test/unit/selector-verification-job.spec.js

@@ -49,7 +49,7 @@ describe('SelectorVerificationJob.run', () => {
         prismaStub.$transaction = sinon_1.default
             .stub()
             .callsFake((fn) => fn(prismaStub));
-        socketStub = { emitToDashboard: sinon_1.default.stub() };
+        socketStub = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
         job = new SelectorVerificationJob_1.SelectorVerificationJob(prismaStub, socketStub);
     });
     afterEach(() => sinon_1.default.restore());
@@ -84,8 +84,13 @@ describe('SelectorVerificationJob.run', () => {
         (0, chai_1.expect)(updateArg.data.status).to.equal('resolved');
         (0, chai_1.expect)(updateArg.data.resolved_at).to.be.instanceOf(Date);
         (0, chai_1.expect)(updateArg.data.clean_builds_count).to.equal(3);
-        (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.be.true;
-        (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal('selector_resolved');
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.be.true;
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal('selector_resolved');
+        // Named, so only the dashboards that may see the selector get it.
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[2]).to.deep.equal({
+            strategy: 'xpath',
+            selector: '//x',
+        });
     }));
     it('updates clean_builds_count and emits PROGRESS when below 3 and value changed', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([
@@ -111,7 +116,11 @@ describe('SelectorVerificationJob.run', () => {
         const updateArg = prismaStub.selectorState.update.firstCall.args[0];
         (0, chai_1.expect)(updateArg.data.status).to.be.undefined;
         (0, chai_1.expect)(updateArg.data.clean_builds_count).to.equal(1);
-        (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal('selector_progress');
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal('selector_progress');
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[2]).to.deep.equal({
+            strategy: 'xpath',
+            selector: '//x',
+        });
     }));
     it('does not write or emit when clean_builds_count is unchanged and not promoting', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([
@@ -130,7 +139,7 @@ describe('SelectorVerificationJob.run', () => {
         ]);
         yield job.run();
         (0, chai_1.expect)(prismaStub.selectorState.update.called).to.be.false;
-        (0, chai_1.expect)(socketStub.emitToDashboard.called).to.be.false;
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.be.false;
     }));
     it('SQL filters out builds with NULL build_id and only counts findElement(s) commands', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([
@@ -160,7 +169,7 @@ describe('SelectorVerificationJob.run', () => {
         yield job.run();
         (0, chai_1.expect)(prismaStub.$queryRaw.called).to.be.false;
         (0, chai_1.expect)(prismaStub.selectorState.update.called).to.be.false;
-        (0, chai_1.expect)(socketStub.emitToDashboard.called).to.be.false;
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.be.false;
     }));
     it('continues processing remaining rows if one fails', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([

package/lib/test/unit/selector-verification-missed-regression.spec.js

@@ -53,7 +53,7 @@ describe('SelectorVerificationJob catches a heal the live check missed', functio
         yield scratch.db.selectorEvent.deleteMany();
         yield scratch.db.selectorState.deleteMany();
         yield scratch.db.sessionLog.deleteMany();
-        socket = { emitToDashboard: sinon_1.default.stub() };
+        socket = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
     }));
     const find = (build, selector, healed, at) => scratch.db.sessionLog.create({
         data: {
@@ -105,7 +105,7 @@ describe('SelectorVerificationJob catches a heal the live check missed', functio
         (0, chai_1.expect)(row).to.include({ status: 'active', regression_count: 1, clean_builds_count: 0 });
         (0, chai_1.expect)(row.fixed_at).to.equal(null);
         (0, chai_1.expect)(yield actionsOf('//pending/broke')).to.deep.equal(['broke_again']);
-        (0, chai_1.expect)(socket.emitToDashboard.firstCall.args[0]).to.equal('selector_regressed');
+        (0, chai_1.expect)(socket.emitToDashboardForSelector.firstCall.args[0]).to.equal('selector_regressed');
     }));
     it('sends a fixed selector back to fix', () => __awaiter(this, void 0, void 0, function* () {
         yield state('//resolved/broke', 'resolved');

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);
+        }));
+    });
+});