@elizaos/computeruse 0.24.20

package/tests/cross-app-verification.test.js

@@ -0,0 +1,243 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Cross-Application Verification Test Suite
+ * Tests verification methods across multiple Windows built-in applications
+ * These apps are available on all Windows 10/11 computers
+ */
+
+const desktop = new Desktop();
+
+// Test configuration for each app
+const APP_TESTS = [
+  {
+    name: "Notepad",
+    launch: "notepad.exe",
+    existsSelector: "role:Document || role:Edit",
+    existsDescription: "text editor area",
+    menuBarSelector: "role:MenuBar",
+    notExistsSelector: "role:Window && name:Save As",
+    notExistsDescription: "Save As dialog",
+    required: true,
+  },
+  {
+    name: "Calculator",
+    launch: "calc",
+    existsSelector: "role:Button && name:Zero",
+    existsDescription: "Zero button",
+    menuBarSelector: null, // Calculator has no traditional menu bar
+    notExistsSelector: "role:Button && name:NonExistentCalcButton",
+    notExistsDescription: "non-existent button",
+    required: true,
+  },
+  {
+    name: "Google Chrome",
+    launch: "chrome",
+    existsSelector: "role:Document || role:Pane",
+    existsDescription: "browser content area",
+    menuBarSelector: null, // Chrome uses toolbar, not menu bar
+    notExistsSelector: "role:Window && name:Downloads Complete",
+    notExistsDescription: "Downloads Complete dialog",
+    required: false, // Chrome may not be installed
+  },
+  {
+    name: "Microsoft Edge",
+    launch: "msedge",
+    existsSelector: "role:Document || role:Pane",
+    existsDescription: "browser content area",
+    menuBarSelector: null, // Edge uses toolbar, not menu bar
+    notExistsSelector: "role:Window && name:Downloads Complete",
+    notExistsDescription: "Downloads Complete dialog",
+    required: false, // Edge can fail if already open or slow to launch
+  },
+  {
+    name: "File Explorer",
+    launch: "explorer",
+    existsSelector: "role:Pane",
+    existsDescription: "content pane",
+    menuBarSelector: null, // Modern Explorer uses ribbon
+    notExistsSelector: "role:Window && name:Confirm Delete",
+    notExistsDescription: "Confirm Delete dialog",
+    required: false, // Explorer has complex window structure, can be flaky
+  },
+];
+
+async function closeApp(appElement, appName) {
+  try {
+    await appElement.pressKey("Alt+F4");
+    await new Promise(r => setTimeout(r, 500));
+
+    // Handle save dialogs if they appear
+    try {
+      const dontSave = await appElement.locator("role:Button && name:Don\\'t Save").first(1000);
+      await dontSave.click();
+    } catch {
+      // Try "No" button for some dialogs
+      try {
+        const noBtn = await appElement.locator("role:Button && name:No").first(500);
+        await noBtn.click();
+      } catch {
+        // No dialog, that's fine
+      }
+    }
+  } catch (e) {
+    console.log(`    Note: Could not close ${appName} cleanly: ${e.message.substring(0, 50)}`);
+  }
+}
+
+async function testApp(config) {
+  console.log(`\n  ═══ ${config.name} ═══`);
+
+  let appElement = null;
+  let passed = 0;
+  let failed = 0;
+  let skipped = false;
+
+  try {
+    // Launch app
+    console.log(`  Launching ${config.name}...`);
+    try {
+      appElement = await desktop.openApplication(config.launch);
+      await new Promise(r => setTimeout(r, 1500)); // Wait for app to stabilize
+    } catch (launchError) {
+      if (!config.required) {
+        console.log(`  ⏭️  Skipping ${config.name} (not installed or failed to launch)`);
+        return { passed: 0, failed: 0, skipped: true, name: config.name };
+      }
+      throw launchError;
+    }
+
+    // Test 1: verifyElementExists for known element
+    console.log(`  Test 1: verifyElementExists (${config.existsDescription})`);
+    try {
+      const found = await desktop.verifyElementExists(
+        appElement,
+        config.existsSelector,
+        5000
+      );
+      if (found) {
+        console.log(`    ✅ Found ${config.existsDescription}: role=${found.role()}`);
+        passed++;
+      } else {
+        console.log(`    ❌ Expected to find ${config.existsDescription}`);
+        failed++;
+      }
+    } catch (e) {
+      console.log(`    ❌ Error: ${e.message.substring(0, 80)}`);
+      failed++;
+    }
+
+    // Test 2: verifyElementExists for MenuBar (if applicable)
+    if (config.menuBarSelector) {
+      console.log(`  Test 2: verifyElementExists (MenuBar)`);
+      try {
+        const menuBar = await desktop.verifyElementExists(
+          appElement,
+          config.menuBarSelector,
+          3000
+        );
+        if (menuBar) {
+          console.log(`    ✅ Found MenuBar: role=${menuBar.role()}`);
+          passed++;
+        }
+      } catch (e) {
+        console.log(`    ❌ MenuBar not found: ${e.message.substring(0, 60)}`);
+        failed++;
+      }
+    }
+
+    // Test 3: verifyElementNotExists for non-existent element
+    console.log(`  Test 3: verifyElementNotExists (${config.notExistsDescription})`);
+    try {
+      await desktop.verifyElementNotExists(
+        appElement,
+        config.notExistsSelector,
+        2000
+      );
+      console.log(`    ✅ Correctly confirmed ${config.notExistsDescription} does not exist`);
+      passed++;
+    } catch (e) {
+      if (e.message.includes("VERIFICATION_FAILED")) {
+        console.log(`    ❌ Element unexpectedly exists`);
+      } else {
+        console.log(`    ❌ Error: ${e.message.substring(0, 60)}`);
+      }
+      failed++;
+    }
+
+    // Test 4: Scoped locator search
+    console.log(`  Test 4: Scoped locator within app window`);
+    try {
+      const element = await appElement.locator(config.existsSelector).first(3000);
+      if (element) {
+        console.log(`    ✅ Scoped locator found element: role=${element.role()}`);
+        passed++;
+      }
+    } catch (e) {
+      console.log(`    ❌ Scoped locator failed: ${e.message.substring(0, 60)}`);
+      failed++;
+    }
+
+  } finally {
+    // Cleanup
+    if (appElement) {
+      console.log(`  Closing ${config.name}...`);
+      await closeApp(appElement, config.name);
+    }
+  }
+
+  return { passed, failed, name: config.name };
+}
+
+async function runTests() {
+  console.log("═══════════════════════════════════════════════════════════════════");
+  console.log("Cross-Application Verification Test Suite");
+  console.log("Tests SDK verification methods across Windows built-in applications");
+  console.log("═══════════════════════════════════════════════════════════════════");
+
+  let totalPassed = 0;
+  let totalFailed = 0;
+  const results = [];
+
+  for (const config of APP_TESTS) {
+    try {
+      const result = await testApp(config);
+      totalPassed += result.passed;
+      totalFailed += result.failed;
+      results.push(result);
+    } catch (error) {
+      console.log(`\n  ❌ ${config.name} test suite crashed: ${error.message}`);
+      results.push({ name: config.name, passed: 0, failed: 1, error: error.message });
+      totalFailed++;
+    }
+
+    // Brief pause between apps
+    await new Promise(r => setTimeout(r, 1000));
+  }
+
+  console.log("\n═══════════════════════════════════════════════════════════════════");
+  console.log("Results Summary:");
+  console.log("═══════════════════════════════════════════════════════════════════");
+
+  let totalSkipped = 0;
+  for (const result of results) {
+    if (result.skipped) {
+      console.log(`  ⏭️  ${result.name}: SKIPPED (not installed)`);
+      totalSkipped++;
+    } else {
+      const status = result.failed === 0 ? "✅" : "❌";
+      console.log(`  ${status} ${result.name}: ${result.passed} passed, ${result.failed} failed`);
+    }
+  }
+
+  console.log("───────────────────────────────────────────────────────────────────");
+  console.log(`  TOTAL: ${totalPassed} passed, ${totalFailed} failed, ${totalSkipped} skipped`);
+  console.log("═══════════════════════════════════════════════════════════════════");
+
+  process.exit(totalFailed > 0 ? 1 : 0);
+}
+
+runTests().catch(error => {
+  console.error("Test suite crashed:", error);
+  process.exit(1);
+});

