@elizaos/computeruse 0.24.20

package/tests/element-range.test.js

@@ -0,0 +1,207 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Test for Element.getRangeValue() and setRangeValue() methods
+ *
+ * Note: This test requires an application with slider controls.
+ * Common apps with sliders: Volume mixer, Media players, Settings apps
+ */
+async function testRangeValue() {
+  console.log("🎚️  Testing Element range value methods...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to find a slider control in any running application
+    console.log("Searching for slider controls...");
+
+    // Common roles for range controls: slider, scrollbar, progressbar
+    const sliderLocator = desktop.locator("role:slider");
+
+    try {
+      const slider = await sliderLocator.first(2000);
+      console.log(`✅ Found slider: ${slider.name() || '(unnamed)'}`);
+
+      // Test: Get current value
+      console.log("Test: Get current range value");
+      const currentValue = slider.getRangeValue();
+      console.log(`  Current value: ${currentValue}`);
+
+      if (typeof currentValue !== 'number') {
+        throw new Error(`Expected number, got ${typeof currentValue}`);
+      }
+
+      // Test: Set a new value (try to set it to 50 if current value is different)
+      console.log("Test: Set range value");
+      const targetValue = currentValue !== 50 ? 50 : 75;
+      slider.setRangeValue(targetValue);
+      console.log(`  Set value to: ${targetValue}`);
+
+      // Wait a bit for the UI to update
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      // Verify the value changed (allow small tolerance for rounding)
+      const newValue = slider.getRangeValue();
+      console.log(`  New value: ${newValue}`);
+
+      const tolerance = 5;
+      if (Math.abs(newValue - targetValue) > tolerance) {
+        console.log(`  ⚠️  Value changed but not exactly to target (tolerance: ${tolerance})`);
+      } else {
+        console.log(`  ✅ Value set successfully`);
+      }
+
+      // Restore original value
+      slider.setRangeValue(currentValue);
+      console.log(`  Restored original value: ${currentValue}`);
+
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No slider found - this is acceptable if no apps with sliders are running");
+        console.log("   Try running: Volume mixer, Windows Media Player, or Settings app");
+        return true; // Not a test failure, just no suitable UI available
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ Range value test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test range value with scrollbar (another type of range control)
+ */
+async function testScrollbarRange() {
+  console.log("🎚️  Testing scrollbar range values...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to find a scrollbar
+    console.log("Searching for scrollbar controls...");
+    const scrollbarLocator = desktop.locator("role:scrollbar");
+
+    try {
+      const scrollbar = await scrollbarLocator.first(2000);
+      console.log(`✅ Found scrollbar: ${scrollbar.name() || '(unnamed)'}`);
+
+      // Just verify we can read the value (don't modify scrollbars as it affects UI)
+      const scrollValue = scrollbar.getRangeValue();
+      console.log(`  Scrollbar position: ${scrollValue}`);
+
+      if (typeof scrollValue !== 'number') {
+        throw new Error(`Expected number, got ${typeof scrollValue}`);
+      }
+
+      console.log("✅ Successfully read scrollbar value");
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No scrollbar found - this is acceptable");
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ Scrollbar range test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test error handling for non-range elements
+ */
+async function testRangeValueError() {
+  console.log("🎚️  Testing range value error handling...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to get range value from a non-range element (like a button)
+    console.log("Test: Get range value from non-range element");
+
+    try {
+      const button = await desktop.locator("role:button").first(2000);
+
+      // This should throw an error or return a default value
+      try {
+        const rangeValue = button.getRangeValue();
+        console.log(`  ⚠️  Got value from non-range element: ${rangeValue} (unexpected but not fatal)`);
+      } catch (err) {
+        console.log(`  ✅ Correctly threw error: ${err.message}`);
+      }
+
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No button found for error test");
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ Range value error test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runRangeValueTests() {
+  console.log("🚀 Starting Element range value tests...\n");
+
+  let passed = 0;
+  let total = 0;
+
+  // Test 1: Basic range value get/set
+  total++;
+  if (await testRangeValue()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 2: Scrollbar range
+  total++;
+  if (await testScrollbarRange()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 3: Error handling
+  total++;
+  if (await testRangeValueError()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Results
+  if (passed === total) {
+    console.log(`🎉 All range value 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 = {
+  testRangeValue,
+  testScrollbarRange,
+  testRangeValueError,
+  runRangeValueTests,
+};
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runRangeValueTests().catch((error) => {
+    console.error("💥 Test runner crashed:", error);
+    process.exit(1);
+  });
+}

package/tests/element-scroll-into-view.test.js

@@ -0,0 +1,256 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Test for Element.scrollIntoView() method
+ *
+ * Note: This test requires an application with scrollable content and off-screen elements.
+ * Common apps: Browser with long pages, File Explorer, Settings with long lists
+ */
+async function testScrollIntoView() {
+  console.log("📜 Testing Element.scrollIntoView()...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to find a window with scrollable content
+    console.log("Searching for scrollable windows...");
+
+    const windowLocator = desktop.locator("role:window");
+
+    try {
+      const window = await windowLocator.first(2000);
+      console.log(`✅ Found window: ${window.name()}`);
+
+      // Try to find a scrollbar (indicates scrollable content)
+      const scrollbarLocator = window.locator("role:scrollbar");
+
+      try {
+        const scrollbar = await scrollbarLocator.first(1000);
+        console.log(`  Found scrollbar - window has scrollable content`);
+
+        // Try to find any element within the window
+        const elementLocator = window.locator("role:button|role:text|role:link");
+
+        try {
+          const elements = await elementLocator.all(2000, 3);
+
+          if (elements.length > 0) {
+            // Pick an element (preferably not the first one)
+            const targetElement = elements.length > 5 ? elements[5] : elements[0];
+            console.log(`  Testing with element: ${targetElement.name() || '(unnamed)'}`);
+
+            // Test: Scroll into view
+            console.log("Test: Scroll element into view");
+            targetElement.scrollIntoView();
+            console.log(`  ✅ scrollIntoView() executed successfully`);
+
+            // Wait a bit for scroll animation
+            await new Promise(resolve => setTimeout(resolve, 500));
+
+            // Verify element is visible
+            if (targetElement.isVisible()) {
+              console.log(`  ✅ Element is visible after scroll`);
+            } else {
+              console.log(`  ⚠️  Element may not be fully visible (acceptable for some UIs)`);
+            }
+
+            return true;
+          } else {
+            console.log("ℹ️  No suitable elements found for scrolling test");
+            return true;
+          }
+        } catch (error) {
+          console.log(`  ℹ️  Could not find elements for scroll test: ${error.message}`);
+          return true;
+        }
+      } catch (error) {
+        console.log(`  ℹ️  No scrollbar found - window may not have scrollable content`);
+        return true;
+      }
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No window found - this is acceptable");
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ scrollIntoView test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test scrollIntoView with already visible element
+ */
+async function testScrollIntoViewAlreadyVisible() {
+  console.log("📜 Testing scrollIntoView with already visible element...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Find any visible window
+    console.log("Test: Scroll already visible element");
+
+    try {
+      const window = await desktop.locator("role:window").first(2000);
+
+      // The window itself should be visible
+      if (window.isVisible()) {
+        // Call scrollIntoView on already visible element (should be a no-op)
+        window.scrollIntoView();
+        console.log(`  ✅ scrollIntoView() on visible element completed`);
+        return true;
+      } else {
+        console.log(`  ℹ️  Window not visible for test`);
+        return true;
+      }
+    } catch (error) {
+      console.log(`  ℹ️  No window found for visible element test`);
+      return true;
+    }
+  } catch (error) {
+    console.error("❌ scrollIntoView visible element test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test scrollIntoView multiple times (should be idempotent)
+ */
+async function testScrollIntoViewIdempotent() {
+  console.log("📜 Testing scrollIntoView idempotence...");
+
+  try {
+    const desktop = new Desktop();
+
+    console.log("Test: Call scrollIntoView multiple times");
+
+    try {
+      const button = await desktop.locator("role:button").first(2000);
+
+      // Call scrollIntoView multiple times
+      button.scrollIntoView();
+      await new Promise(resolve => setTimeout(resolve, 200));
+
+      button.scrollIntoView();
+      await new Promise(resolve => setTimeout(resolve, 200));
+
+      button.scrollIntoView();
+
+      console.log(`  ✅ Multiple scrollIntoView calls completed successfully`);
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log(`  ℹ️  No button found for idempotence test`);
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ scrollIntoView idempotence test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test scrollIntoView before click (common use case)
+ */
+async function testScrollIntoViewBeforeClick() {
+  console.log("📜 Testing scrollIntoView before click pattern...");
+
+  try {
+    const desktop = new Desktop();
+
+    console.log("Test: Scroll into view then click");
+
+    try {
+      const button = await desktop.locator("role:button").first(2000);
+
+      // Common pattern: ensure element is visible before clicking
+      button.scrollIntoView();
+      await new Promise(resolve => setTimeout(resolve, 300));
+
+      // We won't actually click (to avoid disrupting UI), just verify pattern works
+      console.log(`  ✅ scrollIntoView before click pattern works`);
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log(`  ℹ️  No button found for click pattern test`);
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ scrollIntoView before click test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runScrollIntoViewTests() {
+  console.log("🚀 Starting Element.scrollIntoView() tests...\n");
+
+  let passed = 0;
+  let total = 0;
+
+  // Test 1: Basic scroll into view
+  total++;
+  if (await testScrollIntoView()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 2: Already visible element
+  total++;
+  if (await testScrollIntoViewAlreadyVisible()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 3: Idempotence
+  total++;
+  if (await testScrollIntoViewIdempotent()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 4: Before click pattern
+  total++;
+  if (await testScrollIntoViewBeforeClick()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Results
+  if (passed === total) {
+    console.log(`🎉 All scrollIntoView 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 = {
+  testScrollIntoView,
+  testScrollIntoViewAlreadyVisible,
+  testScrollIntoViewIdempotent,
+  testScrollIntoViewBeforeClick,
+  runScrollIntoViewTests,
+};
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runScrollIntoViewTests().catch((error) => {
+    console.error("💥 Test runner crashed:", error);
+    process.exit(1);
+  });
+}