How to Work With Strings in JavaScript Selenium Tests

In JavaScript Selenium tests, strings are ordinary JavaScript values. Locate a keyboard-interactable element, clear it if needed, await sendKeys(), then read an input’s value with getAttribute('value'). For visible rendered text, use getText(). Assert the representation your application actually exposes.

Set up a runnable Selenium test

The examples below use Selenium’s JavaScript WebDriver binding and Node.js. Install the binding and a browser driver supported by your environment:

npm install selenium-webdriver

Save this as strings.test.js. It opens a small data URL, types into an input, checks the input value, submits the form, then checks visible text. The finally block closes the browser even if an assertion fails.

const { Builder, By } = require('selenium-webdriver');
const assert = require('node:assert/strict');

(async function testStrings() {
  const driver = await new Builder().forBrowser('chrome').build();
  try {
    const html = `<!doctype html>
      <form onsubmit="event.preventDefault(); document.querySelector('#result').textContent = document.querySelector('#message').value">
        <input id="message">
        <button type="submit">Send</button>
      </form>
      <output id="result"></output>`;
    await driver.get(`data:text/html;charset=utf-8,${encodeURIComponent(html)}`);

    const expected = 'Hello, Selenium!';
    const field = await driver.findElement(By.id('message'));
    await field.clear();
    await field.sendKeys(expected);

    const value = await field.getAttribute('value');
    assert.equal(value, expected);

    await driver.findElement(By.css('button')).click();
    const rendered = await driver.findElement(By.id('result')).getText();
    assert.equal(rendered, expected);
  } finally {
    await driver.quit();
  }
})().catch(error => {
  console.error(error);
  process.exitCode = 1;
});

The Selenium API calls are asynchronous. Await each one before using its result or making the next dependent interaction. See the WebElement API and element interactions guide.

Enter strings into form controls

sendKeys() simulates keyboard input. It is for keyboard-interactable elements such as text inputs, textareas, and editable content; it is not a universal setter for arbitrary elements. If the page has prefilled content and the test means to replace it, clear first. If the scenario is appending, do not clear.

const field = await driver.findElement(By.name('message'));
await field.clear();
await field.sendKeys('A string entered by the test');
assert.equal(await field.getAttribute('value'), 'A string entered by the test');

Use a locator that identifies the intended control reliably, such as a stable id, name, or test-specific attribute. For contenteditable elements, locate the editable node and use keyboard input; read back the rendered content in a way that matches the application’s markup and behavior.

Typing multiple values

You can pass multiple strings to sendKeys(); Selenium types them in sequence. This can be useful when combining ordinary text and key constants. Keep assertions focused on the resulting value, not on the number of calls used to produce it.

const field = await driver.findElement(By.id('search'));
await field.clear();
await field.sendKeys('selenium', ' webdriver');
assert.equal(await field.getAttribute('value'), 'selenium webdriver');

Read the right string from the page

A common false alarm is comparing input text with getText(). Form controls expose their entered contents as a value, not as visible inner text. Selenium’s interaction examples read the input value after typing. See the Selenium interaction guide.

const field = await driver.findElement(By.name('message'));
const inputValue = await field.getAttribute('value');
assert.equal(inputValue, 'expected input');

const label = await driver.findElement(By.id('status'));
const visibleText = await label.getText();
assert.equal(visibleText, 'Saved');

Use executeScript() when the test specifically needs a browser-side computation or property. For ordinary user-like typing and reading, the element interaction methods make the tested behavior clearer. With executeAsyncScript(), the injected script must call its callback to signal completion.

Assert exact strings and Unicode correctly

Node’s strict equality assertion is case-sensitive and checks the exact string value:

const assert = require('node:assert/strict');
assert.equal(actual, expected);

Do not trim, lowercase, or normalize values unless the product requirement calls for it. Such transformations can hide behavior the test is supposed to catch. If the requirement is locale-aware, case-insensitive comparison, use Intl.Collator with the intended locale and sensitivity:

const collator = new Intl.Collator('en', { sensitivity: 'accent' });
assert.equal(collator.compare(actual, expected), 0);

JavaScript string length and indexes count UTF-16 code units, not necessarily user-perceived characters. A supplementary-plane emoji commonly occupies two code units. Iteration with spread syntax yields code points, but a displayed grapheme can contain several code points, as with joined or modified emoji. Therefore, decide whether a character limit means code units, code points, or grapheme clusters before asserting length. See MDN’s String reference.

const sample = '😀';
console.log(sample.length);       // 2 UTF-16 code units
console.log([...sample].length);  // 1 code point

For URI or UTF-8 boundaries, malformed strings containing lone surrogates may cause encoding failures. Where arbitrary input is in scope, check isWellFormed() or use toWellFormed() where supported by the runtime, and test the behavior your application intends.

Test special keys and shortcuts

Use Selenium’s Key constants for non-text keys. Modifiers are stateful while held, so pair key-down with key-up, use a chord where appropriate, or reset with Key.NULL. Selenium’s keyboard guide demonstrates explicit modifier actions.

const { Builder, By, Key } = require('selenium-webdriver');

const field = await driver.findElement(By.id('message'));
await field.clear();
await field.sendKeys(Key.SHIFT, 'hello');
// Prefer Actions when the test needs explicit key-down/key-up state.

const { Key } = require('selenium-webdriver');
const modifier = process.platform === 'darwin' ? Key.COMMAND : Key.CONTROL;
await field.sendKeys('hello');
await field.sendKeys(modifier, 'a'); // select all on common desktop platforms

const { By, until } = require('selenium-webdriver');
await field.sendKeys('query');
const result = await driver.wait(until.elementLocated(By.id('result')), 5000);
await driver.wait(async () => (await result.getText()) === 'query received', 5000);
assert.equal(await result.getText(), 'query received');

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);