@xenon-device-management/xenon 1.17.5 → 1.18.0

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xenon-device-management/xenon",
-    "version": "1.17.5",
+    "version": "1.18.0",
     "description": "Xenon - Intelligent Mobile Infrastructure. A self-healing device orchestration platform for Appium.",
     "main": "./lib/src/index.js",
     "exports": {

package/lib/src/services/InspectorService.js

@@ -432,28 +432,46 @@ let InspectorService = class InspectorService {
                 score: 95,
             });
         }
+        // On iOS `node.text` is `label || value`, so every locator that selects on
+        // it — predicate and xpath alike — has to name whichever of the two
+        // actually supplied it. Hardcoding `label` sends a page indicator, whose
+        // text lives in `value`, to a predicate that matches nothing.
+        const iosTextAttr = asText(node.attributes.label) === node.text ? 'label' : 'value';
         // 3. Platform Specific - Performance Tier
         if (platform === 'ios') {
             // iOS Predicate String - High Performance
-            const predicate = `type == "${node.type}" AND label == "${node.text || node.label || ''}"`;
+            const predicateValue = node.text || node.label || '';
             if (node.text || node.label) {
                 suggestions.push({
                     strategy: '-ios predicate string',
-                    value: predicate,
-                    unique: true,
+                    value: `type == "${node.type}" AND ${iosTextAttr} == "${predicateValue}"`,
+                    // A compound predicate is at least as selective as its label term, so
+                    // a unique label makes it unique. The converse does not hold — two
+                    // elements sharing a label may differ by type — which makes this
+                    // conservative rather than exact, and that is the right direction:
+                    // it was previously hardcoded true, and a predicate badged unique
+                    // was measured against a real device matching two elements.
+                    unique: this.isUnique(uniqueness, 'text', predicateValue),
                     score: 90,
                 });
             }
             // iOS Class Chain - High Precision
-            const classChain = `**/${node.type}[` +
-                (node.attributes.name
-                    ? `name == "${node.attributes.name}"`
-                    : `label == "${node.text || ''}"`) +
-                ']';
+            //
+            // The predicate MUST be wrapped in backticks. Without them Appium
+            // resolves nothing at all: measured against a real iPhone,
+            // `**/XCUIElementTypePageIndicator[name == "Page control"]` found 0
+            // elements and the same chain with backticks found 1. Every class chain
+            // this service produced was unusable, and each was badged unique — 280
+            // of them in a single snapshot of a home screen.
+            const chainValue = node.attributes.name ? String(node.attributes.name) : node.text || '';
+            const chainTerm = node.attributes.name ? 'name' : 'label';
             suggestions.push({
                 strategy: '-ios class chain',
-                value: classChain,
-                unique: true,
+                value: `**/${node.type}[\`${chainTerm} == "${chainValue}"\`]`,
+                // Same index the accessibility-id suggestion uses, and the same value:
+                // a node's identity there is `name || label`, which is exactly what
+                // the chain selects on.
+                unique: this.isUnique(uniqueness, 'accessibility id', chainValue),
                 score: 85,
             });
         }
@@ -495,9 +513,15 @@ let InspectorService = class InspectorService {
             });
         }
         else if (node.text) {
+            // `@text` is an Android attribute. An XCUIElement has name, label and
+            // value and no text at all, so every iOS suggestion in this shape
+            // resolved to nothing: measured on a real iPhone,
+            // `//XCUIElementTypePageIndicator[@text="Page control"]` found 0 and the
+            // same path with `@label` found 1.
+            const textAttr = platform === 'ios' ? iosTextAttr : 'text';
             suggestions.push({
                 strategy: 'xpath',
-                value: `//${tagName}[@text="${node.text}"]`,
+                value: `//${tagName}[@${textAttr}="${node.text}"]`,
                 unique: this.isUnique(uniqueness, 'text', node.text),
                 score: 60,
             });

package/lib/test/unit/inspector-hierarchy.spec.js

@@ -197,6 +197,61 @@ describe('InspectorService hierarchy parsing', () => {
             (0, chai_1.expect)(root.name).to.equal('1');
         });
     });
