@xenon-device-management/xenon 1.1.0

package/lib/test/unit/FuzzyXmlHealingProvider.test.js

@@ -0,0 +1,294 @@
+"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 chai_1 = require("chai");
+const types_1 = require("../../src/services/healing/types");
+const FuzzyXmlHealingProvider_1 = require("../../src/services/healing/FuzzyXmlHealingProvider");
+const typedi_1 = require("typedi");
+const HealedLocatorGenerator_1 = require("../../src/services/healing/HealedLocatorGenerator");
+// Ensure DI container has the generator registered
+typedi_1.Container.set(HealedLocatorGenerator_1.HealedLocatorGenerator, new HealedLocatorGenerator_1.HealedLocatorGenerator());
+describe('FuzzyXmlHealingProvider', () => {
+    let provider;
+    let mockEtalonService;
+    // iOS page source: "Truck" button has been renamed to "Fleet"
+    const iosPageSource = `<?xml version="1.0" encoding="UTF-8"?>
+    <AppiumAUT>
+      <XCUIElementTypeApplication type="XCUIElementTypeApplication" name="Food Truck" label="Food Truck" enabled="true" visible="true" accessible="false" x="0" y="0" width="428" height="926">
+        <XCUIElementTypeWindow type="XCUIElementTypeWindow" enabled="true" visible="true" accessible="false" x="0" y="0" width="428" height="926">
+          <XCUIElementTypeOther type="XCUIElementTypeOther" enabled="true" visible="true" accessible="false" x="0" y="0" width="428" height="926">
+            <XCUIElementTypeButton type="XCUIElementTypeButton" name="Fleet" label="Fleet" enabled="true" visible="true" accessible="true" x="20" y="161" width="388" height="44" />
+            <XCUIElementTypeButton type="XCUIElementTypeButton" name="Deliveries" label="Deliveries" enabled="true" visible="true" accessible="true" x="20" y="205" width="388" height="44" />
+            <XCUIElementTypeButton type="XCUIElementTypeButton" name="Social Feed" label="Social Feed" enabled="true" visible="true" accessible="true" x="20" y="249" width="388" height="44" />
+            <XCUIElementTypeImage type="XCUIElementTypeImage" name="truck.box" label="truck.box" enabled="true" visible="true" accessible="false" x="36" y="215" width="20" height="20" />
+            <XCUIElementTypeStaticText type="XCUIElementTypeStaticText" name="Deliveries" label="Deliveries" enabled="true" visible="true" accessible="false" x="72" y="205" width="300" height="44" />
+          </XCUIElementTypeOther>
+        </XCUIElementTypeWindow>
+      </XCUIElementTypeApplication>
+    </AppiumAUT>`;
+    // Android page source: "Submit" button renamed to "Send"
+    const androidPageSource = `<?xml version="1.0" encoding="UTF-8"?>
+    <hierarchy>
+      <android.widget.FrameLayout index="0" bounds="[0,0][1080,1920]">
+        <android.widget.LinearLayout index="0" bounds="[0,0][1080,1920]">
+          <android.widget.Button index="0" text="Send" resource-id="com.example:id/submit_btn" content-desc="Send action" bounds="[48,1584][1032,1680]" />
+          <android.widget.TextView index="1" text="Hello World" bounds="[48,1700][1032,1750]" />
+          <android.widget.ImageView index="2" content-desc="Logo" bounds="[400,100][680,300]" />
+        </android.widget.LinearLayout>
+      </android.widget.FrameLayout>
+    </hierarchy>`;
+    beforeEach(() => {
+        mockEtalonService = {
+            getSignature: (_selector) => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            saveSignature: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        };
+        provider = new FuzzyXmlHealingProvider_1.FuzzyXmlHealingProvider(mockEtalonService);
+    });
+    // ============================================================
+    // TEST 1: First candidate fails, second candidate succeeds (Fallback)
+    // ============================================================
+    it('should fall back to second candidate when first candidate fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Etalon: We knew this element as "Orders" at position (20, 205)
+        mockEtalonService.getSignature = () => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                selector: " //XCUIElementTypeButton[@name='Orders']",
+                strategy: 'xpath',
+                attributes: {
+                    name: 'Orders',
+                    label: 'Orders',
+                    x: '20',
+                    y: '205',
+                    width: '388',
+                    height: '44',
+                },
+                nodeName: 'XCUIElementTypeButton',
+                lastSeen: Date.now(),
+            });
+        });
+        const triedCandidates = [];
+        const mockDriver = {
+            findElement: (_strategy, selector) => __awaiter(void 0, void 0, void 0, function* () {
+                triedCandidates.push(selector);
+                // FIRST candidate fails (simulating a locator that doesn't resolve)
+                if (triedCandidates.length === 1) {
+                    throw new Error('no such element');
+                }
+                // SECOND candidate succeeds
+                return { ELEMENT: 'healed-via-fallback-123' };
+            }),
+        };
+        const context = {
+            sessionId: 'test-session',
+            driver: mockDriver,
+            strategy: 'xpath',
+            selector: " //XCUIElementTypeButton[@name='Orders']",
+            pageSource: iosPageSource,
+        };
+        const result = yield provider.heal(context);
+        // Verify healing succeeded
+        (0, chai_1.expect)(result).to.not.be.null;
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.id).to.equal('healed-via-fallback-123');
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.tier).to.equal(types_1.HealingTier.TIER_2_FUZZY_XML);
+        // Verify that at least 2 candidates were tried (first failed, second succeeded)
+        (0, chai_1.expect)(triedCandidates.length).to.be.greaterThanOrEqual(2);
+        console.log(`    ✓ Tried ${triedCandidates.length} candidates before success:`);
+        triedCandidates.forEach((c, i) => console.log(`      ${i + 1}. ${c}`));
+    }));
+    // ============================================================
+    // TEST 2: Tag gate rejects wrong element types
+    // ============================================================
+    it('should reject wrong element types via tag gate (XCUIElementTypeImage should not match XCUIElementTypeButton)', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Etalon: We're looking for a Button
+        mockEtalonService.getSignature = () => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                selector: " //XCUIElementTypeButton[@name='Orders']",
+                strategy: 'xpath',
+                attributes: {
+                    name: 'Orders',
+                    label: 'Orders',
+                    x: '20',
+                    y: '205',
+                },
+                nodeName: 'XCUIElementTypeButton',
+                lastSeen: Date.now(),
+            });
+        });
+        let resolvedSelector = '';
+        const mockDriver = {
+            findElement: (_strategy, selector) => __awaiter(void 0, void 0, void 0, function* () {
+                resolvedSelector = selector;
+                return { ELEMENT: 'correct-button-456' };
+            }),
+        };
+        const context = {
+            sessionId: 'test-session',
+            driver: mockDriver,
+            strategy: 'xpath',
+            selector: " //XCUIElementTypeButton[@name='Orders']",
+            pageSource: iosPageSource,
+        };
+        const result = yield provider.heal(context);
+        (0, chai_1.expect)(result).to.not.be.null;
+        // The resolved element should be a Button (Deliveries), NOT an Image (truck.box)
+        if (resolvedSelector) {
+            (0, chai_1.expect)(resolvedSelector).to.not.contain('truck.box');
+            (0, chai_1.expect)(resolvedSelector).to.not.contain('XCUIElementTypeImage');
+            console.log(`    ✓ Resolved to: ${resolvedSelector} (not truck.box image)`);
+        }
+    }));
+    // ============================================================
+    // TEST 3: Spatial matching picks correct element at same position
+    // ============================================================
+    it('should select Deliveries (at Y=205) over Fleet (at Y=161) based on spatial match', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Etalon: "Orders" was at (20, 205) — Deliveries is at the same position
+        mockEtalonService.getSignature = () => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                selector: " //XCUIElementTypeButton[@name='Orders']",
+                strategy: 'xpath',
+                attributes: {
+                    name: 'Orders',
+                    label: 'Orders',
+                    x: '20',
+                    y: '205',
+                    width: '388',
+                    height: '44',
+                },
+                nodeName: 'XCUIElementTypeButton',
+                lastSeen: Date.now(),
+            });
+        });
+        let resolvedSelector = '';
+        const mockDriver = {
+            findElement: (_strategy, selector) => __awaiter(void 0, void 0, void 0, function* () {
+                resolvedSelector = selector;
+                return { ELEMENT: 'deliveries-789' };
+            }),
+        };
+        const context = {
+            sessionId: 'test-session',
+            driver: mockDriver,
+            strategy: 'xpath',
+            selector: " //XCUIElementTypeButton[@name='Orders']",
+            pageSource: iosPageSource,
+        };
+        const result = yield provider.heal(context);
+        (0, chai_1.expect)(result).to.not.be.null;
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.id).to.equal('deliveries-789');
+        // Should resolve to Deliveries, NOT Fleet
+        (0, chai_1.expect)(resolvedSelector).to.contain('Deliveries');
+        (0, chai_1.expect)(resolvedSelector).to.not.contain('Fleet');
+        console.log(`    ✓ Spatial match selected: ${resolvedSelector} (correct position)`);
+    }));
+    // ============================================================
+    // TEST 4: Android bounds format parsing works for spatial matching
+    // ============================================================
+    it('should parse Android bounds="[x1,y1][x2,y2]" format for spatial matching', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Etalon: "Submit" was at (48, 1584) on Android
+        mockEtalonService.getSignature = () => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                selector: "//android.widget.Button[@text='Submit']",
+                strategy: 'xpath',
+                attributes: {
+                    text: 'Submit',
+                    'resource-id': 'com.example:id/submit_btn',
+                    x: '48',
+                    y: '1584',
+                    width: '984',
+                    height: '96',
+                },
+                nodeName: 'android.widget.Button',
+                lastSeen: Date.now(),
+            });
+        });
+        let resolvedSelector = '';
+        const mockDriver = {
+            findElement: (_strategy, selector) => __awaiter(void 0, void 0, void 0, function* () {
+                resolvedSelector = selector;
+                return { ELEMENT: 'android-healed-101' };
+            }),
+        };
+        const context = {
+            sessionId: 'test-session',
+            driver: mockDriver,
+            strategy: 'xpath',
+            selector: "//android.widget.Button[@text='Submit']",
+            pageSource: androidPageSource,
+        };
+        const result = yield provider.heal(context);
+        (0, chai_1.expect)(result).to.not.be.null;
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.id).to.equal('android-healed-101');
+        // Should NOT match ImageView (Logo at y=100) — tag gate eliminates it
+        (0, chai_1.expect)(resolvedSelector).to.not.contain('ImageView');
+        console.log(`    ✓ Android spatial match resolved: ${resolvedSelector}`);
+    }));
+    // ============================================================
+    // TEST 5: All candidates fail returns null
+    // ============================================================
+    it('should return null when ALL candidate locators fail', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockEtalonService.getSignature = () => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                selector: " //XCUIElementTypeButton[@name='Orders']",
+                strategy: 'xpath',
+                attributes: {
+                    name: 'Orders',
+                    label: 'Orders',
+                    x: '20',
+                    y: '205',
+                },
+                nodeName: 'XCUIElementTypeButton',
+                lastSeen: Date.now(),
+            });
+        });
+        let attemptCount = 0;
+        const mockDriver = {
+            findElement: () => __awaiter(void 0, void 0, void 0, function* () {
+                attemptCount++;
+                throw new Error('no such element');
+            }),
+        };
+        const context = {
+            sessionId: 'test-session',
+            driver: mockDriver,
+            strategy: 'xpath',
+            selector: " //XCUIElementTypeButton[@name='Orders']",
+            pageSource: iosPageSource,
+        };
+        const result = yield provider.heal(context);
+        (0, chai_1.expect)(result).to.be.null;
+        // Should have tried multiple candidates before giving up
+        (0, chai_1.expect)(attemptCount).to.be.greaterThan(1);
+        console.log(`    ✓ Tried ${attemptCount} candidates, all failed → returned null correctly`);
+    }));
+    // ============================================================
+    // TEST 6: No etalon — keyword-only fallback works
+    // ============================================================
+    it('should work without etalon using keyword-only fuzzy matching', () => __awaiter(void 0, void 0, void 0, function* () {
+        // No etalon stored — pure keyword matching
+        mockEtalonService.getSignature = () => __awaiter(void 0, void 0, void 0, function* () { return null; });
+        const mockDriver = {
+            findElement: (_strategy, _selector) => __awaiter(void 0, void 0, void 0, function* () {
+                return { ELEMENT: 'keyword-match-202' };
+            }),
+        };
+        // Looking for something with "Deliveries" as a keyword
+        const context = {
+            sessionId: 'test-session',
+            driver: mockDriver,
+            strategy: 'xpath',
+            selector: "//XCUIElementTypeButton[@name='Deliveries']",
+            pageSource: iosPageSource,
+        };
+        const result = yield provider.heal(context);
+        (0, chai_1.expect)(result).to.not.be.null;
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.id).to.equal('keyword-match-202');
+        console.log(`    ✓ Keyword-only match succeeded: ${result === null || result === void 0 ? void 0 : result.recommendedSelector}`);
+    }));
+});

