mobile-debug-mcp 0.21.5 → 0.22.0

package/test/interact/unit/wait_for_ui.test.ts

@@ -1,76 +0,0 @@
-import { ToolsInteract } from '../../../src/interact/index.js'
-import * as Observe from '../../../src/observe/index.js'
-
-async function runTests() {
-  console.log('Starting wait_for_ui unit tests...')
-
-  const origFind = (ToolsInteract as any).findElementHandler
-  const origReadLog = (Observe as any).ToolsObserve.readLogStreamHandler
-  const origGetLogs = (Observe as any).ToolsObserve.getLogsHandler
-  const origGetFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-  const origResolveObserve = (Observe as any).ToolsObserve.resolveObserve
-  const origGetScreenFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-
-  try {
-    // Timeout / snapshot case: ensure snapshot captured when condition not met
-    const origCapture = (Observe as any).ToolsObserve.captureDebugSnapshotHandler
-    ;(Observe as any).ToolsObserve.captureDebugSnapshotHandler = async ({ reason }: any) => ({ reason, fingerprint: 'snap-123', ui_tree: null, logs: [] })
-    // make findElement always fail
-    (ToolsInteract as any).findElementHandler = async () => ({ found: false })
-    const resTimeout = await ToolsInteract.waitForUIHandler({ type: 'ui', query: 'WillNeverExist', timeoutMs: 500, pollIntervalMs: 100, platform: 'android' })
-    const okTimeout = resTimeout && !(resTimeout as any).success && (resTimeout as any).snapshot && (resTimeout as any).snapshot.fingerprint === 'snap-123' && (resTimeout as any).telemetry && (resTimeout as any).telemetry.pollCount > 0
-    console.log('Timeout Snapshot Test:', okTimeout ? 'PASS' : 'FAIL', JSON.stringify((resTimeout as any).telemetry || {}, null, 2))
-    ;(Observe as any).ToolsObserve.captureDebugSnapshotHandler = origCapture
-
-    // UI condition: findElement returns found on 2nd call
-    let calls = 0
-    ;(ToolsInteract as any).findElementHandler = async (args) => {
-      calls++
-      const query = (args && (args.query || args)) || ''
-      if (calls >= 2) return { found: true, element: { text: query } }
-      return { found: false }
-    }
-
-    const resUi = await ToolsInteract.waitForUIHandler({ type: 'ui', query: 'Generate Session', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okUi = resUi && (resUi as any).success && (resUi as any).telemetry && (resUi as any).telemetry.pollCount > 0 && (resUi as any).telemetry.timeToMatch >= 0
-    console.log('UI Test:', okUi ? 'PASS' : 'FAIL', JSON.stringify((resUi as any).telemetry || {}, null, 2))
-
-    // Log condition: stream empty, snapshot contains matching line
-    ;(Observe as any).ToolsObserve.readLogStreamHandler = async () => ({ entries: [ { message: 'nothing' } ] })
-    let glCalls = 0
-    ;(Observe as any).ToolsObserve.getLogsHandler = async () => {
-      glCalls++
-      if (glCalls === 1) return { device: {}, logs: ['INFO start'] }
-      return { device: {}, logs: ['INFO start', 'ERROR Exception occurred', 'Server: Boom'] }
-    }
-
-    const resLog = await ToolsInteract.waitForUIHandler({ type: 'log', query: 'Server', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okLog = resLog && (resLog as any).success && (resLog as any).telemetry && (resLog as any).telemetry.pollCount > 0 && (resLog as any).telemetry.matchSource === 'log-snapshot'
-    console.log('Log Test:', okLog ? 'PASS' : 'FAIL', JSON.stringify((resLog as any).telemetry || {}, null, 2))
-
-    // Screen condition: fingerprint changes after a few polls
-    let seq = ['A', 'A', 'B']
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: seq.length ? seq.shift() : null })
-    const resScreen = await ToolsInteract.waitForUIHandler({ type: 'screen', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okScreen = resScreen && (resScreen as any).success && (resScreen as any).telemetry && (resScreen as any).telemetry.matchSource === 'screen-fingerprint'
-    console.log('Screen Test:', okScreen ? 'PASS' : 'FAIL', JSON.stringify((resScreen as any).telemetry || {}, null, 2))
-
-    // Idle condition: stable fingerprints observed
-    let idleSeq = ['X', 'X', 'X']
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: idleSeq.length ? idleSeq.shift() : 'X' })
-    const resIdle = await ToolsInteract.waitForUIHandler({ type: 'idle', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okIdle = resIdle && (resIdle as any).success && (resIdle as any).telemetry && (resIdle as any).telemetry.matchSource === 'idle-stable'
-    console.log('Idle Test:', okIdle ? 'PASS' : 'FAIL', JSON.stringify((resIdle as any).telemetry || {}, null, 2))
-
-  } finally {
-    ;(ToolsInteract as any).findElementHandler = origFind
-    ;(Observe as any).ToolsObserve.readLogStreamHandler = origReadLog
-    ;(Observe as any).ToolsObserve.getLogsHandler = origGetLogs
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = origGetFp
-    ;(Observe as any).ToolsObserve.resolveObserve = origResolveObserve
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = origGetScreenFp
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = origGetScreenFp
-  }
-}
-
-runTests().catch(console.error)

package/test/interact/unit/wait_for_ui_new.test.ts

@@ -1,57 +0,0 @@
-import { ToolsInteract } from '../../../src/interact/index.js'
-import * as Observe from '../../../src/observe/index.js'
-
-async function run() {
-  console.log('Starting new wait_for_ui unit tests...')
-  const origGetUITree = (Observe as any).ToolsObserve.getUITreeHandler
-
-  try {
-    // Test 1: exact text match -> exists
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'Hello', resourceId: 'rid1', contentDescription: 'acc1', type: 'Button', bounds: [0,0,10,10], visible: true, clickable: false, enabled: true } ] })
-    const r1 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Hello' }, condition: 'exists', timeout_ms: 1000, poll_interval_ms: 50, platform: 'android' })
-    const ok1 = r1 && r1.status === 'success' && r1.matched === 1 && r1.element && r1.element.text === 'Hello'
-    console.log('Exact match exists:', ok1 ? 'PASS' : 'FAIL', JSON.stringify(r1, null, 2))
-
-    // Test 2: contains matching
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'Welcome User', resourceId: 'rid2', contentDescription: 'acc2', type: 'TextView', bounds: [0,0,50,10], visible: true } ] })
-    const r2 = await ToolsInteract.waitForUIHandler({ selector: { text: 'User', contains: true }, condition: 'exists', timeout_ms: 1000, poll_interval_ms: 50, platform: 'android' })
-    const ok2 = r2 && r2.status === 'success' && r2.matched === 1 && r2.element && r2.element.text && r2.element.text.includes('Welcome')
-    console.log('Contains match:', ok2 ? 'PASS' : 'FAIL', JSON.stringify(r2, null, 2))
-
-    // Test 3: visible condition
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'Hidden', resourceId: 'rid3', bounds: [0,0,0,0], visible: false } ] })
-    const r3 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Hidden' }, condition: 'visible', timeout_ms: 300, poll_interval_ms: 50, platform: 'android' })
-    const ok3 = r3 && r3.status === 'timeout' && r3.error && r3.error.code === 'ELEMENT_NOT_FOUND'
-    console.log('Visible negative (hidden element):', ok3 ? 'PASS' : 'FAIL', JSON.stringify(r3, null, 2))
-
-    // Test 4: clickable condition
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'TapMe', resourceId: 'rid4', bounds: [0,0,20,20], visible: true, clickable: true, enabled: true } ] })
-    const r4 = await ToolsInteract.waitForUIHandler({ selector: { text: 'TapMe' }, condition: 'clickable', timeout_ms: 1000, poll_interval_ms: 50, platform: 'android' })
-    const ok4 = r4 && r4.status === 'success' && r4.matched === 1 && r4.element && r4.element.index === 0
-    console.log('Clickable match:', ok4 ? 'PASS' : 'FAIL', JSON.stringify(r4, null, 2))
-
-    // Test 5: retry behavior - first attempt times out, second attempt succeeds
-    const start = Date.now()
-    let seqTree = async () => {
-      const now = Date.now()
-      // for first ~400ms return no elements, afterwards return match
-      if (now - start < 400) return { elements: [] }
-      return { elements: [ { text: 'Retried', resourceId: 'rid5', bounds: [0,0,10,10], visible: true } ] }
-    }
-    ;(Observe as any).ToolsObserve.getUITreeHandler = seqTree
-    const r5 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Retried' }, condition: 'exists', timeout_ms: 200, poll_interval_ms: 50, match: undefined, retry: { max_attempts: 3, backoff_ms: 150 }, platform: 'android' })
-    const ok5 = r5 && r5.status === 'success' && r5.metrics && r5.metrics.attempts >= 2
-    console.log('Retry behavior:', ok5 ? 'PASS' : 'FAIL', JSON.stringify(r5, null, 2))
-
-    // Test 6: timeout with no selector match -> correct error code
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [] })
-    const r6 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Nope' }, condition: 'exists', timeout_ms: 300, poll_interval_ms: 50, retry: { max_attempts: 1 }, platform: 'android' })
-    const ok6 = r6 && r6.status === 'timeout' && r6.error && r6.error.code === 'ELEMENT_NOT_FOUND'
-    console.log('Timeout no match:', ok6 ? 'PASS' : 'FAIL', JSON.stringify(r6, null, 2))
-
-  } finally {
-    (Observe as any).ToolsObserve.getUITreeHandler = origGetUITree
-  }
-}
-
-run().catch(err => { console.error('wait_for_ui_new tests failed:', err); process.exit(1) })

