@xenon-device-management/xenon 1.1.0

package/lib/test/e2e/plugin-harness.js

@@ -0,0 +1,236 @@
+"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.pluginE2EHarness = pluginE2EHarness;
+const support_1 = require("appium/support");
+const get_port_1 = __importDefault(require("get-port"));
+const log_symbols_1 = require("log-symbols");
+const teen_process_1 = require("teen_process");
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const ip_1 = __importDefault(require("ip"));
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Creates hooks to install a driver and a plugin and starts an Appium server w/ the given extensions.
+ * @param {E2ESetupOpts} opts
+ * @returns {void}
+ */
+function pluginE2EHarness(opts) {
+    let { port } = opts;
+    const { appiumHome, before, after, configFile, driverSource, driverPackage, driverName, driverSpec, pluginSource, pluginPackage, pluginSpec, pluginName, host, enableGoIos, } = opts;
+    let server;
+    function goIosPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const appium_path = path_1.default.dirname(require.resolve('appium'));
+            console.log(`${log_symbols_1.info} appium_path: ${appium_path}`);
+            const node_modules_root = (yield (0, teen_process_1.exec)('npm', ['root', '-g'])).stdout.trim();
+            console.log(`${log_symbols_1.info} node_modules_root: ${node_modules_root}`);
+            const platform_name = process.platform;
+            const arch_name = process.arch;
+            const go_ios_dir = path_1.default.join(node_modules_root, 'go-ios');
+            // find ios binary matching platform name
+            let go_ios_bin = fs_1.default.readdirSync(go_ios_dir, { recursive: true }).find((item) => {
+                console.log(`${log_symbols_1.info} item: ${item}`);
+                return item.includes(platform_name);
+            });
+            console.log(`${log_symbols_1.info} platform: ${platform_name} arch: ${arch_name} go_ios_bin: ${go_ios_bin}`);
+            if (!go_ios_bin) {
+                // throw new Error(`go-ios binary not found for platform ${platform_name}`);
+                go_ios_bin = '';
+                console.log(`${log_symbols_1.warning} go-ios binary not found for platform ${platform_name}`);
+            }
+            const full_path = path_1.default.join(go_ios_dir, go_ios_bin.toString(), 'ios');
+            return full_path;
+        });
+    }
+    // return appium binary path based on APPIUM_HOME
+    function getAppiumBin() {
+        return require.resolve('appium');
+    }
+    function startPlugin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const setupAppiumHome = () => __awaiter(this, void 0, void 0, function* () {
+                /**
+                 * @type {AppiumEnv}
+                 */
+                const env = Object.assign({}, process.env);
+                if (appiumHome) {
+                    env.APPIUM_HOME = appiumHome;
+                    //env.HOME = appiumHome;
+                    yield support_1.fs.mkdirp(appiumHome);
+                    console.log(`${log_symbols_1.info} Set \`APPIUM_HOME\` to ${appiumHome}`);
+                }
+                // find go_ios from npm
+                if (enableGoIos)
+                    env.GO_IOS = yield goIosPath();
+                return env;
+            });
+            /**
+             *
+             * @param {AppiumEnv} env
+             */
+            const installDriver = (env) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const APPIUM_BIN = getAppiumBin();
+                console.log(`${log_symbols_1.info} Checking if driver "${driverName}" is installed...`);
+                const driverListArgs = [APPIUM_BIN, 'driver', 'list', '--json'];
+                console.log(`${log_symbols_1.info} Running: ${process.execPath} ${driverListArgs.join(' ')}`);
+                const { stdout: driverListJson } = yield (0, teen_process_1.exec)(process.execPath, driverListArgs, {
+                    env,
+                });
+                const installedDrivers = JSON.parse(driverListJson);
+                if (!((_a = installedDrivers[driverName]) === null || _a === void 0 ? void 0 : _a.installed)) {
+                    console.log(`${log_symbols_1.warning} Driver "${driverName}" not installed; installing...`);
+                    const driverArgs = [APPIUM_BIN, 'driver', 'install', '--source', driverSource, driverSpec];
+                    if (driverPackage) {
+                        driverArgs.push('--package', driverPackage);
+                    }
+                    console.log(`${log_symbols_1.info} Running: ${process.execPath} ${driverArgs.join(' ')}`);
+                    yield (0, teen_process_1.exec)(process.execPath, driverArgs, {
+                        env,
+                    });
+                }
+                console.log(`${log_symbols_1.success} Installed driver "${driverName}"`);
+            });
+            function removePluginFromExtensionsYaml(env) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const extensionsYaml = path_1.default.join(env.APPIUM_HOME, 'node_modules', '.cache', 'appium', 'extensions.yaml');
+                    console.log(`${log_symbols_1.info} Removing plugin "${pluginName}" from ${extensionsYaml}`);
+                    const extensions = js_yaml_1.default.load(fs_1.default.readFileSync(extensionsYaml, 'utf8'));
+                    delete extensions.plugins[pluginName];
+                    console.log(`${log_symbols_1.info} Writing back to ${extensionsYaml}`);
+                    fs_1.default.writeFileSync(extensionsYaml, js_yaml_1.default.dump(extensions));
+                });
+            }
+            /**
+             *
+             * @param {AppiumEnv} env
+             */
+            const installPlugin = (env) => __awaiter(this, void 0, void 0, function* () {
+                /*const availablePlugins = await installedPluginsByAppiumCommands(env);
+                      console.log(`${info} Available plugins: ${JSON.stringify(Object.keys(availablePlugins), null, 2)}`);
+                      const installedPlugins = Object.keys(availablePlugins).map((item) => availablePlugins[item]).filter((p: any) => p.installed);
+                      console.log(`${info} Installed plugin: ${JSON.stringify(installedPlugins, null, 2)}`);
+                      */
+                // same plugin maybe installed via different source: npm or local
+                // we don't care, just remove it and write it back to the file
+                yield removePluginFromExtensionsYaml(env);
+                // installing our version of plugin
+                const pluginArgs = [
+                    getAppiumBin(),
+                    'plugin',
+                    'install',
+                    '--source',
+                    pluginSource,
+                    pluginSpec,
+                ];
+                // only aplicable for npm
+                if (pluginPackage) {
+                    pluginArgs.push('--package', pluginPackage);
+                }
+                console.log(`${log_symbols_1.info} Installing plugin: ${process.execPath} ${pluginArgs.join(' ')}`);
+                yield (0, teen_process_1.exec)(process.execPath, pluginArgs, { env });
+                console.log(`${log_symbols_1.success} Installed plugin "${pluginName}"`);
+            });
+            const createServer = () => __awaiter(this, void 0, void 0, function* () {
+                if (!port) {
+                    port = yield (0, get_port_1.default)();
+                }
+                console.log(`${log_symbols_1.info} Will use port ${port} for Appium server`);
+                // here we are using CLI (instead of AppiumServer) to prevent schema conflicts
+                yield runAppiumServerFromCli(env, [pluginName], [driverName], configFile);
+                // use axios to wait until port is returning 200 OK
+                console.log(`${log_symbols_1.info} Waiting for Appium server to be ready...`);
+            });
+            function runAppiumServerFromCli(env_1) {
+                return __awaiter(this, arguments, void 0, function* (env, usePlugins = [], useDrivers = [], configFile = '') {
+                    /**
+                           example:
+                           appium server -ka 800 \
+                              --use-plugins=xenon,appium-dashboard  \
+                              --relaxed-security \
+                              --allow-insecure chromedriver_autodownload,execute_driver_script,adb_shell \
+                              --config ./hub-config.json \
+                              -pa /wd/hub
+                           */
+                    const APPIUM_BIN = getAppiumBin();
+                    const serverArgs = [APPIUM_BIN, 'server', '-ka', '800'];
+                    if (usePlugins.length > 0) {
+                        serverArgs.push(`--use-plugins=${usePlugins.join(',')}`);
+                    }
+                    if (useDrivers.length > 0) {
+                        serverArgs.push(`--use-drivers=${useDrivers.join(',')}`);
+                    }
+                    if (configFile) {
+                        serverArgs.push(`--config=${configFile}`);
+                    }
+                    console.log(`APPIUM_HOME=${env.APPIUM_HOME} GO_IOS=${env.GO_IOS}`);
+                    console.log(`${log_symbols_1.info} Running: ${process.execPath} ${serverArgs.join(' ')}`);
+                    (0, teen_process_1.exec)(process.execPath, serverArgs, {
+                        env,
+                    });
+                    return waitServer(host !== null && host !== void 0 ? host : ip_1.default.address(), port !== null && port !== void 0 ? port : 4723, 60);
+                });
+            }
+            // Use axios to hit appium endpoint until it returns 200 OK
+            function waitServer(host, port, timeoutSeconds) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    // const basePath = serverArgs.basePath || '';
+                    const url = `http://${host}:${port}/status`;
+                    const timeout = timeoutSeconds * 1000;
+                    const start = Date.now();
+                    while (Date.now() - start < timeout) {
+                        try {
+                            yield axios_1.default.get(url);
+                            return;
+                        }
+                        catch (ign) {
+                            // ignore
+                            console.log(`${log_symbols_1.info} url: ${url} error: ${ign.message}`);
+                        }
+                        yield new Promise((resolve) => setTimeout(resolve, 1000));
+                    }
+                    throw new Error(`Appium server did not start after ${timeoutSeconds} seconds`);
+                });
+            }
+            const env = yield setupAppiumHome();
+            yield installDriver(env);
+            yield installPlugin(env);
+            yield createServer();
+        });
+    }
+    function stopPlugin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (server) {
+                yield server.close();
+            }
+        });
+    }
+    // clean it after test
+    after(stopPlugin);
+    // have an option to start the plugin before the test manually
+    // this is useful to start multiple plugins in a single test
+    if (before) {
+        console.log("Adding plugin startup into mocha's before hook");
+        before(startPlugin);
+    }
+    else {
+        console.log(`Please start plugin ${pluginName} manually using "startPlugin()" function`);
+    }
+    return {
+        startPlugin,
+        stopPlugin,
+    };
+}