package/lib/test/unit/GetAdbOriginal.js

@@ -0,0 +1,42 @@
+"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.getAdbOriginal = getAdbOriginal;
+const appium_adb_1 = __importDefault(require("appium-adb"));
+function getAdbOriginal() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield appium_adb_1.default.createADB({
+            udid: null,
+            appDeviceReadyTimeout: null,
+            useKeystore: null,
+            keystorePath: null,
+            keystorePassword: null,
+            keyAlias: null,
+            keyPassword: null,
+            curDeviceId: null,
+            emulatorPort: null,
+            logcat: null,
+            instrumentProc: null,
+            suppressKillServer: null,
+            jars: {},
+            adbPort: 5037,
+            adbHost: null,
+            adbExecTimeout: 20000,
+            remoteAppsCacheLimit: 10,
+            buildToolsVersion: null,
+            allowOfflineDevices: false,
+            allowDelayAdb: true,
+        });
+    });
+}

package/lib/test/unit/HealingCascade.test.js

@@ -0,0 +1,128 @@
+"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 chai_1 = require("chai");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const types_1 = require("../../src/services/healing/types");
+const typedi_1 = require("typedi");
+const HealEtalonService_1 = require("../../src/services/healing/HealEtalonService");
+const HealedLocatorGenerator_1 = require("../../src/services/healing/HealedLocatorGenerator");
+// Mock Tesseract
+const TesseractMock = {
+    recognize: () => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            data: {
+                words: [
+                    {
+                        text: 'Login',
+                        confidence: 90,
+                        bbox: { x0: 100, y0: 100, x1: 200, y1: 150 },
+                    },
+                ],
+            },
+        });
+    }),
+};
+// We need to override the import or the class behavior for the test
+// Since OcrHealingProvider imports Tesseract directly, we'll mock the heal method for this specific test
+// to avoid complex dependency mocking of tesseract.js in a POC environment.
+describe('Healing Orchestrator - Cascade Strategy', () => {
+    let orchestrator;
+    let mockEtalonService;
+    let mockGenerator;
+    beforeEach(() => {
+        typedi_1.Container.reset();
+        mockEtalonService = {
+            getSignature: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            saveSignature: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        };
+        mockGenerator = new HealedLocatorGenerator_1.HealedLocatorGenerator();
+        typedi_1.Container.set(HealEtalonService_1.HealEtalonService, mockEtalonService);
+        typedi_1.Container.set(HealedLocatorGenerator_1.HealedLocatorGenerator, mockGenerator);
+        orchestrator = new HealingOrchestrator_1.HealingOrchestrator(mockEtalonService);
+    });
+    it('should cascade to OCR (Tier 3) when Fuzzy XML (Tier 2) fails to find a high-confidence match', () => __awaiter(void 0, void 0, void 0, function* () {
+        // 1. Setup a page source that has NO matching text or buttons for "Login"
+        // This will cause Fuzzy XML Provider to return null (or score below 0.5 threshold)
+        const emptyPageSource = '<?xml version="1.0" encoding="UTF-8"?><AppiumAUT><XCUIElementTypeWindow /></AppiumAUT>';
+        // 2. Setup a screenshot (dummy base64)
+        const dummyScreenshot = 'fake-base64-screenshot';
+        const mockDriver = {
+            getPageSource: () => __awaiter(void 0, void 0, void 0, function* () { return emptyPageSource; }),
+            getScreenshot: () => __awaiter(void 0, void 0, void 0, function* () { return dummyScreenshot; }),
+            findElements: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+            findElement: (strategy, selector) => __awaiter(void 0, void 0, void 0, function* () {
+                // If called via OCR tap-resolution predicate:
+                if (strategy === '-ios predicate string' && selector.includes('Login')) {
+                    return { ELEMENT: 'real-element-from-ocr' };
+                }
+                throw new Error('no such element');
+            }),
+        };
+        // 3. Mock the OcrHealingProvider behavior for this test to avoid Tesseract native issues
+        // We'll replace the OCR provider in the orchestrator with a mock one that succeeds
+        const ocrProvider = orchestrator.providers.find((p) => p.tier === types_1.HealingTier.TIER_3_LOCAL_OCR);
+        ocrProvider.heal = (context) => __awaiter(void 0, void 0, void 0, function* () {
+            if (context.selector.includes('Login')) {
+                return {
+                    id: 'healed-via-ocr',
+                    tier: types_1.HealingTier.TIER_3_LOCAL_OCR,
+                    confidence: 0.9,
+                    originalSelector: context.selector,
+                    recommendedSelector: 'ocr:text="Login"',
+                    rect: { x: 100, y: 100, width: 100, height: 50 },
+                };
+            }
+            return null;
+        });
+        // 4. Trigger healing for a broken "Login" button
+        const result = yield orchestrator.attemptHealing('test-session', mockDriver, 'xpath', "//XCUIElementTypeButton[@name='Login']");
+        // 5. Verification
+        (0, chai_1.expect)(result).to.not.be.null;
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.tier).to.equal(types_1.HealingTier.TIER_3_LOCAL_OCR);
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.id).to.equal('healed-via-ocr');
+        console.log(`    ✓ Cascaed successful! Fuzzy XML failed, but OCR found the element: ${(result === null || result === void 0 ? void 0 : result.message) || 'OCR result'}`);
+    }));
+    it('should continue to LLM Reasoning (Tier 5) if all preceding tiers fail', () => __awaiter(void 0, void 0, void 0, function* () {
+        const emptyPageSource = '<?xml version="1.0" encoding="UTF-8"?><AppiumAUT><XCUIElementTypeWindow /></AppiumAUT>';
+        const mockDriver = {
+            getPageSource: () => __awaiter(void 0, void 0, void 0, function* () { return emptyPageSource; }),
+            getScreenshot: () => __awaiter(void 0, void 0, void 0, function* () { return 'fake-screenshot'; }),
+            findElement: (strategy, selector) => __awaiter(void 0, void 0, void 0, function* () {
+                if (selector === '//llm-healed')
+                    return { ELEMENT: 'llm-element' };
+                throw new Error('not found');
+            }),
+        };
+        // Mock ALL providers before LLM to return null
+        orchestrator.providers.forEach((p) => {
+            if (p.tier < types_1.HealingTier.TIER_5_LLM_REASONING) {
+                p.heal = () => __awaiter(void 0, void 0, void 0, function* () { return null; });
+            }
+            else {
+                // Tier 5 Mock
+                p.heal = () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        id: 'llm-element',
+                        tier: types_1.HealingTier.TIER_5_LLM_REASONING,
+                        confidence: 0.95,
+                        originalSelector: '//broken',
+                        recommendedSelector: '//llm-healed',
+                    });
+                });
+            }
+        });
+        const result = yield orchestrator.attemptHealing('test-session', mockDriver, 'xpath', '//broken');
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.tier).to.equal(types_1.HealingTier.TIER_5_LLM_REASONING);
+        (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.id).to.equal('llm-element');
+        console.log('    ✓ Cascade reached Tier 5 (LLM) correctly');
+    }));
+});