package/tests/desktop-verify.test.js

@@ -0,0 +1,169 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Test for Desktop.verifyElementExists() and Desktop.verifyElementNotExists() methods
+ * These tests verify the verification methods work correctly with window-scoped searches
+ */
+
+async function testVerifyElementExists() {
+  console.log("🔍 Testing Desktop.verifyElementExists()...");
+  const desktop = new Desktop();
+
+  // Open Notepad for testing
+  console.log("  Opening Notepad...");
+  const notepad = await desktop.openApplication("notepad.exe");
+  await new Promise(r => setTimeout(r, 1000));
+
+  try {
+    // Test 1: Find an element that exists (Document/text editor)
+    console.log("  Test 1: Verify existing element (Document)");
+    const textEditor = await desktop.verifyElementExists(
+      notepad,
+      "role:Document || role:Edit",
+      5000
+    );
+
+    if (!textEditor) {
+      throw new Error("Expected to find text editor element");
+    }
+    console.log(`  ✅ Found: role=${textEditor.role()}, name=${textEditor.name()}`);
+
+    // Test 2: Find MenuBar (tests menubar role mapping)
+    console.log("  Test 2: Verify MenuBar exists");
+    const menuBar = await desktop.verifyElementExists(
+      notepad,
+      "role:MenuBar",
+      5000
+    );
+
+    if (!menuBar) {
+      throw new Error("Expected to find MenuBar element");
+    }
+    console.log(`  ✅ Found: role=${menuBar.role()}`);
+
+    // Test 3: Non-existent element should throw
+    console.log("  Test 3: Verify non-existent element throws error");
+    let threwError = false;
+    try {
+      await desktop.verifyElementExists(
+        notepad,
+        "role:Button && name:NonExistentButton12345",
+        2000
+      );
+    } catch (e) {
+      threwError = true;
+      console.log(`  ✅ Correctly threw error for non-existent element`);
+    }
+
+    if (!threwError) {
+      throw new Error("Expected verifyElementExists to throw for non-existent element");
+    }
+
+    return true;
+  } finally {
+    // Cleanup
+    console.log("  Closing Notepad...");
+    try {
+      await notepad.pressKey("Alt+F4");
+      await new Promise(r => setTimeout(r, 500));
+      const dontSave = await notepad.locator("role:Button && name:Don\\'t Save").first();
+      await dontSave.click();
+    } catch {
+      // No save dialog
+    }
+  }
+}
+
+async function testVerifyElementNotExists() {
+  console.log("\n🔍 Testing Desktop.verifyElementNotExists()...");
+  const desktop = new Desktop();
+
+  // Open Notepad for testing
+  console.log("  Opening Notepad...");
+  const notepad = await desktop.openApplication("notepad.exe");
+  await new Promise(r => setTimeout(r, 1000));
+
+  try {
+    // Test 1: Verify non-existent element passes
+    console.log("  Test 1: Verify non-existent element (Save As dialog)");
+    await desktop.verifyElementNotExists(
+      notepad,
+      "role:Window && name:Save As",
+      2000
+    );
+    console.log("  ✅ Correctly confirmed 'Save As' dialog does not exist");
+
+    // Test 2: Verify existing element throws
+    console.log("  Test 2: Verify existing element (MenuBar) throws error");
+    let threwError = false;
+    try {
+      await desktop.verifyElementNotExists(
+        notepad,
+        "role:MenuBar",
+        2000
+      );
+    } catch (e) {
+      threwError = true;
+      if (e.message.includes("VERIFICATION_FAILED")) {
+        console.log("  ✅ Correctly threw VERIFICATION_FAILED for existing element");
+      } else {
+        throw new Error(`Expected VERIFICATION_FAILED error, got: ${e.message}`);
+      }
+    }
+
+    if (!threwError) {
+      throw new Error("Expected verifyElementNotExists to throw for existing element");
+    }
+
+    return true;
+  } finally {
+    // Cleanup
+    console.log("  Closing Notepad...");
+    try {
+      await notepad.pressKey("Alt+F4");
+      await new Promise(r => setTimeout(r, 500));
+      const dontSave = await notepad.locator("role:Button && name:Don\\'t Save").first();
+      await dontSave.click();
+    } catch {
+      // No save dialog
+    }
+  }
+}
+
+async function runTests() {
+  console.log("═══════════════════════════════════════════════════════════════");
+  console.log("Desktop Verification Methods Test Suite");
+  console.log("═══════════════════════════════════════════════════════════════\n");
+
+  let passed = 0;
+  let failed = 0;
+
+  try {
+    await testVerifyElementExists();
+    passed++;
+    console.log("\n✅ testVerifyElementExists PASSED\n");
+  } catch (error) {
+    failed++;
+    console.error("\n❌ testVerifyElementExists FAILED:", error.message, "\n");
+  }
+
+  try {
+    await testVerifyElementNotExists();
+    passed++;
+    console.log("\n✅ testVerifyElementNotExists PASSED\n");
+  } catch (error) {
+    failed++;
+    console.error("\n❌ testVerifyElementNotExists FAILED:", error.message, "\n");
+  }
+
+  console.log("═══════════════════════════════════════════════════════════════");
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  console.log("═══════════════════════════════════════════════════════════════");
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+runTests().catch(error => {
+  console.error("Test suite crashed:", error);
+  process.exit(1);
+});

package/tests/element-chaining.test.js

@@ -0,0 +1,158 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Test for Element.locator() chaining functionality
+ * This test verifies the fix for issue #258 where Element.locator() chaining would fail
+ * due to expensive WindowsEngine creation on every call.
+ */
+async function testElementChaining() {
+  console.log("🔗 Testing Element.locator() chaining...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Get any available application for testing
+    const apps = desktop.applications();
+    if (apps.length === 0) {
+      throw new Error("No applications found for testing");
+    }
+
+    const testApp = apps[0];
+    console.log(`📱 Testing with app: ${testApp.name()}`);
+
+    // Test 1: Basic chaining - this was the main issue
+    console.log("Test 1: Basic element chaining");
+    const windowLocator = testApp.locator("role:window");
+    const buttonLocator = windowLocator.locator("role:button");
+    console.log("✅ Basic chaining works");
+
+    // Test 2: Multiple chaining levels
+    console.log("Test 2: Multiple chaining levels");
+    const deepChain = testApp
+      .locator("role:window")
+      .locator("role:pane")
+      .locator("role:button");
+    console.log("✅ Deep chaining works");
+
+    // Test 3: Stress test - create many locators quickly
+    console.log("Test 3: Stress test (50 rapid chains)");
+    const startTime = Date.now();
+    for (let i = 0; i < 50; i++) {
+      const locator = testApp.locator("role:window").locator("role:button");
+      // Just create the locator, don't need to use it
+    }
+    const endTime = Date.now();
+    console.log(`✅ Created 50 chained locators in ${endTime - startTime}ms`);
+
+    // Test 4: Concurrent chaining
+    console.log("Test 4: Concurrent chaining");
+    const promises = [];
+    for (let i = 0; i < 10; i++) {
+      promises.push(
+        Promise.resolve().then(() => {
+          return testApp.locator("role:window").locator("role:text");
+        })
+      );
+    }
+    await Promise.all(promises);
+    console.log("✅ Concurrent chaining works");
+
+    return true;
+  } catch (error) {
+    console.error("❌ Element chaining test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test for Wikipedia-specific chaining (if Wikipedia is available)
+ */
+async function testWikipediaChaining() {
+  console.log("🌐 Testing Wikipedia-specific chaining...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to find Wikipedia page
+    try {
+      const wikipediaLocator = desktop.locator("role:document|wikipedia");
+      const w = await wikipediaLocator.first(0); // timeout in ms (0 = immediate)
+      console.log(`📖 Found Wikipedia page: ${w.name()}`);
+
+      // Test the original failing case
+      const textLocator = w.locator("role:text|wikipedia");
+      console.log("✅ Wikipedia element chaining works");
+
+      // Try to find some elements
+      try {
+        const elements = await textLocator.all(2000);
+        console.log(`✅ Found ${elements.length} Wikipedia text elements`);
+      } catch (err) {
+        console.log("ℹ️  No specific Wikipedia text elements found (normal)");
+      }
+
+      return true;
+    } catch (err) {
+      if (err.message.includes("Timed out")) {
+        console.log(
+          "ℹ️  No Wikipedia page found - skipping Wikipedia-specific test"
+        );
+        return true; // Not a failure, just no Wikipedia available
+      }
+      throw err;
+    }
+  } catch (error) {
+    console.error("❌ Wikipedia chaining test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runChainingTests() {
+  console.log("🚀 Starting Element.locator() chaining tests...\n");
+
+  let passed = 0;
+  let total = 0;
+
+  // Test 1: Basic element chaining
+  total++;
+  if (await testElementChaining()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 2: Wikipedia-specific chaining
+  total++;
+  if (await testWikipediaChaining()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Results
+  if (passed === total) {
+    console.log(`🎉 All chaining tests passed! (${passed}/${total})`);
+    process.exit(0);
+  } else {
+    console.log(`❌ Some tests failed: ${passed}/${total} passed`);
+    process.exit(1);
+  }
+}
+
+// Export for use in other test files
+module.exports = {
+  testElementChaining,
+  testWikipediaChaining,
+  runChainingTests,
+};
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runChainingTests().catch((error) => {
+    console.error("💥 Test runner crashed:", error);
+    process.exit(1);
+  });
+}