package/lib/test/e2e/plugin.spec.js

@@ -0,0 +1,97 @@
+"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 });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const NodeDevices_1 = __importDefault(require("../../src/device-managers/NodeDevices"));
+const chai_1 = __importDefault(require("chai"));
+chai_1.default.should();
+const chai_2 = require("chai");
+const axios_1 = __importDefault(require("axios"));
+const e2ehelper_1 = require("./e2ehelper");
+const plugin_test_support_1 = require("@appium/plugin-test-support");
+const ip_1 = __importDefault(require("ip"));
+const db_1 = require("../../src/data-service/db");
+describe('Basic Plugin Test', () => {
+    // dump hub config into a file
+    const hub_config_file = (0, e2ehelper_1.ensureHubConfig)();
+    // dump node config into a file
+    (0, e2ehelper_1.ensureNodeConfig)();
+    // setup appium home
+    const APPIUM_HOME = (0, e2ehelper_1.ensureAppiumHome)();
+    // run hub
+    (0, plugin_test_support_1.pluginE2EHarness)({
+        before: global.before,
+        after: global.after,
+        serverArgs: {
+            subcommand: 'server',
+            configFile: hub_config_file,
+        },
+        pluginName: 'xenon',
+        port: e2ehelper_1.HUB_APPIUM_PORT,
+        driverSource: 'npm',
+        driverName: 'uiautomator2',
+        driverSpec: 'appium-uiautomator2-driver',
+        pluginSource: 'local',
+        pluginSpec: e2ehelper_1.PLUGIN_PATH,
+        appiumHome: APPIUM_HOME,
+    });
+    const hub_url = `http://${ip_1.default.address()}:${e2ehelper_1.HUB_APPIUM_PORT}`;
+    it('Basic Plugin test', () => __awaiter(void 0, void 0, void 0, function* () {
+        (yield axios_1.default.get(`${hub_url}/xenon`)).status.should.eql(200);
+    }));
+    it('Basic Plugin API test', () => __awaiter(void 0, void 0, void 0, function* () {
+        (yield axios_1.default.get(`${hub_url}/xenon/api/device`)).status.should.eql(200);
+    }));
+    it('Add Android devices from node to hub', () => __awaiter(void 0, void 0, void 0, function* () {
+        (yield db_1.XenonDatabase.DeviceModel).removeDataOnly();
+        const nodeAndroidDevice = [
+            {
+                adbRemoteHost: null,
+                adbPort: 5039,
+                systemPort: 58296,
+                sdk: '13',
+                realDevice: false,
+                name: 'sdk_gphone64_arm64',
+                busy: false,
+                state: 'device',
+                udid: 'emulator-5551',
+                platform: 'android',
+                deviceType: 'emulator',
+                host: 'http://127.2.1.41:4723',
+                totalUtilizationTimeMilliSec: 7023014,
+                sessionStartTime: 0,
+            },
+        ];
+        const nodeDevices = new NodeDevices_1.default(hub_url);
+        yield nodeDevices.postDevicesToHub(nodeAndroidDevice, 'add');
+        const devices = (yield axios_1.default.get(`${hub_url}/xenon/api/device`)).data;
+        devices.find((d) => d.udid === 'emulator-5551').should.to.be.an('object');
+        nodeAndroidDevice[0].udid = 'emulator-5552';
+        yield nodeDevices.postDevicesToHub(nodeAndroidDevice, 'add');
+        const updatedDeviceList = (yield axios_1.default.get(`${hub_url}/xenon/api/device`)).data;
+        //updatedDeviceList.should.have.lengthOf(2);
+        updatedDeviceList.find((d) => d.udid === 'emulator-5552').should.to.be.an('object');
+    }));
+    it('Remove Android devices from node to hub', () => __awaiter(void 0, void 0, void 0, function* () {
+        const nodeDevices = new NodeDevices_1.default(hub_url);
+        const devices = (yield axios_1.default.get(`${hub_url}/xenon/api/device`)).data;
+        const exptectedDevice = devices.find((d) => d.udid === 'emulator-5551');
+        devices.find((d) => d.udid === 'emulator-5551').should.to.be.an('object');
+        console.log('devices', exptectedDevice);
+        yield nodeDevices.postDevicesToHub([{ udid: 'emulator-5551', host: '127.2.1.41' }], 'remove');
+        const updatedDeviceList = (yield axios_1.default.get(`${hub_url}/xenon/api/device`)).data;
+        const find = updatedDeviceList.find((d) => d.udid === 'emulator-5551');
+        (0, chai_2.expect)(find).to.be.undefined;
+    }));
+});

