Ações de Teclado

Uma representação de qualquer dispositivo de entrada de teclado para interagir com uma página da web.

Existem apenas 2 ações que podem ser realizadas com um teclado: pressionar uma tecla e liberar uma tecla pressionada. Além de suportar caracteres ASCII, cada tecla do teclado possui uma representação que pode ser pressionada ou liberada em sequências designadas.

Chaves

Além das teclas representadas pelo Unicode regular, valores Unicode foram atribuídos a outras teclas de teclado para uso com o Selenium. Cada linguagem tem sua própria maneira de fazer referência a essas teclas; a lista completa pode ser encontrada aqui.

Use the [Java Keys enum](https://github.com/SeleniumHQ/selenium/blob/selenium-4.2.0/java/src/org/openqa/selenium/Keys.java#L28)
Use the [Python Keys class](https://github.com/SeleniumHQ/selenium/blob/selenium-4.2.0/py/selenium/webdriver/common/keys.py#L23)
Use the [.NET static Keys class](https://github.com/SeleniumHQ/selenium/blob/selenium-4.2.0/dotnet/src/webdriver/Keys.cs#L28)
Use the [Ruby KEYS constant](https://github.com/SeleniumHQ/selenium/blob/selenium-4.2.0/rb/lib/selenium/webdriver/common/keys.rb#L28)
Use the [JavaScript KEYS constant](https://github.com/SeleniumHQ/selenium/blob/selenium-4.2.0/javascript/node/selenium-webdriver/lib/input.js#L44)
Use the [Java Keys enum](https://github.com/SeleniumHQ/selenium/blob/selenium-4.2.0/java/src/org/openqa/selenium/Keys.java#L28)

Pressione a tecla

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform();
Show full example
package dev.selenium.actions_api;

import dev.selenium.BaseChromeTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.Platform;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;

public class KeysTest extends BaseChromeTest {
    @Test
    public void keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("A", textField.getAttribute("value"));
    }

    @Test
    public void keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("Ab", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .sendKeys("abc")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("abc", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");
        driver.findElement(By.tagName("body")).click();

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform();

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"));
    }

    @Test
    public void copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        Keys cmdCtrl = Platform.getCurrent().is(Platform.MAC) ? Keys.COMMAND : Keys.CONTROL;

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform();

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"));
    }
}
View full example on GitHub
    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("abc")\
        .perform()
Show full example
import sys

from selenium.webdriver import Keys, ActionChains
from selenium.webdriver.common.by import By


def test_key_down(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "ABC"


def test_key_up(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("a")\
        .key_up(Keys.SHIFT)\
        .send_keys("b")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "Ab"


def test_send_keys_to_active_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_send_keys_to_designated_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    driver.find_element(By.TAG_NAME, "body").click()

    text_input = driver.find_element(By.ID, "textInput")
    ActionChains(driver)\
        .send_keys_to_element(text_input, "abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_copy_and_paste(firefox_driver):
    driver = firefox_driver
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    cmd_ctrl = Keys.COMMAND if sys.platform == 'darwin' else Keys.CONTROL

    ActionChains(driver)\
        .send_keys("Selenium!")\
        .send_keys(Keys.ARROW_LEFT)\
        .key_down(Keys.SHIFT)\
        .send_keys(Keys.ARROW_UP)\
        .key_up(Keys.SHIFT)\
        .key_down(cmd_ctrl)\
        .send_keys("xvv")\
        .key_up(cmd_ctrl)\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "SeleniumSelenium!"
View full example on GitHub
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .Perform();
Show full example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Interactions;

namespace SeleniumDocs.ActionsAPI
{
    [TestClass]
    public class KeysTest : BaseFirefoxTest
    {
        [TestMethod]
        public void KeyDown()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("A", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void KeyUp()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .KeyUp(Keys.Shift)
                .SendKeys("b")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("Ab", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToActiveElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .SendKeys("abc")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToDesignatedElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";
            driver.FindElement(By.TagName("body")).Click();
            
            IWebElement textField = driver.FindElement(By.Id("textInput"));
            new Actions(driver)
                .SendKeys(textField, "abc")
                .Perform();

            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void CopyAndPaste()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            var capabilities = ((WebDriver)driver).Capabilities;
            String platformName = (string)capabilities.GetCapability("platformName");

            String cmdCtrl = platformName.Contains("mac") ? Keys.Command : Keys.Control;

            new Actions(driver)
                .SendKeys("Selenium!")
                .SendKeys(Keys.ArrowLeft)
                .KeyDown(Keys.Shift)
                .SendKeys(Keys.ArrowUp)
                .KeyUp(Keys.Shift)
                .KeyDown(cmdCtrl)
                .SendKeys("xvv")
                .KeyUp(cmdCtrl)
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("SeleniumSelenium!", textField.GetAttribute("value"));
        }
    }
}
View full example on GitHub
    driver.action
          .key_down(:shift)
          .send_keys('a')
          .perform
Show full example
# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Keys' do
  let(:driver) { start_session }
  let(:wait) { Selenium::WebDriver::Wait.new(timeout: 2) }

  it 'key down' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'A'
  end

  it 'key up' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .key_up(:shift)
          .send_keys('b')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'Ab'
  end

  it 'sends keys to active element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .send_keys('abc')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'abc'
  end

  it 'sends keys to designated element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    driver.find_element(tag_name: 'body').click
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    text_field = driver.find_element(id: 'textInput')
    driver.action
          .send_keys(text_field, 'Selenium!')
          .perform

    expect(text_field.attribute('value')).to eq 'Selenium!'
  end

  it 'copy and paste' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    cmd_ctrl = driver.capabilities.platform_name.include?('mac') ? :command : :control
    driver.action
          .send_keys('Selenium!')
          .send_keys(:arrow_left)
          .key_down(:shift)
          .send_keys(:arrow_up)
          .key_up(:shift)
          .key_down(cmd_ctrl)
          .send_keys('xvv')
          .key_up(cmd_ctrl)
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'SeleniumSelenium!'
  end
end
View full example on GitHub
    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .perform()
Show full example
const { By, Key, Browser, Builder} = require('selenium-webdriver')
const assert = require('assert')
const { platform } = require('node:process')

describe('Keyboard Action - Keys test', function() {
  let driver

  before(async function() {
    driver = await new Builder().forBrowser('chrome').build();
  })

  after(async () => await driver.quit())

  it('KeyDown', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .perform()

    const textField = driver.findElement(By.id('textInput'))
    assert.deepStrictEqual(await textField.getAttribute('value'), 'A')
  })

  it('KeyUp', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .keyUp(Key.SHIFT)
      .sendKeys('b')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'Ab')
  })

  it('sendKeys', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .sendKeys('abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Designated Element', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.findElement(By.css('body')).click()
    const textField = await driver.findElement(By.id('textInput'))

    await driver.actions()
      .sendKeys(textField, 'abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Copy and Paste', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = await driver.findElement(By.id('textInput'))

    const cmdCtrl = platform.includes('darwin') ? Key.COMMAND : Key.CONTROL

    await driver.actions()
      .click(textField)
      .sendKeys('Selenium!')
      .sendKeys(Key.ARROW_LEFT)
      .keyDown(Key.SHIFT)
      .sendKeys(Key.ARROW_UP)
      .keyUp(Key.SHIFT)
      .keyDown(cmdCtrl)
      .sendKeys('xvv')
      .keyUp(cmdCtrl)
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'SeleniumSelenium!')
  })
})
View full example on GitHub
        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform()
Show full example
package dev.selenium.actions_api

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.openqa.selenium.By
import org.openqa.selenium.HasCapabilities
import org.openqa.selenium.Keys
import org.openqa.selenium.Platform
import org.openqa.selenium.WebElement
import org.openqa.selenium.interactions.Actions

class KeysTest : BaseTest() {

    @Test
    fun keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("A", textField.getAttribute("value"))
    }

    @Test
    fun keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("Ab", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .sendKeys("abc")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("abc", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")
        driver.findElement(By.tagName("body")).click()

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform()

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"))
    }

    @Test
    fun copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        val platformName = (driver as HasCapabilities).getCapabilities().getPlatformName()

        val cmdCtrl = if(platformName == Platform.MAC) Keys.COMMAND else Keys.CONTROL

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform()

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"))
    }
}
View full example on GitHub

Liberar a tecla

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform();
Show full example
package dev.selenium.actions_api;

import dev.selenium.BaseChromeTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.Platform;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;

public class KeysTest extends BaseChromeTest {
    @Test
    public void keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("A", textField.getAttribute("value"));
    }

    @Test
    public void keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("Ab", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .sendKeys("abc")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("abc", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");
        driver.findElement(By.tagName("body")).click();

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform();

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"));
    }

    @Test
    public void copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        Keys cmdCtrl = Platform.getCurrent().is(Platform.MAC) ? Keys.COMMAND : Keys.CONTROL;

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform();

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"));
    }
}
View full example on GitHub
    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("a")\
        .key_up(Keys.SHIFT)\
        .send_keys("b")\
        .perform()
Show full example
import sys

from selenium.webdriver import Keys, ActionChains
from selenium.webdriver.common.by import By


def test_key_down(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "ABC"


def test_key_up(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("a")\
        .key_up(Keys.SHIFT)\
        .send_keys("b")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "Ab"


def test_send_keys_to_active_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_send_keys_to_designated_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    driver.find_element(By.TAG_NAME, "body").click()

    text_input = driver.find_element(By.ID, "textInput")
    ActionChains(driver)\
        .send_keys_to_element(text_input, "abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_copy_and_paste(firefox_driver):
    driver = firefox_driver
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    cmd_ctrl = Keys.COMMAND if sys.platform == 'darwin' else Keys.CONTROL

    ActionChains(driver)\
        .send_keys("Selenium!")\
        .send_keys(Keys.ARROW_LEFT)\
        .key_down(Keys.SHIFT)\
        .send_keys(Keys.ARROW_UP)\
        .key_up(Keys.SHIFT)\
        .key_down(cmd_ctrl)\
        .send_keys("xvv")\
        .key_up(cmd_ctrl)\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "SeleniumSelenium!"
View full example on GitHub
            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .KeyUp(Keys.Shift)
                .SendKeys("b")
                .Perform();
Show full example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Interactions;

namespace SeleniumDocs.ActionsAPI
{
    [TestClass]
    public class KeysTest : BaseFirefoxTest
    {
        [TestMethod]
        public void KeyDown()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("A", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void KeyUp()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .KeyUp(Keys.Shift)
                .SendKeys("b")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("Ab", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToActiveElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .SendKeys("abc")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToDesignatedElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";
            driver.FindElement(By.TagName("body")).Click();
            
            IWebElement textField = driver.FindElement(By.Id("textInput"));
            new Actions(driver)
                .SendKeys(textField, "abc")
                .Perform();

            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void CopyAndPaste()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            var capabilities = ((WebDriver)driver).Capabilities;
            String platformName = (string)capabilities.GetCapability("platformName");

            String cmdCtrl = platformName.Contains("mac") ? Keys.Command : Keys.Control;

            new Actions(driver)
                .SendKeys("Selenium!")
                .SendKeys(Keys.ArrowLeft)
                .KeyDown(Keys.Shift)
                .SendKeys(Keys.ArrowUp)
                .KeyUp(Keys.Shift)
                .KeyDown(cmdCtrl)
                .SendKeys("xvv")
                .KeyUp(cmdCtrl)
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("SeleniumSelenium!", textField.GetAttribute("value"));
        }
    }
}
View full example on GitHub
    driver.action
          .key_down(:shift)
          .send_keys('a')
          .key_up(:shift)
          .send_keys('b')
          .perform
Show full example
# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Keys' do
  let(:driver) { start_session }
  let(:wait) { Selenium::WebDriver::Wait.new(timeout: 2) }

  it 'key down' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'A'
  end

  it 'key up' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .key_up(:shift)
          .send_keys('b')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'Ab'
  end

  it 'sends keys to active element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .send_keys('abc')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'abc'
  end

  it 'sends keys to designated element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    driver.find_element(tag_name: 'body').click
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    text_field = driver.find_element(id: 'textInput')
    driver.action
          .send_keys(text_field, 'Selenium!')
          .perform

    expect(text_field.attribute('value')).to eq 'Selenium!'
  end

  it 'copy and paste' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    cmd_ctrl = driver.capabilities.platform_name.include?('mac') ? :command : :control
    driver.action
          .send_keys('Selenium!')
          .send_keys(:arrow_left)
          .key_down(:shift)
          .send_keys(:arrow_up)
          .key_up(:shift)
          .key_down(cmd_ctrl)
          .send_keys('xvv')
          .key_up(cmd_ctrl)
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'SeleniumSelenium!'
  end
end
View full example on GitHub
    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .keyUp(Key.SHIFT)
      .sendKeys('b')
      .perform()
Show full example
const { By, Key, Browser, Builder} = require('selenium-webdriver')
const assert = require('assert')
const { platform } = require('node:process')

describe('Keyboard Action - Keys test', function() {
  let driver

  before(async function() {
    driver = await new Builder().forBrowser('chrome').build();
  })

  after(async () => await driver.quit())

  it('KeyDown', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .perform()

    const textField = driver.findElement(By.id('textInput'))
    assert.deepStrictEqual(await textField.getAttribute('value'), 'A')
  })

  it('KeyUp', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .keyUp(Key.SHIFT)
      .sendKeys('b')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'Ab')
  })

  it('sendKeys', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .sendKeys('abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Designated Element', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.findElement(By.css('body')).click()
    const textField = await driver.findElement(By.id('textInput'))

    await driver.actions()
      .sendKeys(textField, 'abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Copy and Paste', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = await driver.findElement(By.id('textInput'))

    const cmdCtrl = platform.includes('darwin') ? Key.COMMAND : Key.CONTROL

    await driver.actions()
      .click(textField)
      .sendKeys('Selenium!')
      .sendKeys(Key.ARROW_LEFT)
      .keyDown(Key.SHIFT)
      .sendKeys(Key.ARROW_UP)
      .keyUp(Key.SHIFT)
      .keyDown(cmdCtrl)
      .sendKeys('xvv')
      .keyUp(cmdCtrl)
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'SeleniumSelenium!')
  })
})
View full example on GitHub
        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform()
Show full example
package dev.selenium.actions_api

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.openqa.selenium.By
import org.openqa.selenium.HasCapabilities
import org.openqa.selenium.Keys
import org.openqa.selenium.Platform
import org.openqa.selenium.WebElement
import org.openqa.selenium.interactions.Actions

class KeysTest : BaseTest() {

    @Test
    fun keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("A", textField.getAttribute("value"))
    }

    @Test
    fun keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("Ab", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .sendKeys("abc")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("abc", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")
        driver.findElement(By.tagName("body")).click()

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform()

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"))
    }

    @Test
    fun copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        val platformName = (driver as HasCapabilities).getCapabilities().getPlatformName()

        val cmdCtrl = if(platformName == Platform.MAC) Keys.COMMAND else Keys.CONTROL

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform()

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"))
    }
}
View full example on GitHub

Enviar teclas

This is a convenience method in the Actions API that combines keyDown and keyUp commands in one action. Executing this command differs slightly from using the element method, but primarily this gets used when needing to type multiple characters in the middle of other actions.

Elemento Ativo

        new Actions(driver)
                .sendKeys("abc")
                .perform();
Show full example
package dev.selenium.actions_api;

import dev.selenium.BaseChromeTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.Platform;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;

public class KeysTest extends BaseChromeTest {
    @Test
    public void keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("A", textField.getAttribute("value"));
    }

    @Test
    public void keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("Ab", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .sendKeys("abc")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("abc", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");
        driver.findElement(By.tagName("body")).click();

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform();

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"));
    }

    @Test
    public void copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        Keys cmdCtrl = Platform.getCurrent().is(Platform.MAC) ? Keys.COMMAND : Keys.CONTROL;

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform();

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"));
    }
}
View full example on GitHub
    ActionChains(driver)\
        .send_keys("abc")\
        .perform()
Show full example
import sys

from selenium.webdriver import Keys, ActionChains
from selenium.webdriver.common.by import By


def test_key_down(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "ABC"


def test_key_up(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("a")\
        .key_up(Keys.SHIFT)\
        .send_keys("b")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "Ab"


def test_send_keys_to_active_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_send_keys_to_designated_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    driver.find_element(By.TAG_NAME, "body").click()

    text_input = driver.find_element(By.ID, "textInput")
    ActionChains(driver)\
        .send_keys_to_element(text_input, "abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_copy_and_paste(firefox_driver):
    driver = firefox_driver
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    cmd_ctrl = Keys.COMMAND if sys.platform == 'darwin' else Keys.CONTROL

    ActionChains(driver)\
        .send_keys("Selenium!")\
        .send_keys(Keys.ARROW_LEFT)\
        .key_down(Keys.SHIFT)\
        .send_keys(Keys.ARROW_UP)\
        .key_up(Keys.SHIFT)\
        .key_down(cmd_ctrl)\
        .send_keys("xvv")\
        .key_up(cmd_ctrl)\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "SeleniumSelenium!"
View full example on GitHub

            new Actions(driver)
                .SendKeys("abc")
Show full example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Interactions;

namespace SeleniumDocs.ActionsAPI
{
    [TestClass]
    public class KeysTest : BaseFirefoxTest
    {
        [TestMethod]
        public void KeyDown()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("A", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void KeyUp()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .KeyUp(Keys.Shift)
                .SendKeys("b")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("Ab", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToActiveElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .SendKeys("abc")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToDesignatedElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";
            driver.FindElement(By.TagName("body")).Click();
            
            IWebElement textField = driver.FindElement(By.Id("textInput"));
            new Actions(driver)
                .SendKeys(textField, "abc")
                .Perform();

            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void CopyAndPaste()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            var capabilities = ((WebDriver)driver).Capabilities;
            String platformName = (string)capabilities.GetCapability("platformName");

            String cmdCtrl = platformName.Contains("mac") ? Keys.Command : Keys.Control;

            new Actions(driver)
                .SendKeys("Selenium!")
                .SendKeys(Keys.ArrowLeft)
                .KeyDown(Keys.Shift)
                .SendKeys(Keys.ArrowUp)
                .KeyUp(Keys.Shift)
                .KeyDown(cmdCtrl)
                .SendKeys("xvv")
                .KeyUp(cmdCtrl)
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("SeleniumSelenium!", textField.GetAttribute("value"));
        }
    }
}
View full example on GitHub
    driver.action
          .send_keys('abc')
          .perform
Show full example
# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Keys' do
  let(:driver) { start_session }
  let(:wait) { Selenium::WebDriver::Wait.new(timeout: 2) }

  it 'key down' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'A'
  end

  it 'key up' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .key_up(:shift)
          .send_keys('b')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'Ab'
  end

  it 'sends keys to active element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .send_keys('abc')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'abc'
  end

  it 'sends keys to designated element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    driver.find_element(tag_name: 'body').click
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    text_field = driver.find_element(id: 'textInput')
    driver.action
          .send_keys(text_field, 'Selenium!')
          .perform

    expect(text_field.attribute('value')).to eq 'Selenium!'
  end

  it 'copy and paste' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    cmd_ctrl = driver.capabilities.platform_name.include?('mac') ? :command : :control
    driver.action
          .send_keys('Selenium!')
          .send_keys(:arrow_left)
          .key_down(:shift)
          .send_keys(:arrow_up)
          .key_up(:shift)
          .key_down(cmd_ctrl)
          .send_keys('xvv')
          .key_up(cmd_ctrl)
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'SeleniumSelenium!'
  end
end
View full example on GitHub
    await driver.actions()
      .sendKeys('abc')
      .perform()
Show full example
const { By, Key, Browser, Builder} = require('selenium-webdriver')
const assert = require('assert')
const { platform } = require('node:process')

describe('Keyboard Action - Keys test', function() {
  let driver

  before(async function() {
    driver = await new Builder().forBrowser('chrome').build();
  })

  after(async () => await driver.quit())

  it('KeyDown', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .perform()

    const textField = driver.findElement(By.id('textInput'))
    assert.deepStrictEqual(await textField.getAttribute('value'), 'A')
  })

  it('KeyUp', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .keyUp(Key.SHIFT)
      .sendKeys('b')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'Ab')
  })

  it('sendKeys', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .sendKeys('abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Designated Element', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.findElement(By.css('body')).click()
    const textField = await driver.findElement(By.id('textInput'))

    await driver.actions()
      .sendKeys(textField, 'abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Copy and Paste', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = await driver.findElement(By.id('textInput'))

    const cmdCtrl = platform.includes('darwin') ? Key.COMMAND : Key.CONTROL

    await driver.actions()
      .click(textField)
      .sendKeys('Selenium!')
      .sendKeys(Key.ARROW_LEFT)
      .keyDown(Key.SHIFT)
      .sendKeys(Key.ARROW_UP)
      .keyUp(Key.SHIFT)
      .keyDown(cmdCtrl)
      .sendKeys('xvv')
      .keyUp(cmdCtrl)
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'SeleniumSelenium!')
  })
})
View full example on GitHub
        Actions(driver)
                .sendKeys("abc")
                .perform()
Show full example
package dev.selenium.actions_api

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.openqa.selenium.By
import org.openqa.selenium.HasCapabilities
import org.openqa.selenium.Keys
import org.openqa.selenium.Platform
import org.openqa.selenium.WebElement
import org.openqa.selenium.interactions.Actions

class KeysTest : BaseTest() {

    @Test
    fun keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("A", textField.getAttribute("value"))
    }

    @Test
    fun keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("Ab", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .sendKeys("abc")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("abc", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")
        driver.findElement(By.tagName("body")).click()

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform()

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"))
    }

    @Test
    fun copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        val platformName = (driver as HasCapabilities).getCapabilities().getPlatformName()

        val cmdCtrl = if(platformName == Platform.MAC) Keys.COMMAND else Keys.CONTROL

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform()

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"))
    }
}
View full example on GitHub

Elemento Designado

        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform();
Show full example
package dev.selenium.actions_api;

import dev.selenium.BaseChromeTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.Platform;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;

public class KeysTest extends BaseChromeTest {
    @Test
    public void keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("A", textField.getAttribute("value"));
    }

    @Test
    public void keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("Ab", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .sendKeys("abc")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("abc", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");
        driver.findElement(By.tagName("body")).click();

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform();

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"));
    }

    @Test
    public void copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        Keys cmdCtrl = Platform.getCurrent().is(Platform.MAC) ? Keys.COMMAND : Keys.CONTROL;

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform();

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"));
    }
}
View full example on GitHub
    text_input = driver.find_element(By.ID, "textInput")
    ActionChains(driver)\
        .send_keys_to_element(text_input, "abc")\
        .perform()
Show full example
import sys

from selenium.webdriver import Keys, ActionChains
from selenium.webdriver.common.by import By


def test_key_down(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "ABC"


def test_key_up(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("a")\
        .key_up(Keys.SHIFT)\
        .send_keys("b")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "Ab"


def test_send_keys_to_active_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_send_keys_to_designated_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    driver.find_element(By.TAG_NAME, "body").click()

    text_input = driver.find_element(By.ID, "textInput")
    ActionChains(driver)\
        .send_keys_to_element(text_input, "abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_copy_and_paste(firefox_driver):
    driver = firefox_driver
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    cmd_ctrl = Keys.COMMAND if sys.platform == 'darwin' else Keys.CONTROL

    ActionChains(driver)\
        .send_keys("Selenium!")\
        .send_keys(Keys.ARROW_LEFT)\
        .key_down(Keys.SHIFT)\
        .send_keys(Keys.ARROW_UP)\
        .key_up(Keys.SHIFT)\
        .key_down(cmd_ctrl)\
        .send_keys("xvv")\
        .key_up(cmd_ctrl)\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "SeleniumSelenium!"
View full example on GitHub
            driver.FindElement(By.TagName("body")).Click();
            
            IWebElement textField = driver.FindElement(By.Id("textInput"));
            new Actions(driver)
Show full example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Interactions;

namespace SeleniumDocs.ActionsAPI
{
    [TestClass]
    public class KeysTest : BaseFirefoxTest
    {
        [TestMethod]
        public void KeyDown()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("A", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void KeyUp()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .KeyUp(Keys.Shift)
                .SendKeys("b")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("Ab", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToActiveElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .SendKeys("abc")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToDesignatedElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";
            driver.FindElement(By.TagName("body")).Click();
            
            IWebElement textField = driver.FindElement(By.Id("textInput"));
            new Actions(driver)
                .SendKeys(textField, "abc")
                .Perform();

            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void CopyAndPaste()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            var capabilities = ((WebDriver)driver).Capabilities;
            String platformName = (string)capabilities.GetCapability("platformName");

            String cmdCtrl = platformName.Contains("mac") ? Keys.Command : Keys.Control;

            new Actions(driver)
                .SendKeys("Selenium!")
                .SendKeys(Keys.ArrowLeft)
                .KeyDown(Keys.Shift)
                .SendKeys(Keys.ArrowUp)
                .KeyUp(Keys.Shift)
                .KeyDown(cmdCtrl)
                .SendKeys("xvv")
                .KeyUp(cmdCtrl)
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("SeleniumSelenium!", textField.GetAttribute("value"));
        }
    }
}
View full example on GitHub
    text_field = driver.find_element(id: 'textInput')
    driver.action
          .send_keys(text_field, 'Selenium!')
          .perform
Show full example
# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Keys' do
  let(:driver) { start_session }
  let(:wait) { Selenium::WebDriver::Wait.new(timeout: 2) }

  it 'key down' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'A'
  end

  it 'key up' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .key_up(:shift)
          .send_keys('b')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'Ab'
  end

  it 'sends keys to active element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .send_keys('abc')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'abc'
  end

  it 'sends keys to designated element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    driver.find_element(tag_name: 'body').click
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    text_field = driver.find_element(id: 'textInput')
    driver.action
          .send_keys(text_field, 'Selenium!')
          .perform

    expect(text_field.attribute('value')).to eq 'Selenium!'
  end

  it 'copy and paste' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    cmd_ctrl = driver.capabilities.platform_name.include?('mac') ? :command : :control
    driver.action
          .send_keys('Selenium!')
          .send_keys(:arrow_left)
          .key_down(:shift)
          .send_keys(:arrow_up)
          .key_up(:shift)
          .key_down(cmd_ctrl)
          .send_keys('xvv')
          .key_up(cmd_ctrl)
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'SeleniumSelenium!'
  end
end
View full example on GitHub

Selenium v4.5.0

    const textField = await driver.findElement(By.id('textInput'))

    await driver.actions()
      .sendKeys(textField, 'abc')
      .perform()
Show full example
const { By, Key, Browser, Builder} = require('selenium-webdriver')
const assert = require('assert')
const { platform } = require('node:process')

describe('Keyboard Action - Keys test', function() {
  let driver

  before(async function() {
    driver = await new Builder().forBrowser('chrome').build();
  })

  after(async () => await driver.quit())

  it('KeyDown', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .perform()

    const textField = driver.findElement(By.id('textInput'))
    assert.deepStrictEqual(await textField.getAttribute('value'), 'A')
  })

  it('KeyUp', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .keyUp(Key.SHIFT)
      .sendKeys('b')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'Ab')
  })

  it('sendKeys', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .sendKeys('abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Designated Element', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.findElement(By.css('body')).click()
    const textField = await driver.findElement(By.id('textInput'))

    await driver.actions()
      .sendKeys(textField, 'abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Copy and Paste', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = await driver.findElement(By.id('textInput'))

    const cmdCtrl = platform.includes('darwin') ? Key.COMMAND : Key.CONTROL

    await driver.actions()
      .click(textField)
      .sendKeys('Selenium!')
      .sendKeys(Key.ARROW_LEFT)
      .keyDown(Key.SHIFT)
      .sendKeys(Key.ARROW_UP)
      .keyUp(Key.SHIFT)
      .keyDown(cmdCtrl)
      .sendKeys('xvv')
      .keyUp(cmdCtrl)
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'SeleniumSelenium!')
  })
})
View full example on GitHub
        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform()
Show full example
package dev.selenium.actions_api

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.openqa.selenium.By
import org.openqa.selenium.HasCapabilities
import org.openqa.selenium.Keys
import org.openqa.selenium.Platform
import org.openqa.selenium.WebElement
import org.openqa.selenium.interactions.Actions

class KeysTest : BaseTest() {

    @Test
    fun keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("A", textField.getAttribute("value"))
    }

    @Test
    fun keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("Ab", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .sendKeys("abc")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("abc", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")
        driver.findElement(By.tagName("body")).click()

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform()

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"))
    }

    @Test
    fun copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        val platformName = (driver as HasCapabilities).getCapabilities().getPlatformName()

        val cmdCtrl = if(platformName == Platform.MAC) Keys.COMMAND else Keys.CONTROL

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform()

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"))
    }
}
View full example on GitHub

Copiar e Colar

Aqui está um exemplo de uso de todos os métodos acima para realizar uma ação de copiar/colar. Note que a tecla a ser usada para essa operação será diferente, dependendo se for um sistema Mac OS ou não. Este código resultará no texto: SeleniumSelenium!

        Keys cmdCtrl = Platform.getCurrent().is(Platform.MAC) ? Keys.COMMAND : Keys.CONTROL;

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform();

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"));
Show full example
package dev.selenium.actions_api;

import dev.selenium.BaseChromeTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.Platform;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;

public class KeysTest extends BaseChromeTest {
    @Test
    public void keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("A", textField.getAttribute("value"));
    }

    @Test
    public void keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("Ab", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        new Actions(driver)
                .sendKeys("abc")
                .perform();

        WebElement textField = driver.findElement(By.id("textInput"));
        Assertions.assertEquals("abc", textField.getAttribute("value"));
    }

    @Test
    public void sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");
        driver.findElement(By.tagName("body")).click();

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform();

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"));
    }

    @Test
    public void copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html");

        Keys cmdCtrl = Platform.getCurrent().is(Platform.MAC) ? Keys.COMMAND : Keys.CONTROL;

        WebElement textField = driver.findElement(By.id("textInput"));
        new Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform();

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"));
    }
}
View full example on GitHub
    cmd_ctrl = Keys.COMMAND if sys.platform == 'darwin' else Keys.CONTROL

    ActionChains(driver)\
        .send_keys("Selenium!")\
        .send_keys(Keys.ARROW_LEFT)\
        .key_down(Keys.SHIFT)\
        .send_keys(Keys.ARROW_UP)\
        .key_up(Keys.SHIFT)\
        .key_down(cmd_ctrl)\
        .send_keys("xvv")\
        .key_up(cmd_ctrl)\
        .perform()