package/test/observe/device/wait_for_element_real.ts

@@ -1,3 +0,0 @@
-// wait_for_element device runner removed
-console.log('wait_for_element device test removed');
-process.exit(0);

package/test/observe/unit/get_screen_fingerprint.test.ts

@@ -1,69 +0,0 @@
-import { AndroidObserve } from '../../../src/observe/index.js'
-
-async function run() {
-  console.log('Starting get_screen_fingerprint unit tests...')
-
-  const origGet = (AndroidObserve as any).prototype.getUITree
-  const origCurrent = (AndroidObserve as any).prototype.getCurrentScreen
-
-  // Test 1: stable identical screens produce same fingerprint
-  ;(AndroidObserve as any).prototype.getUITree = async function() {
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [
-        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
-        { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' }
-      ]
-    }
-  }
-
-  ;(AndroidObserve as any).prototype.getCurrentScreen = async function() {
-    return { device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true }, package: 'com.example', activity: 'com.example.MainActivity', shortActivity: 'MainActivity' }
-  }
-
-  const ai = new AndroidObserve()
-  const a = await ai.getScreenFingerprint('mock')
-  const b = await ai.getScreenFingerprint('mock')
-  console.log('Test 1:', a.fingerprint === b.fingerprint ? 'PASS' : 'FAIL')
-
-  // Test 2: change in UI text changes fingerprint
-  ;(AndroidObserve as any).prototype.getUITree = async function() {
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [
-        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
-        { text: 'Profile', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' }
-      ]
-    }
-  }
-
-  const c = await ai.getScreenFingerprint('mock')
-  console.log('Test 2:', a.fingerprint !== c.fingerprint ? 'PASS' : 'FAIL')
-
-  // Test 3: dynamic text ignored (timestamp) should not change fingerprint
-  ;(AndroidObserve as any).prototype.getUITree = async function() {
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [
-        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
-        { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' },
-        { text: '12:34', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [900,10,1080,40], resourceId: null }
-      ]
-    }
-  }
-
-  const d = await ai.getScreenFingerprint('mock')
-  console.log('Test 3:', a.fingerprint === d.fingerprint ? 'PASS' : 'FAIL')
-
-  // Restore
-  ;(AndroidObserve as any).prototype.getUITree = origGet
-  ;(AndroidObserve as any).prototype.getCurrentScreen = origCurrent
-}
-
-run().catch(console.error)