package/lib/test/e2e/telemetry_verification.spec.js

@@ -0,0 +1,83 @@
+"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 });
+const chai_1 = __importDefault(require("chai"));
+chai_1.default.should();
+const chai_2 = require("chai");
+const e2ehelper_1 = require("./e2ehelper");
+const plugin_test_support_1 = require("@appium/plugin-test-support");
+const ip_1 = __importDefault(require("ip"));
+const webdriverio_1 = require("webdriverio");
+const prisma_1 = require("../../src/prisma");
+describe('Performance Telemetry Verification', () => {
+    const APPIUM_HOME = (0, e2ehelper_1.ensureAppiumHome)('telemetry-verify', true);
+    const hub_config_file = (0, e2ehelper_1.ensureHubConfig)('android', 'both', 'both', {
+        enableDashboard: true,
+    });
+    (0, plugin_test_support_1.pluginE2EHarness)({
+        before: global.before,
+        after: global.after,
+        serverArgs: {
+            subcommand: 'server',
+            configFile: hub_config_file,
+        },
+        pluginName: 'xenon',
+        port: e2ehelper_1.HUB_APPIUM_PORT,
+        driverSource: 'npm',
+        driverName: 'fake',
+        driverSpec: 'appium-fake-driver',
+        pluginSource: 'local',
+        pluginSpec: e2ehelper_1.PLUGIN_PATH,
+        appiumHome: APPIUM_HOME,
+    });
+    const hub_url = `http://${ip_1.default.address()}:${e2ehelper_1.HUB_APPIUM_PORT}`;
+    it('Should capture duration and OTel metadata for commands', () => __awaiter(void 0, void 0, void 0, function* () {
+        const driver = yield (0, webdriverio_1.remote)({
+            protocol: 'http',
+            hostname: ip_1.default.address(),
+            port: e2ehelper_1.HUB_APPIUM_PORT,
+            path: '/wd/hub',
+            capabilities: {
+                platformName: 'Android',
+                'appium:automationName': 'fake',
+                'appium:deviceName': 'FakeDevice',
+                'xe:enable_dashboard': true,
+            },
+        });
+        try {
+            yield driver.getTitle();
+            yield driver.$('//button').click();
+            // Give some time for background persistence
+            yield new Promise((r) => setTimeout(r, 1000));
+            const sessionLogs = yield prisma_1.prisma.sessionLog.findMany({
+                where: { session_id: driver.sessionId },
+                orderBy: { createdAt: 'desc' },
+            });
+            console.log(`Found ${sessionLogs.length} logs for session ${driver.sessionId}`);
+            sessionLogs.forEach((log) => {
+                console.log(`Command: ${log.command_name}, Duration: ${log.duration}ms, SpanID: ${log.span_id}`);
+                // Assertions
+                (0, chai_2.expect)(log.span_id).to.not.be.null;
+                (0, chai_2.expect)(log.trace_id).to.not.be.null;
+                if (log.command_name !== 'createSession' && log.command_name !== 'deleteSession') {
+                    (0, chai_2.expect)(log.duration).to.be.a('number').and.at.least(0);
+                }
+            });
+            (0, chai_2.expect)(sessionLogs.length).to.be.at.least(2);
+        }
+        finally {
+            yield driver.deleteSession();
+        }
+    }));
+});

