@elizaos/computeruse 0.24.20

package/tests/element-value.test.js

@@ -0,0 +1,264 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Test for Element.getValue() and setValue() methods
+ *
+ * Note: This test requires an application with text input fields.
+ * Common apps with text inputs: Notepad, Browser address bar, Settings search
+ */
+async function testGetSetValue() {
+  console.log("📝 Testing Element getValue/setValue methods...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to find a text input field (edit control)
+    console.log("Searching for text input fields...");
+
+    // Common roles for value-based controls: edit, textfield, combobox
+    const editLocator = desktop.locator("role:edit");
+
+    try {
+      const editField = await editLocator.first(2000);
+      console.log(`✅ Found edit field: ${editField.name() || '(unnamed)'}`);
+
+      // Test: Get current value
+      console.log("Test: Get current value");
+      const currentValue = editField.getValue();
+      console.log(`  Current value: ${currentValue !== null ? `"${currentValue}"` : 'null'}`);
+
+      // Test: Set a new value
+      console.log("Test: Set value");
+      const testValue = "Test Input 123";
+      editField.setValue(testValue);
+      console.log(`  Set value to: "${testValue}"`);
+
+      // Wait a bit for the UI to update
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      // Verify the value changed
+      const newValue = editField.getValue();
+      console.log(`  New value: ${newValue !== null ? `"${newValue}"` : 'null'}`);
+
+      if (newValue === testValue) {
+        console.log(`  ✅ Value set successfully`);
+      } else {
+        console.log(`  ⚠️  Value changed but doesn't match exactly (may be platform behavior)`);
+      }
+
+      // Restore original value if it existed
+      if (currentValue !== null) {
+        editField.setValue(currentValue);
+        console.log(`  Restored original value: "${currentValue}"`);
+      } else {
+        // Clear the field
+        editField.setValue("");
+        console.log(`  Cleared field`);
+      }
+
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No edit field found - this is acceptable if no text input apps are running");
+        console.log("   Try running: Notepad, Browser, or Settings app with search field");
+        return true; // Not a test failure, just no suitable UI available
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ getValue/setValue test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test getValue with combo box
+ */
+async function testComboBoxValue() {
+  console.log("📝 Testing combo box value...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to find a combo box
+    console.log("Searching for combo box controls...");
+    const comboLocator = desktop.locator("role:combobox");
+
+    try {
+      const comboBox = await comboLocator.first(2000);
+      console.log(`✅ Found combo box: ${comboBox.name() || '(unnamed)'}`);
+
+      // Just verify we can read the value
+      const comboValue = comboBox.getValue();
+      console.log(`  Combo box value: ${comboValue !== null ? `"${comboValue}"` : 'null'}`);
+
+      console.log("✅ Successfully read combo box value");
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No combo box found - this is acceptable");
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ Combo box value test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test getValue returns null for non-value elements
+ */
+async function testGetValueNull() {
+  console.log("📝 Testing getValue with non-value element...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Try to get value from a button (which shouldn't have a value attribute)
+    console.log("Test: Get value from button element");
+
+    try {
+      const button = await desktop.locator("role:button").first(2000);
+
+      const buttonValue = button.getValue();
+      if (buttonValue === null) {
+        console.log(`  ✅ Correctly returned null for button element`);
+      } else {
+        console.log(`  ⚠️  Got value from button: "${buttonValue}" (unexpected but not fatal)`);
+      }
+
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No button found for null value test");
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ getValue null test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test setValue with empty string
+ */
+async function testSetValueEmpty() {
+  console.log("📝 Testing setValue with empty string...");
+
+  try {
+    const desktop = new Desktop();
+
+    console.log("Test: Set empty value");
+
+    try {
+      const editField = await desktop.locator("role:edit").first(2000);
+
+      // Get current value
+      const currentValue = editField.getValue();
+      console.log(`  Current value: ${currentValue !== null ? `"${currentValue}"` : 'null'}`);
+
+      // Set to empty
+      editField.setValue("");
+      console.log(`  Set value to empty string`);
+
+      await new Promise(resolve => setTimeout(resolve, 300));
+
+      // Verify it's empty
+      const emptyValue = editField.getValue();
+      console.log(`  New value: ${emptyValue !== null ? `"${emptyValue}"` : 'null'}`);
+
+      if (emptyValue === "" || emptyValue === null) {
+        console.log(`  ✅ Field cleared successfully`);
+      }
+
+      // Restore original value
+      if (currentValue !== null && currentValue !== "") {
+        editField.setValue(currentValue);
+        console.log(`  Restored original value`);
+      }
+
+      return true;
+    } catch (error) {
+      if (error.message && error.message.includes("Timed out")) {
+        console.log("ℹ️  No edit field found for empty value test");
+        return true;
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("❌ setValue empty test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runValueTests() {
+  console.log("🚀 Starting Element value tests...\n");
+
+  let passed = 0;
+  let total = 0;
+
+  // Test 1: Basic get/set value
+  total++;
+  if (await testGetSetValue()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 2: Combo box value
+  total++;
+  if (await testComboBoxValue()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 3: getValue returns null
+  total++;
+  if (await testGetValueNull()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 4: setValue empty string
+  total++;
+  if (await testSetValueEmpty()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Results
+  if (passed === total) {
+    console.log(`🎉 All 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 = {
+  testGetSetValue,
+  testComboBoxValue,
+  testGetValueNull,
+  testSetValueEmpty,
+  runValueTests,
+};
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runValueTests().catch((error) => {
+    console.error("💥 Test runner crashed:", error);
+    process.exit(1);
+  });
+}

package/tests/execute-browser-script-wrapper.test.js

@@ -0,0 +1,135 @@
+const assert = require("assert");
+const path = require("path");
+const fs = require("fs");
+
+const { Desktop } = require("../wrapper.js");
+
+async function testFunctionInput() {
+  let capturedScript = null;
+  const expected = { greeting: "hello", answer: 42 };
+  const fake = {
+    _originalExecuteBrowserScript: async (script) => {
+      capturedScript = script;
+      return JSON.stringify(expected);
+    },
+  };
+
+  const result = await Desktop.prototype.executeBrowserScript.call(
+    fake,
+    ({ greeting, answer }) => ({ greeting, answer }),
+    { greeting: "hello", answer: 42 },
+  );
+
+  assert.deepStrictEqual(result, expected);
+  assert.ok(
+    capturedScript.includes('"greeting":"hello"') &&
+      capturedScript.includes('"answer":42'),
+    "env payload should be embedded in generated script",
+  );
+  assert.ok(
+    capturedScript.trim().startsWith("(async function()"),
+    "generated script should be wrapped in async IIFE",
+  );
+}
+
+async function testStringInput() {
+  const fake = {
+    _originalExecuteBrowserScript: async () => "raw-result",
+  };
+  const script = '(() => "ignored")()';
+  const result = await Desktop.prototype.executeBrowserScript.call(
+    fake,
+    script,
+  );
+  assert.strictEqual(result, "raw-result");
+}
+
+async function testFileInput() {
+  const fixturePath = path.join(
+    __dirname,
+    "fixtures",
+    "sample-browser-script.js",
+  );
+  const expectedScript = fs.readFileSync(fixturePath, "utf8");
+  let receivedScript = null;
+  const fake = {
+    _originalExecuteBrowserScript: async (script) => {
+      receivedScript = script;
+      return "file-result";
+    },
+  };
+
+  // Test without env - should not inject
+  const result = await Desktop.prototype.executeBrowserScript.call(fake, {
+    file: fixturePath,
+  });
+
+  assert.strictEqual(result, "file-result");
+  assert.strictEqual(receivedScript, expectedScript);
+}
+
+async function testFileInputWithEnvInjection() {
+  const fixturePath = path.join(__dirname, "fixtures", "script-with-env.js");
+  const columnPositions = [10, 20, 30];
+  let receivedScript = null;
+  const fake = {
+    _originalExecuteBrowserScript: async (script) => {
+      receivedScript = script;
+      // Simulate executing the script with injected env
+      const column_positions = columnPositions;
+      const result = eval(script);
+      return JSON.stringify(result);
+    },
+  };
+
+  const result = await Desktop.prototype.executeBrowserScript.call(fake, {
+    file: fixturePath,
+    env: { column_positions: columnPositions },
+  });
+
+  // Result comes back as JSON string for file-based scripts
+  const parsed = JSON.parse(result);
+  assert.deepStrictEqual(parsed, {
+    positions: columnPositions,
+    count: 3,
+  });
+
+  // Verify the env was injected into the script as an env object
+  assert.ok(
+    receivedScript.includes("const env = "),
+    "env object should be injected into script",
+  );
+  assert.ok(
+    receivedScript.includes('"column_positions"'),
+    "column_positions key should be in env object",
+  );
+  assert.ok(
+    receivedScript.includes(JSON.stringify(columnPositions)),
+    "column_positions value should be embedded",
+  );
+}
+
+async function run() {
+  try {
+    await testFunctionInput();
+    console.log("✅ executeBrowserScript handles function input");
+
+    await testStringInput();
+    console.log("✅ executeBrowserScript preserves string behavior");
+
+    await testFileInput();
+    console.log("✅ executeBrowserScript loads scripts from files");
+
+    await testFileInputWithEnvInjection();
+    console.log(
+      "✅ executeBrowserScript injects env variables into file scripts",
+    );
+
+    console.log("🎉 All executeBrowserScript wrapper tests passed");
+  } catch (err) {
+    console.error("❌ executeBrowserScript wrapper test failed:", err);
+    process.exitCode = 1;
+  }
+}
+
+run();

package/tests/fixtures/sample-browser-script.js

@@ -0,0 +1,7 @@
+(() => {
+  const el = document.querySelector('h1');
+  const text = el ? el.textContent : 'no-heading';
+  return `fixture:${text}`;
+})()
+
+

package/tests/fixtures/script-with-env.js

@@ -0,0 +1,16 @@
+// Browser script that uses injected env object
+(() => {
+  // env object should be auto-injected by wrapper
+  if (typeof env === "undefined") {
+    throw new Error("env not injected");
+  }
+
+  if (!env.column_positions) {
+    throw new Error("column_positions not in env");
+  }
+
+  return {
+    positions: env.column_positions,
+    count: env.column_positions.length,
+  };
+})();

package/tests/locator-validate.test.js

@@ -0,0 +1,260 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Test for Locator.validate() method
+ * This test verifies that validate() returns ValidationResult without throwing errors
+ */
+async function testValidateExists() {
+  console.log("🔍 Testing Locator.validate() for existing elements...");
+
+  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: Validate an existing element (the app window itself)
+    console.log("Test 1: Validate existing element");
+    const result = await desktop.locator("role:window").validate(2000);
+
+    if (!result.exists) {
+      throw new Error("Expected element to exist");
+    }
+    if (!result.element) {
+      throw new Error("Expected element to be present in result");
+    }
+    if (result.error) {
+      throw new Error(`Expected no error, got: ${result.error}`);
+    }
+
+    console.log(`✅ Window element found: ${result.element.name()}`);
+
+    return true;
+  } catch (error) {
+    console.error("❌ Validate exists test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test validate() with non-existent element
+ */
+async function testValidateNotExists() {
+  console.log("🔍 Testing Locator.validate() for non-existent elements...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Test: Validate a non-existent element
+    console.log("Test: Validate non-existent element");
+    const result = await desktop
+      .locator("role:button|ThisButtonDoesNotExist12345XYZ")
+      .validate(1000);
+
+    if (result.exists) {
+      throw new Error("Expected element to not exist");
+    }
+    if (result.element) {
+      throw new Error("Expected element to be undefined");
+    }
+    if (result.error) {
+      // Errors should only happen for invalid selectors, not for "not found"
+      throw new Error(`Unexpected error in validation: ${result.error}`);
+    }
+
+    console.log("✅ Correctly reported element as not existing");
+
+    return true;
+  } catch (error) {
+    console.error("❌ Validate not exists test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test validate() with chained locators
+ */
+async function testValidateChaining() {
+  console.log("🔍 Testing Locator.validate() with chaining...");
+
+  try {
+    const desktop = new Desktop();
+    const apps = desktop.applications();
+
+    if (apps.length === 0) {
+      throw new Error("No applications found for testing");
+    }
+
+    const testApp = apps[0];
+
+    // Test: Validate with chained locator
+    console.log("Test: Validate with chained locator");
+    const result = await testApp
+      .locator("role:window")
+      .locator("role:button")
+      .validate(2000);
+
+    // Either exists or doesn't exist - both are valid, we just check no crash
+    if (result.exists) {
+      console.log(`✅ Found button in chain: ${result.element.name()}`);
+    } else {
+      console.log("✅ No button found in chain (expected)");
+    }
+
+    if (result.error) {
+      throw new Error(`Unexpected error: ${result.error}`);
+    }
+
+    return true;
+  } catch (error) {
+    console.error("❌ Validate chaining test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test validate() with zero timeout
+ */
+async function testValidateZeroTimeout() {
+  console.log("🔍 Testing Locator.validate() with zero timeout...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Test: Immediate validation (no retry)
+    console.log("Test: Validate with zero timeout (immediate)");
+    const result = await desktop.locator("role:window").validate(0);
+
+    // With zero timeout, should still find immediate elements
+    console.log(`✅ Immediate validation returned: exists=${result.exists}`);
+
+    return true;
+  } catch (error) {
+    console.error("❌ Validate zero timeout test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test that validate() doesn't throw like first() does
+ */
+async function testValidateVsFirst() {
+  console.log("🔍 Testing validate() vs first() behavior...");
+
+  try {
+    const desktop = new Desktop();
+    const selector = "role:button|ThisButtonDoesNotExist12345XYZ";
+
+    // Test: first() should throw
+    console.log("Test: Verifying first() throws on not found");
+    let firstThrew = false;
+    try {
+      await desktop.locator(selector).first(500);
+    } catch (err) {
+      firstThrew = true;
+      console.log("✅ first() correctly threw error");
+    }
+
+    if (!firstThrew) {
+      throw new Error("Expected first() to throw, but it didn't");
+    }
+
+    // Test: validate() should NOT throw
+    console.log("Test: Verifying validate() doesn't throw on not found");
+    const result = await desktop.locator(selector).validate(500);
+
+    if (result.exists) {
+      throw new Error("Expected element to not exist");
+    }
+
+    console.log("✅ validate() correctly returned {exists: false} without throwing");
+
+    return true;
+  } catch (error) {
+    console.error("❌ Validate vs first test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runValidateTests() {
+  console.log("🚀 Starting Locator.validate() tests...\n");
+
+  let passed = 0;
+  let total = 0;
+
+  // Test 1: Validate existing element
+  total++;
+  if (await testValidateExists()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 2: Validate non-existent element
+  total++;
+  if (await testValidateNotExists()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 3: Validate with chaining
+  total++;
+  if (await testValidateChaining()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 4: Validate with zero timeout
+  total++;
+  if (await testValidateZeroTimeout()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 5: Validate vs first behavior
+  total++;
+  if (await testValidateVsFirst()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Results
+  if (passed === total) {
+    console.log(`🎉 All validate 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 = {
+  testValidateExists,
+  testValidateNotExists,
+  testValidateChaining,
+  testValidateZeroTimeout,
+  testValidateVsFirst,
+  runValidateTests,
+};
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runValidateTests().catch((error) => {
+    console.error("💥 Test runner crashed:", error);
+    process.exit(1);
+  });
+}