package/test/observe/unit/ios-getlogs.test.ts

@@ -1,67 +0,0 @@
-import { iOSObserve } from '../../../src/observe/ios'
-import assert from 'assert'
-
-// Lightweight unit tests: verify predicate construction and meta extraction logic using internal functions
-// Since getLogs executes xcrun, run tests in SKIP_DEVICE_TESTS=1 environment by stubbing execCommand where possible.
-
-import * as iosUtils from '../../../src/utils/ios/utils'
-
-function stubExecCommand(original: any, expectedArgsChecker: (args: string[]) => boolean, output: string) {
-  return async function (args: string[], deviceId?: string) {
-    if (!expectedArgsChecker(args)) throw new Error('Unexpected args: ' + JSON.stringify(args))
-    return { output, device: { platform: 'ios', id: deviceId || 'booted' } }
-  }
-}
-
-describe('iOS getLogs predicate and meta', () => {
-  let obs: iOSObserve
-  beforeEach(() => {
-    obs = new iOSObserve()
-  })
-
-  it('uses simple process name predicate when appId provided', async () => {
-    const bundle = 'com.ideamechanics.modul8'
-    // stub execCommand twice: first for pgrep, second for log show
-    const pgrepOutput = '12345\n'
-    const logOutput = '2026-03-31 09:21:20.085 Module[12345:678] <Info> Modul8: Test message'
-
-    const orig = (iosUtils as any).execCommand
-    try {
-      (iosUtils as any).execCommand = stubExecCommand(orig, (args) => args.includes('pgrep'), pgrepOutput)
-      // second replacement for the log show call
-      let called = false
-      (iosUtils as any).execCommand = async function (args: string[]) {
-        if (args.includes('pgrep')) return { output: pgrepOutput, device: { platform: 'ios', id: 'booted' } }
-        if (args.includes('log') && args.includes('show')) { called = true; return { output: logOutput, device: { platform: 'ios', id: 'booted' } } }
-        throw new Error('Unexpected args: ' + JSON.stringify(args))
-      }
-
-      const res = await obs.getLogs({ appId: bundle, deviceId: 'booted' })
-      assert(res.meta.processNameUsed === 'modul8' || res.meta.processNameUsed === 'Modul8' || !!res.meta.processNameUsed)
-      assert(res.meta.detectedPid === 12345)
-      assert(res.source === 'pid')
-      assert(res.logCount === 1)
-      assert(res.logs[0].message.includes('Test message'))
-      assert(called, 'log show must have been called')
-    } finally {
-      (iosUtils as any).execCommand = orig
-    }
-  })
-
-  it('falls back to broad when no appId', async () => {
-    const logOutput = '2026-03-31 09:21:20.085 SomeOther[222:333] <Info> Other: Hello'
-    const orig = (iosUtils as any).execCommand
-    try {
-      (iosUtils as any).execCommand = async function (args: string[]) {
-        if (args.includes('log') && args.includes('show')) return { output: logOutput, device: { platform: 'ios', id: 'booted' } }
-        throw new Error('Unexpected args: ' + JSON.stringify(args))
-      }
-      const obs = new iOSObserve()
-      const res = await obs.getLogs({ deviceId: 'booted' })
-      assert(res.source === 'broad')
-      assert(res.logCount === 1)
-    } finally {
-      (iosUtils as any).execCommand = orig
-    }
-  })
-})