package/lib/test/e2e/video-recording-test.spec.js

@@ -0,0 +1,63 @@
+"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 });
+const webdriverio_1 = require("webdriverio");
+/**
+ * Test to verify video recording functionality
+ * This test enables video recording and verifies that the video_recording field is populated in the database
+ */
+const APPIUM_HOST = 'localhost';
+const APPIUM_PORT = 4723;
+const WDIO_PARAMS = {
+    connectionRetryCount: 5,
+    hostname: APPIUM_HOST,
+    port: APPIUM_PORT,
+    path: '/wd/hub/',
+    logLevel: 'info',
+};
+const capabilities = {
+    platformName: 'iOS',
+    'appium:automationName': 'XCUITest',
+    'appium:iPhoneOnly': true,
+    'appium:app': 'https://github.com/AppiumTestDistribution/appium-demo/blob/main/vodqa.zip?raw=true',
+    // Note: record_video is now enabled by default, can be set to false to disable
+    // record_video: false, // Uncomment to disable video recording
+    video_resolution: '1280x720',
+    name: 'Video Recording Test',
+    build: 'video-recording-test-build',
+};
+describe('Video Recording Test', () => {
+    let driver;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        driver = yield (0, webdriverio_1.remote)(Object.assign(Object.assign({}, WDIO_PARAMS), { capabilities }));
+    }));
+    it('should record video during test', () => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('✅ Session created - video recording should be enabled');
+        // Perform some basic interactions
+        try {
+            yield driver.$('~login').click();
+            console.log('✅ Clicked login button');
+        }
+        catch (e) {
+            console.log('ℹ️ Could not click login button (element may not exist in test environment)');
+        }
+        // Wait a bit to ensure video is being recorded
+        yield driver.pause(2000);
+        console.log('✅ Test paused for 2 seconds - video should be recording');
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('🟢 Deleting session - video should be stopped and saved');
+        yield driver.deleteSession();
+        console.log('✅ Session deleted');
+        // Give the server a moment to process the video
+        yield new Promise((resolve) => setTimeout(resolve, 1000));
+    }));
+});

