@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/test/helpers/fake-ai-provider.js

@@ -0,0 +1,188 @@
+"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 });
+exports.OLLAMA_URL = exports.PROVIDERS = void 0;
+exports.useFakeAiProviders = useFakeAiProviders;
+const axios_1 = __importDefault(require("axios"));
+const sinon_1 = __importDefault(require("sinon"));
+const config_1 = require("../../src/config");
+exports.PROVIDERS = ['gemini', 'openai', 'anthropic', 'ollama'];
+const AI_SETTINGS = [
+    'aiProvider',
+    'aiModel',
+    'aiBaseUrl',
+    'geminiApiKey',
+    'openaiApiKey',
+    'anthropicApiKey',
+    'geminiModel',
+    'openaiModel',
+    'anthropicModel',
+    'ollamaModel',
+];
+exports.OLLAMA_URL = 'http://ollama.test:11434';
+function json(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        // The OpenAI and Anthropic SDKs retry a 429 after a pause unless told not to.
+        headers: { 'content-type': 'application/json', 'x-should-retry': 'false' },
+    });
+}
+function okBody(provider, text) {
+    switch (provider) {
+        case 'gemini':
+            return {
+                candidates: [
+                    { content: { role: 'model', parts: [{ text }] }, finishReason: 'STOP', index: 0 },
+                ],
+            };
+        case 'openai':
+            return {
+                id: 'chatcmpl-test',
+                object: 'chat.completion',
+                created: 0,
+                model: 'test',
+                choices: [
+                    { index: 0, message: { role: 'assistant', content: text }, finish_reason: 'stop' },
+                ],
+            };
+        case 'anthropic':
+            return {
+                id: 'msg_test',
+                type: 'message',
+                role: 'assistant',
+                model: 'test',
+                content: [{ type: 'text', text }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 1, output_tokens: 1 },
+            };
+        default:
+            return { response: text };
+    }
+}
+function errorBody(provider, status, said) {
+    const message = said !== null && said !== void 0 ? said : (status === 429 ? 'Resource has been exhausted (e.g. check quota).' : `HTTP ${status}`);
+    switch (provider) {
+        case 'gemini':
+            return { error: { code: status, message, status: 'RESOURCE_EXHAUSTED' } };
+        case 'anthropic':
+            return { type: 'error', error: { type: 'rate_limit_error', message } };
+        default:
+            return { error: { message, type: 'requests', code: 'rate_limit_exceeded' } };
+    }
+}
+function aborted() {
+    const err = new Error('This operation was aborted');
+    err.name = 'AbortError';
+    return err;
+}
+/** Resolves never, and rejects as fetch does when the request's signal aborts. */
+function hangUntilAborted(signal) {
+    return new Promise((_, reject) => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return reject(aborted());
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => reject(aborted()));
+    });
+}
+function useFakeAiProviders() {
+    let saved = {};
+    let savedMockEnv;
+    let provider = 'gemini';
+    let current = { status: 500 };
+    let ollamaUp = true;
+    const calls = [];
+    const sandbox = sinon_1.default.createSandbox();
+    beforeEach(() => {
+        saved = Object.fromEntries(AI_SETTINGS.map((k) => [k, config_1.config[k]]));
+        savedMockEnv = process.env.GEMINI_API_KEY;
+        // 'mock' would put the service in its built-in mock mode.
+        if (process.env.GEMINI_API_KEY === 'mock')
+            delete process.env.GEMINI_API_KEY;
+        for (const k of AI_SETTINGS)
+            config_1.config[k] = undefined;
+        config_1.config.aiProvider = 'gemini';
+        calls.length = 0;
+        current = { status: 500 };
+        ollamaUp = true;
+        sandbox.stub(globalThis, 'fetch').callsFake(((_url, init) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const signal = (_a = init === null || init === void 0 ? void 0 : init.signal) !== null && _a !== void 0 ? _a : undefined;
+            calls.push({ provider, body: String((_b = init === null || init === void 0 ? void 0 : init.body) !== null && _b !== void 0 ? _b : ''), signal });
+            if (current === 'hang')
+                return hangUntilAborted(signal);
+            if ('text' in current)
+                return json(200, okBody(provider, current.text));
+            return json(current.status, errorBody(provider, current.status, current.message));
+        })));
+        // Ollama: its health check answers, then the generate call as told.
+        sandbox.stub(axios_1.default, 'get').callsFake(((url) => __awaiter(this, void 0, void 0, function* () {
+            if (url.startsWith(exports.OLLAMA_URL)) {
+                if (ollamaUp)
+                    return { status: 200, data: { models: [] } };
+                throw Object.assign(new Error(`connect ECONNREFUSED ${exports.OLLAMA_URL}`), {
+                    code: 'ECONNREFUSED',
+                });
+            }
+            throw new Error(`no network in tests: GET ${url}`);
+        })));
+        sandbox.stub(axios_1.default, 'post').callsFake(((url, body, cfg) => __awaiter(this, void 0, void 0, function* () {
+            if (!url.startsWith(exports.OLLAMA_URL))
+                throw new Error(`no network in tests: POST ${url}`);
+            const signal = cfg === null || cfg === void 0 ? void 0 : cfg.signal;
+            calls.push({ provider: 'ollama', body: JSON.stringify(body), signal });
+            if (current === 'hang')
+                return hangUntilAborted(signal);
+            if ('text' in current)
+                return { status: 200, data: okBody('ollama', current.text) };
+            const err = new Error(`Request failed with status code ${current.status}`);
+            err.response = {
+                status: current.status,
+                data: errorBody('ollama', current.status, current.message),
+            };
+            throw err;
+        })));
+    });
+    afterEach(() => {
+        sandbox.restore();
+        for (const k of AI_SETTINGS)
+            config_1.config[k] = saved[k];
+        if (savedMockEnv === undefined)
+            delete process.env.GEMINI_API_KEY;
+        else
+            process.env.GEMINI_API_KEY = savedMockEnv;
+    });
+    return {
+        calls,
+        use(name, opts = {}) {
+            provider = name;
+            const model = `test-${name}-${Math.random().toString(36).slice(2)}`;
+            const key = opts.key === false ? undefined : 'test-key';
+            config_1.config.aiProvider = name;
+            if (name === 'gemini')
+                Object.assign(config_1.config, { geminiApiKey: key, geminiModel: model });
+            if (name === 'openai')
+                Object.assign(config_1.config, { openaiApiKey: key, openaiModel: model });
+            if (name === 'anthropic')
+                Object.assign(config_1.config, { anthropicApiKey: key, anthropicModel: model });
+            if (name === 'ollama')
+                Object.assign(config_1.config, { aiBaseUrl: exports.OLLAMA_URL, ollamaModel: model });
+            return { model };
+        },
+        answer(answer) {
+            current = answer;
+        },
+        ollamaUp(up) {
+            ollamaUp = up;
+        },
+    };
+}