package/test/observe/unit/scroll_to_element.test.ts

@@ -1,129 +0,0 @@
-import { ToolsInteract } from '../../../src/interact/index.js'
-import { ToolsObserve } from '../../../src/observe/index.js'
-
-const origGet = (ToolsObserve as any).getUITreeHandler
-const origSwipe = (ToolsInteract as any).swipeHandler
-
-async function runTests() {
-  // Use a stable logger to avoid test harness replacing console.log between calls
-  console.log = (...args: any[]) => { try { process.stdout.write(args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n') } catch {} }
-  console.log('Starting tests for scroll_to_element...')
-
-  // Test 1: Element found immediately
-  console.log('\nTest 1: Element found immediately')
-  (ToolsObserve as any).getUITreeHandler = async () => ({
-    device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-    screen: '',
-    resolution: { width: 1080, height: 1920 },
-    elements: [{
-      text: 'Target',
-      type: 'Button',
-      contentDescription: null,
-      clickable: true,
-      enabled: true,
-      visible: true,
-      bounds: [0, 0, 100, 100],
-      resourceId: null
-    }]
-  })
-
-  const res1 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Target' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
-  console.log('Result:', res1.success === true ? 'PASS' : 'FAIL')
-  console.log('scrollsPerformed:', (res1 as any).scrollsPerformed)
-
-  // Test 2: Element found after scrolling
-  console.log('\nTest 2: Element found after scrolling')
-  let calls = 0
-  (ToolsObserve as any).getUITreeHandler = async () => {
-    calls++
-    if (calls < 3) {
-      return {
-        device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-        screen: '',
-        resolution: { width: 1080, height: 1920 },
-        elements: []
-      }
-    }
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [{
-        text: 'Target',
-        type: 'Button',
-        contentDescription: null,
-        clickable: true,
-        enabled: true,
-        visible: true,
-        bounds: [0, 0, 100, 100],
-        resourceId: null
-      }]
-    }
-  }
-
-  // Stub swipe so it doesn't try to call adb/idb
-  (ToolsInteract as any).swipeHandler = async () => ({ success: true })
-
-  const res2 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Target' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
-  console.log('Result:', res2.success === true ? 'PASS' : 'FAIL')
-  console.log('calls:', calls, calls >= 3 ? 'PASS' : 'FAIL')
-
-  // Test 3: UI unchanged stops early
-  console.log('\nTest 3: UI unchanged stops early')
-  (ToolsObserve as any).getUITreeHandler = async () => ({
-    device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-    screen: '',
-    resolution: { width: 1080, height: 1920 },
-    elements: []
-  })
-
-  (ToolsInteract as any).swipeHandler = async () => ({ success: true })
-
-  const res3 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Missing' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
-  console.log('Result:', res3.success === false && (res3 as any).attempts === 1 ? 'PASS' : 'FAIL')
-  console.log('Reason:', (res3 as any).reason || JSON.stringify(res3))
-
-  // Test 4: Offscreen element scrolls into view
-  console.log('\nTest 4: Offscreen element scrolls into view')
-  const ai = new (await import('../../../src/interact/index.js')).AndroidInteract()
-  const origObserveGet = ai['observe'].getUITree
-  const origAiSwipe = ai.swipe
-  let swiped = false
-  let swipeCalled = 0
-  ;(ai['observe'] as any).getUITree = async () => {
-    if (!swiped) {
-      return {
-        device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-        screen: '',
-        resolution: { width: 1080, height: 1920 },
-        elements: [ { text: null, type: 'android.view.View', resourceId: null, contentDescription: null, bounds: [0,0,1080,200], visible: true } ]
-      }
-    }
-    return {
-      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
-      screen: '',
-      resolution: { width: 1080, height: 1920 },
-      elements: [{ text: 'OffscreenTarget', type: 'android.widget.Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [100,400,300,460], resourceId: null }]
-    }
-  }
-  ;(ai as any).swipe = async () => { swipeCalled++; swiped = true; return { success: true } }
-
-  const r4 = await ai.scrollToElement({ text: 'OffscreenTarget' }, 'down', 3, 0.7, 'mock')
-  const ok4 = r4 && (r4 as any).success === true && (r4 as any).scrollsPerformed === 1 && swipeCalled === 1
-  console.log('Result:', ok4 ? 'PASS' : 'FAIL')
-  console.log('  success:', (r4 as any).success, 'scrollsPerformed:', (r4 as any).scrollsPerformed, 'swipeCalled:', swipeCalled)
-
-  ;(ai['observe'] as any).getUITree = origObserveGet
-  ;(ai as any).swipe = origAiSwipe
-
-  // Restore
-  (ToolsObserve as any).getUITreeHandler = origGet
-  ;(ToolsInteract as any).swipeHandler = origSwipe
-}
-
-// Ensure console.log is a function (some test runners replace it)
-if (typeof console.log !== 'function') {
-  console.log = (...args: any[]) => { try { process.stdout.write(args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n') } catch { /* swallow */ } }
-}
-
-runTests().catch(console.error)

package/test/observe/unit/wait_for_element_mock.ts

@@ -1,2 +0,0 @@
-// wait_for_element tests removed — tool deprecated
-console.log('wait_for_element unit tests removed');

package/test/observe/unit/wait_for_ui_edge_cases.test.ts

@@ -1,41 +0,0 @@
-import { ToolsInteract } from '../../../../src/interact/index.js'
-import * as Observe from '../../../../src/observe/index.js'
-
-async function run() {
-  console.log('Unit: wait_for_ui edge cases')
-
-  const origFind = (ToolsInteract as any).findElementHandler
-  const origFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-
-  try {
-    // 1) Immediate absence should pass for match='absent'
-    (ToolsInteract as any).findElementHandler = async () => ({ found: false })
-    const r1 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Nothing', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 200, match: 'absent', platform: 'android' })
-    console.log('Immediate absent test:', r1 && (r1 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r1 as any).poll_count, duration_ms: (r1 as any).duration_ms, stable_duration_ms: (r1 as any).stable_duration_ms, matchSource: (r1 as any).matchSource }, null, 2))
-
-    // 2) Boundary stability: condition becomes true and stays exactly long enough
-    // Use pollInterval 100ms and stability 300ms -> need ~3 consecutive trues
-    let seq2 = [false, true, true, true]
-    (ToolsInteract as any).findElementHandler = async () => ({ found: seq2.shift() ?? true })
-    const r2 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Boundary', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, match: 'present', platform: 'android' })
-    console.log('Boundary stability test:', r2 && (r2 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r2 as any).poll_count, duration_ms: (r2 as any).duration_ms, stable_duration_ms: (r2 as any).stable_duration_ms, matchSource: (r2 as any).matchSource }, null, 2))
-
-    // 3) Long flicker that never stabilizes should timeout/fail
-    // Sequence toggles true/false repeatedly
-    let seq3 = [false, true, false, true, false, true, false]
-    (ToolsInteract as any).findElementHandler = async () => ({ found: seq3.shift() ?? false })
-    const r3 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Flicker', timeoutMs: 1200, pollIntervalMs: 150, stability_ms: 400, match: 'present', platform: 'android' })
-    console.log('Long flicker timeout test:', !(r3 && (r3 as any).success) ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r3 as any).poll_count, duration_ms: (r3 as any).duration_ms, stable_duration_ms: (r3 as any).stable_duration_ms, matchSource: (r3 as any).matchSource }, null, 2))
-
-    // 4) Very short stability requirement should pass quickly
-    (ToolsInteract as any).findElementHandler = async () => ({ found: true })
-    const r4 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'ShortStable', timeoutMs: 2000, pollIntervalMs: 200, stability_ms: 50, match: 'present', platform: 'android' })
-    console.log('Short stability test:', r4 && (r4 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r4 as any).poll_count, duration_ms: (r4 as any).duration_ms, stable_duration_ms: (r4 as any).stable_duration_ms, matchSource: (r4 as any).matchSource }, null, 2))
-
-  } finally {
-    (ToolsInteract as any).findElementHandler = origFind
-    (Observe as any).ToolsObserve.getScreenFingerprintHandler = origFp
-  }
-}
-
-run().catch(e=>{ console.error(e); process.exit(1) })

