mobile-debug-mcp 0.26.5 → 0.28.0

package/test/unit/interact/verification_stabilization.test.ts

@@ -0,0 +1,94 @@
+import assert from 'assert'
+import { ToolsInteract } from '../../../src/interact/index.js'
+import * as Observe from '../../../src/observe/index.js'
+
+async function run() {
+  console.log('Starting verification stabilization unit tests...')
+
+  const originalGetUITreeHandler = (Observe as any).ToolsObserve.getUITreeHandler
+
+  try {
+    let visibilityCalls = 0
+    ;(Observe as any).ToolsObserve.getUITreeHandler = async () => {
+      visibilityCalls++
+      const visible = visibilityCalls >= 3
+      return {
+        device: { platform: 'android', id: 'mock-device', osVersion: '14', model: 'Pixel', simulator: true },
+        captured_at_ms: Date.now(),
+        resolution: { width: 1080, height: 2400 },
+        elements: [
+          {
+            text: visible ? 'Ready' : 'Loading',
+            contentDescription: null,
+            type: 'android.widget.TextView',
+            resourceId: 'ready_label',
+            clickable: false,
+            enabled: true,
+            visible,
+            bounds: [0, 0, 120, 40]
+          }
+        ]
+      }
+    }
+
+    const visibleResult = await ToolsInteract.waitForUIHandler({
+      selector: { text: 'Ready' },
+      condition: 'visible',
+      timeout_ms: 600,
+      poll_interval_ms: 50,
+      platform: 'android'
+    })
+
+    assert.strictEqual(visibleResult.status, 'success')
+    assert.ok(visibilityCalls >= 4, 'visibility should be confirmed across consecutive reads')
+
+    let stateCalls = 0
+    ;(Observe as any).ToolsObserve.getUITreeHandler = async () => {
+      stateCalls++
+      const value = stateCalls >= 3 ? 30 : 10
+      const stale = stateCalls === 2
+      return {
+        device: { platform: 'android', id: 'mock-device', osVersion: '14', model: 'Pixel', simulator: true },
+        captured_at_ms: stale ? Date.now() - 1000 : Date.now(),
+        resolution: { width: 1080, height: 2400 },
+        elements: [
+          {
+            text: 'Volume',
+            contentDescription: null,
+            type: 'android.widget.SeekBar',
+            resourceId: 'volume_slider',
+            clickable: true,
+            enabled: true,
+            visible: true,
+            bounds: [0, 0, 240, 40],
+            state: {
+              value,
+              raw_value: value,
+              value_range: { min: 0, max: 100 }
+            }
+          }
+        ]
+      }
+    }
+
+    const stateResult = await ToolsInteract.expectStateHandler({
+      selector: { text: 'Volume' },
+      property: 'value',
+      expected: 30,
+      platform: 'android'
+    })
+
+    assert.strictEqual(stateResult.success, true)
+    assert.strictEqual(stateResult.reason, 'value matches expected value')
+    assert.ok(stateCalls >= 4, 'state verification should require stable fresh reads')
+
+    console.log('verification stabilization unit tests passed')
+  } finally {
+    ;(Observe as any).ToolsObserve.getUITreeHandler = originalGetUITreeHandler
+  }
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/server/common.test.ts

@@ -1,5 +1,6 @@
 import assert from 'assert'
-import { requireBooleanArg } from '../../../src/server/common.js'
+import { createTraceStep } from '../../../src/server/common.js'
+import { buildActionExecutionResult, inferGenericFailure, requireBooleanArg } from '../../../src/server/common.js'
 
 function run() {
   assert.strictEqual(requireBooleanArg({ exact: true }, 'exact'), true)
@@ -7,6 +8,64 @@ function run() {
   assert.throws(() => requireBooleanArg({}, 'exact'), /Missing or invalid boolean argument: exact/)
   assert.throws(() => requireBooleanArg({ exact: 'true' as unknown as boolean }, 'exact'), /Missing or invalid boolean argument: exact/)
 
+  assert.deepStrictEqual(inferGenericFailure('semantic mismatch between inferred and raw state'), {
+    failureCode: 'SEMANTIC_MISMATCH',
+    retryable: false
+  })
+
+  const recoveryResult = buildActionExecutionResult({
+    actionType: 'tap',
+    sourceModule: 'server',
+    selector: { x: 10, y: 20 },
+    success: false,
+    uiFingerprintBefore: 'fp_before',
+    uiFingerprintAfter: 'fp_after',
+    failure: { failureCode: 'SEMANTIC_MISMATCH', retryable: false }
+  })
+  assert.strictEqual(recoveryResult.failure_code, 'SEMANTIC_MISMATCH')
+  assert.strictEqual(recoveryResult.recovery?.failure_class, 'SemanticMismatchFailure')
+  assert.strictEqual(recoveryResult.recovery?.runtime_code, 'SEMANTIC_MISMATCH')
+  assert.strictEqual(recoveryResult.recovery?.retry_allowed, false)
+  assert.strictEqual(recoveryResult.recovery?.max_recovery_attempts, 3)
+  assert.strictEqual(recoveryResult.recovery?.max_retry_depth, 3)
+  assert.strictEqual(recoveryResult.trace.final_outcome, 'failure')
+  assert.strictEqual(recoveryResult.trace.steps.at(-1)?.stage, 'recover')
+
+  const notInteractableResult = buildActionExecutionResult({
+    actionType: 'tap',
+    sourceModule: 'server',
+    selector: { x: 5, y: 5 },
+    success: false,
+    uiFingerprintBefore: 'fp_before',
+    uiFingerprintAfter: 'fp_after',
+    failure: { failureCode: 'ELEMENT_NOT_INTERACTABLE', retryable: true }
+  })
+  assert.strictEqual(notInteractableResult.failure_code, 'ELEMENT_NOT_INTERACTABLE')
+  assert.strictEqual(notInteractableResult.recovery?.failure_class, 'ExecutionFailure')
+  assert.strictEqual(notInteractableResult.recovery?.runtime_code, 'ELEMENT_NOT_INTERACTABLE')
+  assert.strictEqual(notInteractableResult.recovery?.retry_allowed, true)
+  assert.strictEqual(notInteractableResult.trace.steps[0].stage, 'resolve')
+  assert.strictEqual(notInteractableResult.trace.steps[0].result, 'failure')
+  assert.strictEqual(notInteractableResult.trace.steps.at(-1)?.stage, 'recover')
+
+  const traceSteps = [
+    createTraceStep({ stage: 'resolve', timestamp: 100, result: 'success', attemptIndex: 0 }),
+    createTraceStep({ stage: 'execute', timestamp: 200, result: 'retry', attemptIndex: 1 }),
+    createTraceStep({ stage: 'verify', timestamp: 300, result: 'success', attemptIndex: 2 })
+  ]
+  const tracedResult = buildActionExecutionResult({
+    actionType: 'tap',
+    sourceModule: 'server',
+    selector: { x: 1, y: 1 },
+    success: true,
+    uiFingerprintBefore: 'before',
+    uiFingerprintAfter: 'after',
+    details: { attempts: 3 },
+    traceSteps
+  })
+  assert.deepStrictEqual(tracedResult.trace.steps, traceSteps)
+  assert.strictEqual(tracedResult.trace.attempts, 3)
+
   console.log('server common tests passed')
 }