package/lib/test/helpers/test-container.js

@@ -0,0 +1,112 @@
+"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.setupTestContainer = setupTestContainer;
+exports.createTestAndroidManager = createTestAndroidManager;
+exports.createTestIOSManager = createTestIOSManager;
+exports.createTestXenonManager = createTestXenonManager;
+exports.resetTestContainer = resetTestContainer;
+require("reflect-metadata");
+const typedi_1 = require("typedi");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const uuid_1 = require("uuid");
+const db_1 = require("../../src/data-service/db");
+const device_store_1 = require("../../src/data-service/device-store");
+const AndroidDeviceManager_1 = __importDefault(require("../../src/device-managers/AndroidDeviceManager"));
+const IOSDeviceManager_1 = __importDefault(require("../../src/device-managers/IOSDeviceManager"));
+const device_managers_1 = require("../../src/device-managers");
+const sinon_1 = __importDefault(require("sinon"));
+const IOSDiscoveryService_1 = require("../../src/device-managers/ios/IOSDiscoveryService");
+const sandbox = sinon_1.default.createSandbox();
+/**
+ * Test utility to initialize the TypeDI Container with a PluginContext
+ * configured for testing purposes.
+ */
+function setupTestContainer(overrides) {
+    // Reset container to ensure clean state between tests
+    typedi_1.Container.reset();
+    const nodeId = (0, uuid_1.v4)();
+    const port = 4723;
+    const pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs, overrides || {});
+    // Mock LocalStorage
+    typedi_1.Container.set('LocalStorage', {
+        getItem: (key) => null,
+        setItem: (key, value) => { },
+        removeItem: (key) => { },
+    });
+    // Initialize PluginContext
+    const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+    context.setContext(pluginArgs, port, nodeId, '');
+    // Get managers (they'll use the PluginContext via DI)
+    const androidManager = typedi_1.Container.get(AndroidDeviceManager_1.default);
+    const iosManager = typedi_1.Container.get(IOSDeviceManager_1.default);
+    const xenonManager = typedi_1.Container.get(device_managers_1.XenonManager);
+    return {
+        context,
+        androidManager,
+        iosManager,
+        xenonManager,
+        nodeId,
+        port,
+    };
+}
+/**
+ * Creates a mock PluginContext and AndroidDeviceManager for unit testing.
+ * Use this when you need to stub/spy on the manager.
+ */
+function createTestAndroidManager(pluginArgs) {
+    const { androidManager } = setupTestContainer(pluginArgs);
+    return androidManager;
+}
+/**
+ * Creates a mock PluginContext and IOSDeviceManager for unit testing.
+ */
+function createTestIOSManager(pluginArgs) {
+    const { iosManager } = setupTestContainer(pluginArgs);
+    return iosManager;
+}
+/**
+ * Creates a XenonManager configured for testing.
+ */
+function createTestXenonManager(pluginArgs) {
+    const { xenonManager } = setupTestContainer(pluginArgs);
+    xenonManager.init();
+    return xenonManager;
+}
+function resetTestContainer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        sandbox.restore();
+        typedi_1.Container.reset();
+        // Stub discovery methods to prevent background pollution
+        sandbox.stub(AndroidDeviceManager_1.default.prototype, 'getDevices').resolves([]);
+        sandbox.stub(IOSDiscoveryService_1.IOSDiscoveryService.prototype, 'getDevices').resolves([]);
+        // @ts-ignore - Stubbing internal methods to be extra safe
+        sandbox.stub(AndroidDeviceManager_1.default.prototype, 'fetchAndroidDevices').resolves([]);
+        // @ts-ignore
+        sandbox.stub(IOSDiscoveryService_1.IOSDiscoveryService.prototype, 'fetchLocalIOSDevices').resolves([]);
+        // @ts-ignore
+        sandbox.stub(IOSDiscoveryService_1.IOSDiscoveryService.prototype, 'fetchLocalSimulators').resolves([]);
+        // Clear DeviceStoreFactory static caches to prevent cross-test pollution
+        // @ts-ignore - Accessing private static members for test cleanup
+        device_store_1.DeviceStoreFactory._deviceStore = undefined;
+        // @ts-ignore
+        device_store_1.DeviceStoreFactory._pendingSessionStore = undefined;
+        // @ts-ignore
+        device_store_1.DeviceStoreFactory._cliArgsStore = undefined;
+        // @ts-ignore
+        device_store_1.DeviceStoreFactory._healEtalonStore = undefined;
+        yield db_1.XenonDatabase.reset();
+    });
+}