package/test/observe/unit/wait_for_ui_stability.test.ts

@@ -1,30 +0,0 @@
-import { ToolsInteract } from '../../../../src/interact/index.js'
-import * as Observe from '../../../../src/observe/index.js'
-
-async function run() {
-  console.log('Unit: wait_for_ui stability behavior')
-
-  const origFind = (ToolsInteract as any).findElementHandler
-  const origFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-
-  try {
-    // Simulate UI flicker: present, absent, present, then stable
-    const seq = [false, true, false, true, true, true]
-    (ToolsInteract as any).findElementHandler = async () => ({ found: seq.shift() ?? true })
-
-    const res = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'X', timeoutMs: 5000, pollIntervalMs: 100, stability_ms: 500, platform: 'android' })
-    const ok = res && (res as any).success
-    console.log('Flicker stability test:', ok ? 'PASS' : 'FAIL', JSON.stringify((res as any).telemetry || {}, null, 2))
-
-    // Simulate immediate stable presence
-    (ToolsInteract as any).findElementHandler = async () => ({ found: true })
-    const res2 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Y', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, platform: 'android' })
-    console.log('Immediate stable test:', res2 && (res2 as any).success ? 'PASS' : 'FAIL', JSON.stringify((res2 as any).telemetry || {}, null, 2))
-
-  } finally {
-    (ToolsInteract as any).findElementHandler = origFind
-    (Observe as any).ToolsObserve.getScreenFingerprintHandler = origFp
-  }
-}
-
-run().catch(e=>{ console.error(e); process.exit(1) })