Show full example
import sys

from selenium.webdriver import Keys, ActionChains
from selenium.webdriver.common.by import By


def test_key_down(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "ABC"


def test_key_up(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .key_down(Keys.SHIFT)\
        .send_keys("a")\
        .key_up(Keys.SHIFT)\
        .send_keys("b")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "Ab"


def test_send_keys_to_active_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')

    ActionChains(driver)\
        .send_keys("abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_send_keys_to_designated_element(driver):
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    driver.find_element(By.TAG_NAME, "body").click()

    text_input = driver.find_element(By.ID, "textInput")
    ActionChains(driver)\
        .send_keys_to_element(text_input, "abc")\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "abc"


def test_copy_and_paste(firefox_driver):
    driver = firefox_driver
    driver.get('https://selenium.dev/selenium/web/single_text_input.html')
    cmd_ctrl = Keys.COMMAND if sys.platform == 'darwin' else Keys.CONTROL

    ActionChains(driver)\
        .send_keys("Selenium!")\
        .send_keys(Keys.ARROW_LEFT)\
        .key_down(Keys.SHIFT)\
        .send_keys(Keys.ARROW_UP)\
        .key_up(Keys.SHIFT)\
        .key_down(cmd_ctrl)\
        .send_keys("xvv")\
        .key_up(cmd_ctrl)\
        .perform()

    assert driver.find_element(By.ID, "textInput").get_attribute('value') == "SeleniumSelenium!"
View full example on GitHub

            var capabilities = ((WebDriver)driver).Capabilities;
            String platformName = (string)capabilities.GetCapability("platformName");

            String cmdCtrl = platformName.Contains("mac") ? Keys.Command : Keys.Control;

            new Actions(driver)
                .SendKeys("Selenium!")
                .SendKeys(Keys.ArrowLeft)
                .KeyDown(Keys.Shift)
                .SendKeys(Keys.ArrowUp)
Show full example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Interactions;

namespace SeleniumDocs.ActionsAPI
{
    [TestClass]
    public class KeysTest : BaseFirefoxTest
    {
        [TestMethod]
        public void KeyDown()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("A", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void KeyUp()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .KeyDown(Keys.Shift)
                .SendKeys("a")
                .KeyUp(Keys.Shift)
                .SendKeys("b")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("Ab", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToActiveElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            new Actions(driver)
                .SendKeys("abc")
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }
        
        [TestMethod]
        public void SendKeysToDesignatedElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";
            driver.FindElement(By.TagName("body")).Click();
            
            IWebElement textField = driver.FindElement(By.Id("textInput"));
            new Actions(driver)
                .SendKeys(textField, "abc")
                .Perform();

            Assert.AreEqual("abc", textField.GetAttribute("value"));
        }

        [TestMethod]
        public void CopyAndPaste()
        {
            driver.Url = "https://selenium.dev/selenium/web/single_text_input.html";

            var capabilities = ((WebDriver)driver).Capabilities;
            String platformName = (string)capabilities.GetCapability("platformName");

            String cmdCtrl = platformName.Contains("mac") ? Keys.Command : Keys.Control;

            new Actions(driver)
                .SendKeys("Selenium!")
                .SendKeys(Keys.ArrowLeft)
                .KeyDown(Keys.Shift)
                .SendKeys(Keys.ArrowUp)
                .KeyUp(Keys.Shift)
                .KeyDown(cmdCtrl)
                .SendKeys("xvv")
                .KeyUp(cmdCtrl)
                .Perform();

            IWebElement textField = driver.FindElement(By.Id("textInput"));
            Assert.AreEqual("SeleniumSelenium!", textField.GetAttribute("value"));
        }
    }
}
View full example on GitHub
    driver.action
          .send_keys('Selenium!')
          .send_keys(:arrow_left)
          .key_down(:shift)
          .send_keys(:arrow_up)
          .key_up(:shift)
          .key_down(cmd_ctrl)
          .send_keys('xvv')
          .key_up(cmd_ctrl)
          .perform
Show full example
# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Keys' do
  let(:driver) { start_session }
  let(:wait) { Selenium::WebDriver::Wait.new(timeout: 2) }

  it 'key down' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'A'
  end

  it 'key up' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .key_down(:shift)
          .send_keys('a')
          .key_up(:shift)
          .send_keys('b')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'Ab'
  end

  it 'sends keys to active element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    driver.action
          .send_keys('abc')
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'abc'
  end

  it 'sends keys to designated element' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    driver.find_element(tag_name: 'body').click
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    text_field = driver.find_element(id: 'textInput')
    driver.action
          .send_keys(text_field, 'Selenium!')
          .perform

    expect(text_field.attribute('value')).to eq 'Selenium!'
  end

  it 'copy and paste' do
    driver.get 'https://www.selenium.dev/selenium/web/single_text_input.html'
    wait.until { driver.find_element(id: 'textInput').attribute('autofocus') }

    cmd_ctrl = driver.capabilities.platform_name.include?('mac') ? :command : :control
    driver.action
          .send_keys('Selenium!')
          .send_keys(:arrow_left)
          .key_down(:shift)
          .send_keys(:arrow_up)
          .key_up(:shift)
          .key_down(cmd_ctrl)
          .send_keys('xvv')
          .key_up(cmd_ctrl)
          .perform

    expect(driver.find_element(id: 'textInput').attribute('value')).to eq 'SeleniumSelenium!'
  end
end
View full example on GitHub
    const cmdCtrl = platform.includes('darwin') ? Key.COMMAND : Key.CONTROL

    await driver.actions()
      .click(textField)
      .sendKeys('Selenium!')
      .sendKeys(Key.ARROW_LEFT)
      .keyDown(Key.SHIFT)
      .sendKeys(Key.ARROW_UP)
      .keyUp(Key.SHIFT)
      .keyDown(cmdCtrl)
      .sendKeys('xvv')
      .keyUp(cmdCtrl)
      .perform()
Show full example
const { By, Key, Browser, Builder} = require('selenium-webdriver')
const assert = require('assert')
const { platform } = require('node:process')

describe('Keyboard Action - Keys test', function() {
  let driver

  before(async function() {
    driver = await new Builder().forBrowser('chrome').build();
  })

  after(async () => await driver.quit())

  it('KeyDown', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .perform()

    const textField = driver.findElement(By.id('textInput'))
    assert.deepStrictEqual(await textField.getAttribute('value'), 'A')
  })

  it('KeyUp', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .keyDown(Key.SHIFT)
      .sendKeys('a')
      .keyUp(Key.SHIFT)
      .sendKeys('b')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'Ab')
  })

  it('sendKeys', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = driver.findElement(By.id('textInput'))
    await textField.click()

    await driver.actions()
      .sendKeys('abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Designated Element', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    await driver.findElement(By.css('body')).click()
    const textField = await driver.findElement(By.id('textInput'))

    await driver.actions()
      .sendKeys(textField, 'abc')
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'abc')
  })

  it('Copy and Paste', async function() {
    await driver.get('https://www.selenium.dev/selenium/web/single_text_input.html')

    const textField = await driver.findElement(By.id('textInput'))

    const cmdCtrl = platform.includes('darwin') ? Key.COMMAND : Key.CONTROL

    await driver.actions()
      .click(textField)
      .sendKeys('Selenium!')
      .sendKeys(Key.ARROW_LEFT)
      .keyDown(Key.SHIFT)
      .sendKeys(Key.ARROW_UP)
      .keyUp(Key.SHIFT)
      .keyDown(cmdCtrl)
      .sendKeys('xvv')
      .keyUp(cmdCtrl)
      .perform()

    assert.deepStrictEqual(await textField.getAttribute('value'), 'SeleniumSelenium!')
  })
})
View full example on GitHub
        val cmdCtrl = if(platformName == Platform.MAC) Keys.COMMAND else Keys.CONTROL

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform()
Show full example
package dev.selenium.actions_api

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.openqa.selenium.By
import org.openqa.selenium.HasCapabilities
import org.openqa.selenium.Keys
import org.openqa.selenium.Platform
import org.openqa.selenium.WebElement
import org.openqa.selenium.interactions.Actions