+    describe('iOS locator syntax', () => {
+        // Two StaticTexts share the label "Done" and neither has a name, so both a
+        // predicate and a class chain built from that label are genuinely
+        // ambiguous. The button carries a name and is genuinely unique. The text
+        // field has a value and no label.
+        const XML = `<AppiumAUT>
+      <XCUIElementTypeApplication type="XCUIElementTypeApplication" name="MyApp" label="MyApp" x="0" y="0" width="390" height="844">
+        <XCUIElementTypeButton type="XCUIElementTypeButton" name="done-btn" label="Save" x="0" y="0" width="10" height="10" />
+        <XCUIElementTypeStaticText type="XCUIElementTypeStaticText" label="Done" x="0" y="20" width="10" height="10" />
+        <XCUIElementTypeStaticText type="XCUIElementTypeStaticText" label="Done" x="0" y="30" width="10" height="10" />
+        <XCUIElementTypeTextField type="XCUIElementTypeTextField" value="typed text" x="0" y="40" width="10" height="10" />
+      </XCUIElementTypeApplication>
+    </AppiumAUT>`;
+        const root = () => parse(XML, 'ios');
+        const byType = (t) => find(root(), (n) => n.type === t)[0];
+        it('wraps the class chain predicate in backticks', () => {
+            // Measured on a real iPhone: without backticks Appium resolves 0
+            // elements, with them it resolves 1. Every chain this produced was
+            // unusable — 280 of them in one home-screen snapshot.
+            (0, chai_1.expect)(locator(byType('XCUIElementTypeButton'), '-ios class chain').value).to.equal('**/XCUIElementTypeButton[`name == "done-btn"`]');
+        });
+        it('selects on label in the class chain when there is no name', () => {
+            (0, chai_1.expect)(locator(byType('XCUIElementTypeStaticText'), '-ios class chain').value).to.equal('**/XCUIElementTypeStaticText[`label == "Done"`]');
+        });
+        it('uses an attribute an XCUIElement actually has in xpath', () => {
+            // `@text` is Android's. iOS has name, label and value — and `@text`
+            // resolved to nothing on a real device.
+            const xpath = locator(byType('XCUIElementTypeStaticText'), 'xpath').value;
+            (0, chai_1.expect)(xpath).to.equal('//XCUIElementTypeStaticText[@label="Done"]');
+            (0, chai_1.expect)(xpath).to.not.contain('@text');
+        });
+        it('names value rather than label when value is what supplied the text', () => {
+            (0, chai_1.expect)(locator(byType('XCUIElementTypeTextField'), 'xpath').value).to.equal('//XCUIElementTypeTextField[@value="typed text"]');
+        });
+        it('names the same attribute in the predicate as in the xpath', () => {
+            // A page indicator carries its text in `value` and has no label at all.
+            // The predicate hardcoded `label ==`, so it matched nothing — measured
+            // against a real iPhone as the last surviving miss after the other
+            // fixes landed.
+            const field = byType('XCUIElementTypeTextField');
+            (0, chai_1.expect)(locator(field, '-ios predicate string').value).to.equal('type == "XCUIElementTypeTextField" AND value == "typed text"');
+            (0, chai_1.expect)(locator(byType('XCUIElementTypeStaticText'), '-ios predicate string').value).to.equal('type == "XCUIElementTypeStaticText" AND label == "Done"');
+        });
+        it('stops claiming every predicate and class chain is unique', () => {
+            // Both were hardcoded true. On a real device a predicate badged unique
+            // matched two elements.
+            const shared = byType('XCUIElementTypeStaticText'); // label "Done", shared
+            (0, chai_1.expect)(locator(shared, '-ios predicate string').unique).to.equal(false);
+            (0, chai_1.expect)(locator(shared, '-ios class chain').unique).to.equal(false);
+        });
+        it('still reports a genuinely unique one as unique', () => {
+            const named = byType('XCUIElementTypeButton'); // name "done-btn", unique
+            (0, chai_1.expect)(locator(named, '-ios class chain').unique).to.equal(true);
+        });
+    });
     describe('iOS', () => {
         it('parses the XCUIElementType tree unchanged', () => {
             const root = parse(IOS_XML, 'ios');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xenon-device-management/xenon",
-  "version": "1.17.5",
+  "version": "1.18.0",
   "description": "Xenon - Intelligent Mobile Infrastructure. A self-healing device orchestration platform for Appium.",
   "main": "./lib/src/index.js",
   "exports": {