package/test/system/adb_version.test.ts

@@ -1,25 +0,0 @@
-import assert from 'assert'
-import * as androidUtils from '../../src/utils/android/utils.js'
-import * as systemStatus from '../../src/system/index.js'
-
-const origEnsure = (androidUtils as any).ensureAdbAvailable
-
-function mockEnsure(returnVal: any) {
-  (androidUtils as any).ensureAdbAvailable = () => returnVal
-}
-
-function restoreEnsure() {
-  (androidUtils as any).ensureAdbAvailable = origEnsure
-}
-
-describe('adb version parsing', () => {
-  afterEach(() => {
-    restoreEnsure()
-  })
-
-  it('uses only the first line of multi-line adb --version output', async () => {
-    mockEnsure({ adbCmd: 'adb', ok: true, version: 'Android Debug Bridge version 1.0.41\nRevision 8f3b7' })
-    const res = await systemStatus.getSystemStatus()
-    assert.strictEqual(res.adbVersion, 'Android Debug Bridge version 1.0.41')
-  })
-})

package/test/system/get_system_status.test.ts

@@ -1,52 +0,0 @@
-import assert from 'assert'
-import { ensureAdbAvailable } from '../../src/utils/android/utils.js'
-import { getXcrunCmd } from '../../src/utils/ios/utils.js'
-
-// We import the server handler module to access the internal get_system_status implementation.
-import * as server from '../../src/server.js'
-
-// Small helper to call the tool handler similarly to how the MCP transport would.
-async function callGetSystemStatus() {
-  const req = { params: { name: 'get_system_status', arguments: {} } }
-  // @ts-ignore - use the handler exported from server
-  const handler = (server as any).defaultRequestHandler || (server as any).callToolHandler || (server as any).__callTool
-  if (!handler) {
-    // fallback: require the module and call the exported server instance's request handler
-    // The server code registers the handler directly; we will emulate by requiring compiled code in dist if available.
-    try {
-      const dist = await import('../../dist/server.js')
-      // Try to execute by sending a call via the server instance if exported
-      if (dist && dist.server && typeof dist.server._handleCall === 'function') {
-        return dist.server._handleCall(req)
-      }
-    } catch {
-      // best effort only
-    }
-    throw new Error('Cannot locate server call handler for tests')
-  }
-
-  return handler(req)
-}
-
-describe('get_system_status tool (unit)', () => {
-  it('returns structured result without throwing', async () => {
-    const res = await callGetSystemStatus()
-    // Handler returns { content: [{ type: 'text', text: JSON.stringify(...) }] }
-    assert(res && res.content && Array.isArray(res.content))
-    const textBlock = res.content.find((c: any) => c.type === 'text')
-    assert(textBlock && textBlock.text)
-    const payload = JSON.parse(textBlock.text)
-    assert(typeof payload.success === 'boolean')
-    assert(Array.isArray(payload.issues))
-  }).timeout(5000)
-
-  it('detects adb availability helper works', () => {
-    const adb = ensureAdbAvailable()
-    assert(adb && typeof adb.ok === 'boolean')
-  })
-
-  it('detects xcrun command helper exists', () => {
-    const cmd = getXcrunCmd()
-    assert(typeof cmd === 'string')
-  })
-})