class KeysTest : BaseTest() {

    @Test
    fun keyDown() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("A", textField.getAttribute("value"))
    }

    @Test
    fun keyUp() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .keyDown(Keys.SHIFT)
                .sendKeys("a")
                .keyUp(Keys.SHIFT)
                .sendKeys("b")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("Ab", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToActiveElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        Actions(driver)
                .sendKeys("abc")
                .perform()

        val textField = driver.findElement(By.id("textInput"))
        Assertions.assertEquals("abc", textField.getAttribute("value"))
    }

    @Test
    fun sendKeysToDesignatedElement() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")
        driver.findElement(By.tagName("body")).click()

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .perform()

        Assertions.assertEquals("Selenium!", textField.getAttribute("value"))
    }

    @Test
    fun copyAndPaste() {
        driver.get("https://www.selenium.dev/selenium/web/single_text_input.html")

        val platformName = (driver as HasCapabilities).getCapabilities().getPlatformName()

        val cmdCtrl = if(platformName == Platform.MAC) Keys.COMMAND else Keys.CONTROL

        val textField = driver.findElement(By.id("textInput"))
        Actions(driver)
                .sendKeys(textField, "Selenium!")
                .sendKeys(Keys.ARROW_LEFT)
                .keyDown(Keys.SHIFT)
                .sendKeys(Keys.ARROW_UP)
                .keyUp(Keys.SHIFT)
                .keyDown(cmdCtrl)
                .sendKeys("xvv")
                .keyUp(cmdCtrl)
                .perform()

        Assertions.assertEquals("SeleniumSelenium!", textField.getAttribute("value"))
    }
}
View full example on GitHub
Última modificação August 4, 2024: refactor[js]: update code samples to use mocha and update docs (4e38f3fbcd)