package/lib/test/helpers/fake-http-proxy.js

@@ -0,0 +1,106 @@
+"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 });
+exports.startFakeProxy = startFakeProxy;
+const http_1 = __importDefault(require("http"));
+const net_1 = __importDefault(require("net"));
+/**
+ * An HTTP proxy on 127.0.0.1 that forwards what it is sent and notes it: a
+ * request in absolute form (http-proxy-agent, axios) is passed on to its
+ * target, a CONNECT (https-proxy-agent, so WebSockets) becomes a tunnel, or
+ * is refused with `refuseConnect`. A spec can then tell a call that went
+ * through the proxy from one that went straight to the target.
+ */
+function startFakeProxy() {
+    return __awaiter(this, arguments, void 0, function* (opts = {}) {
+        const seen = [];
+        const authorizations = [];
+        const sockets = new Set();
+        const resolve = (host) => { var _a, _b; return (_b = (_a = opts.hosts) === null || _a === void 0 ? void 0 : _a[host]) !== null && _b !== void 0 ? _b : host; };
+        const server = http_1.default.createServer((req, res) => {
+            var _a, _b;
+            seen.push(`${req.method} ${req.url}`);
+            authorizations.push(String((_a = req.headers['proxy-authorization']) !== null && _a !== void 0 ? _a : ''));
+            let target;
+            try {
+                target = new URL((_b = req.url) !== null && _b !== void 0 ? _b : '');
+            }
+            catch (_c) {
+                res.writeHead(400).end();
+                return;
+            }
+            const upstream = http_1.default.request(Object.assign(Object.assign({}, urlParts(target)), { hostname: resolve(target.hostname), method: req.method, headers: req.headers }), (answer) => {
+                var _a;
+                res.writeHead((_a = answer.statusCode) !== null && _a !== void 0 ? _a : 502, answer.headers);
+                answer.pipe(res);
+            });
+            upstream.on('error', () => res.writeHead(502).end());
+            req.pipe(upstream);
+        });
+        server.on('connect', (req, client, head) => {
+            var _a;
+            seen.push(`CONNECT ${req.url}`);
+            authorizations.push(String((_a = req.headers['proxy-authorization']) !== null && _a !== void 0 ? _a : ''));
+            if (opts.ignoreConnect) {
+                sockets.add(client);
+                client.on('error', () => client.destroy());
+                return;
+            }
+            if (opts.refuseConnect) {
+                client.end('HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n');
+                return;
+            }
+            const [host, port] = String(req.url).split(':');
+            const upstream = net_1.default.connect(Number(port), resolve(host), () => {
+                client.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+                if (head.length)
+                    upstream.write(head);
+                upstream.pipe(client);
+                client.pipe(upstream);
+            });
+            sockets.add(upstream).add(client);
+            const drop = () => {
+                upstream.destroy();
+                client.destroy();
+            };
+            upstream.on('error', drop);
+            client.on('error', drop);
+        });
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        return {
+            url: `http://127.0.0.1:${port}`,
+            seen,
+            authorizations,
+            close: () => new Promise((resolve) => {
+                var _a;
+                for (const socket of sockets)
+                    socket.destroy();
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+function urlParts(url) {
+    return {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port,
+        path: `${url.pathname}${url.search}`,
+    };
+}

package/lib/test/helpers/loki-stores.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLokiStores = useLokiStores;
+exports.usePrismaStores = usePrismaStores;
 const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
 // DeviceStoreFactory's cached stores, one per kind.
 const CACHES = ['_deviceStore', '_pendingSessionStore', '_cliArgsStore', '_healEtalonStore'];
 /**
@@ -39,3 +41,34 @@ function useLokiStores() {
             process.env.NODE_ENV = previousEnv;
     });
 }
+/**
+ * The Prisma stores (what a server with SQLite runs) for the enclosing
+ * `describe`, however the file was started. Put the suite's database behind
+ * them first: `useScratchDatabase({ wholeSuite: true })`.
+ *
+ * `npm run test:all` sets NODE_ENV to 'test', so DeviceStoreFactory hands it
+ * Loki stores, while `npx mocha <file>` gets Prisma ones. A spec written
+ * against the Prisma store's queries then tested Loki in the full run, and its
+ * phones stayed in Loki's one collection for every later spec. This hands the
+ * factory new Prisma stores for the suite, then puts the old ones back. A
+ * module that took its store when it was imported (`grid.ts`) keeps that one.
+ *
+ * Call it inside a `describe`, before the hooks that use a store, never at the
+ * top of a file.
+ */
+function usePrismaStores() {
+    const factory = device_store_1.DeviceStoreFactory;
+    const saved = {};
+    before(() => {
+        for (const key of CACHES)
+            saved[key] = factory[key];
+        factory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        factory._pendingSessionStore = new prisma_store_1.PrismaPendingSessionStore();
+        factory._cliArgsStore = new prisma_store_1.PrismaCLIArgsStore();
+        factory._healEtalonStore = new prisma_store_1.PrismaHealEtalonStore();
+    });
+    after(() => {
+        for (const key of CACHES)
+            factory[key] = saved[key];
+    });
+}

package/lib/test/helpers/otlp-probe.js

@@ -0,0 +1,107 @@
+"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 });
+exports.startOtlpProbe = startOtlpProbe;
+exports.attributeOf = attributeOf;
+exports.resetOtelGlobals = resetOtelGlobals;
+exports.flushOtelGlobals = flushOtelGlobals;
+const http_1 = __importDefault(require("http"));
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+/**
+ * A stand-in OTLP/HTTP collector on 127.0.0.1. It answers every request 200
+ * and keeps what it was sent, so a spec can see where Xenon's telemetry went
+ * and in which encoding (Xenon's own exporters send OTLP/JSON; the ones the
+ * OTel SDK builds from OTEL_* variables send protobuf).
+ */
+function startOtlpProbe() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requests = [];
+        const server = http_1.default.createServer((req, res) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => {
+                var _a, _b;
+                const body = Buffer.concat(chunks);
+                const contentType = String((_a = req.headers['content-type']) !== null && _a !== void 0 ? _a : '');
+                let json;
+                if (contentType.includes('json')) {
+                    try {
+                        json = JSON.parse(body.toString('utf8'));
+                    }
+                    catch (_c) {
+                        json = undefined;
+                    }
+                }
+                requests.push({ path: (_b = req.url) !== null && _b !== void 0 ? _b : '', contentType, body, json });
+                if (contentType.includes('json')) {
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end('{}');
+                }
+                else {
+                    res.writeHead(200, { 'content-type': 'application/x-protobuf' });
+                    res.end();
+                }
+            });
+        });
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        return {
+            url: (path) => `http://127.0.0.1:${port}${path}`,
+            requests,
+            spans: () => requests.flatMap((r) => {
+                var _a, _b;
+                return ((_b = (_a = r.json) === null || _a === void 0 ? void 0 : _a.resourceSpans) !== null && _b !== void 0 ? _b : []).flatMap((rs) => { var _a; return ((_a = rs.scopeSpans) !== null && _a !== void 0 ? _a : []).flatMap((ss) => { var _a; return ((_a = ss.spans) !== null && _a !== void 0 ? _a : []); }); });
+            }),
+            close: () => new Promise((resolve) => {
+                var _a;
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+/** A span attribute's value, whatever its OTLP/JSON type. */
+function attributeOf(attributes, key) {
+    const found = attributes === null || attributes === void 0 ? void 0 : attributes.find((a) => a.key === key);
+    if (!found)
+        return undefined;
+    return Object.values(found.value)[0];
+}
+/**
+ * Takes every OTel global (tracer, meter and logger providers, context
+ * manager, propagator) off the API, so the next registration wins. The API
+ * keeps the first registration for the life of the process and refuses the
+ * rest: a spec that leaves one behind decides what every later spec exports.
+ */
+function resetOtelGlobals() {
+    api_1.trace.disable();
+    api_1.metrics.disable();
+    api_logs_1.logs.disable();
+    api_1.context.disable();
+    api_1.propagation.disable();
+}
+/** Exports whatever the registered meter and logger providers hold now. */
+function flushOtelGlobals() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const meterProvider = api_1.metrics.getMeterProvider();
+        yield ((_a = meterProvider.forceFlush) === null || _a === void 0 ? void 0 : _a.call(meterProvider));
+        const loggerProvider = api_logs_1.logs.getLoggerProvider();
+        yield ((_b = loggerProvider.forceFlush) === null || _b === void 0 ? void 0 : _b.call(loggerProvider));
+    });
+}

package/lib/test/helpers/page-sources.js

@@ -0,0 +1,164 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ios = exports.android = void 0;
+exports.elementIdOf = elementIdOf;
+exports.pageDriver = pageDriver;
+const xmldom_1 = require("@xmldom/xmldom");
+const xpath_1 = require("xpath");
+/**
+ * Page sources shaped like the drivers' own (UiAutomator2's `hierarchy`,
+ * XCUITest's `AppiumAUT`), and a driver that answers finds by running the
+ * XPath on them, as the real drivers do, for specs that check which element a
+ * healed locator selects. No phone.
+ */
+const W3C_ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';
+const attrs = (o) => Object.entries(o)
+    .map(([k, v]) => `${k}="${v}"`)
+    .join(' ');
+function androidNode(tag, index, bounds, extra = {}, children) {
+    const a = attrs(Object.assign({ index, package: 'com.example.shop', class: tag, text: '', 'resource-id': '', 'content-desc': '', checkable: 'false', checked: 'false', clickable: 'false', enabled: 'true', focusable: 'false', focused: 'false', 'long-clickable': 'false', password: 'false', scrollable: 'false', selected: 'false', bounds, displayed: 'true' }, extra));
+    return children === undefined ? `<${tag} ${a} />` : `<${tag} ${a}>${children}</${tag}>`;
+}
+exports.android = {
+    button: (index, id, text, bounds) => androidNode('android.widget.Button', index, bounds, {
+        'resource-id': `com.example.shop:id/${id}`,
+        text,
+        'content-desc': text,
+        clickable: 'true',
+        focusable: 'true',
+    }),
+    field: (index, id, text, bounds) => androidNode('android.widget.EditText', index, bounds, {
+        'resource-id': `com.example.shop:id/${id}`,
+        text,
+        clickable: 'true',
+        focusable: 'true',
+    }),
+    text: (index, id, text, bounds) => androidNode('android.widget.TextView', index, bounds, {
+        'resource-id': `com.example.shop:id/${id}`,
+        text,
+    }),
+    image: (index, id, description, bounds) => androidNode('android.widget.ImageView', index, bounds, {
+        'resource-id': `com.example.shop:id/${id}`,
+        'content-desc': description,
+    }),
+    /** A clickable row holding other elements, as list rows and compound buttons are. */
+    row: (index, id, bounds, children) => androidNode('android.widget.LinearLayout', index, bounds, { 'resource-id': `com.example.shop:id/${id}`, clickable: 'true', focusable: 'true' }, children),
+    layout: (index, id, bounds, children) => androidNode('android.widget.LinearLayout', index, bounds, { 'resource-id': id ? `com.example.shop:id/${id}` : '' }, children),
+    page: (children) => "<?xml version='1.0' encoding='UTF-8' standalone='yes' ?>" +
+        '<hierarchy index="0" class="hierarchy" rotation="0" width="1080" height="2220">' +
+        androidNode('android.widget.FrameLayout', 0, '[0,0][1080,2220]', {}, children) +
+        '</hierarchy>',
+};
+function iosNode(type, a, children = '') {
+    return `<${type} ${attrs(Object.assign({ type, enabled: 'true', visible: 'true', accessible: 'true' }, a))}>${children}</${type}>`;
+}
+exports.ios = {
+    button: (name, label, y) => iosNode('XCUIElementTypeButton', { name, label, x: 20, y, width: 350, height: 44 }),
+    field: (name, value, y) => iosNode('XCUIElementTypeTextField', { name, value, x: 20, y, width: 350, height: 44 }),
+    group: (children) => iosNode('XCUIElementTypeOther', { x: 0, y: 100, width: 390, height: 600 }, children),
+    page: (children) => '<?xml version="1.0" encoding="UTF-8"?><AppiumAUT>' +
+        iosNode('XCUIElementTypeApplication', { name: 'Shop', label: 'Shop', x: 0, y: 0, width: 390, height: 844 }, iosNode('XCUIElementTypeWindow', { x: 0, y: 0, width: 390, height: 844 }, children)) +
+        '</AppiumAUT>',
+};
+/** The element id the fake driver gives an element: its resource-id or name. */
+function elementIdOf(el) {
+    return `el:${el.getAttribute('resource-id') || el.getAttribute('name') || el.tagName}`;
+}
+/**
+ * A driver showing `pageSource`: finds run the XPath on it and answer the
+ * first match, attributes and rects are the element's own. `show` changes the
+ * screen.
+ */
+function pageDriver(pageSource) {
+    let doc = new xmldom_1.DOMParser().parseFromString(pageSource, 'text/xml');
+    let source = pageSource;
+    const known = new Map();
+    const select = (using, value) => {
+        if (using !== 'xpath')
+            throw new Error(`unsupported locator strategy ${using}`);
+        return (0, xpath_1.select)(value, doc).filter((n) => n.nodeType === 1);
+    };
+    const ref = (el) => {
+        const id = elementIdOf(el);
+        known.set(id, el);
+        return { ELEMENT: id, [W3C_ELEMENT_KEY]: id };
+    };
+    const element = (id) => {
+        const el = known.get(id);
+        if (!el)
+            throw new Error(`no element ${id}`);
+        return el;
+    };
+    return {
+        show(next) {
+            source = next;
+            doc = new xmldom_1.DOMParser().parseFromString(next, 'text/xml');
+        },
+        getPageSource() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return source;
+            });
+        },
+        findElement(using, value) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const [first] = select(using, value);
+                if (!first) {
+                    throw Object.assign(new Error('NoSuchElement: An element could not be located'), {
+                        name: 'NoSuchElementError',
+                    });
+                }
+                return ref(first);
+            });
+        },
+        findElements(using, value) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return select(using, value).map(ref);
+            });
+        },
+        caps: { platformName: /<XCUIElementType/.test(pageSource) ? 'iOS' : 'Android' },
+        /**
+         * As the drivers answer: getAttribute(name, elementId). UiAutomator2
+         * answers String(value), so an attribute the element hasn't set is
+         * "null"; WebDriverAgent answers null.
+         */
+        getAttribute(name, id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const value = element(id).getAttribute(name);
+                if (value)
+                    return value;
+                return /<XCUIElementType/.test(source) ? null : 'null';
+            });
+        },
+        getName(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return element(id).tagName;
+            });
+        },
+        getElementRect(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const el = element(id);
+                const bounds = el.getAttribute('bounds');
+                if (bounds) {
+                    const [x1, y1, x2, y2] = ((_a = bounds.match(/\d+/g)) !== null && _a !== void 0 ? _a : []).map(Number);
+                    return { x: x1, y: y1, width: x2 - x1, height: y2 - y1 };
+                }
+                return {
+                    x: Number(el.getAttribute('x')),
+                    y: Number(el.getAttribute('y')),
+                    width: Number(el.getAttribute('width')),
+                    height: Number(el.getAttribute('height')),
+                };
+            });
+        },
+    };
+}