Keyboard actions (keyDown, keyUp) in Selenium Java - Build an Automation Script

Test keyboard actions keyDown and keyUp on input field

Preconditions (2)

Step 1: Open the browser and navigate to http://example.com/keyboard-test

Step 2: Locate the input field with id 'input-box'

Step 3: Click on the input field to focus

Step 4: Press and hold the SHIFT key (keyDown)

Step 5: Type the letters 'abc' while SHIFT is held down

Step 6: Release the SHIFT key (keyUp)

Step 7: Verify that the input field contains 'ABC'

✅ Expected Result: The input field should contain the uppercase text 'ABC' after typing with SHIFT key held down.

Automation Requirements - Selenium WebDriver with Java

Assertions Needed:

Verify the input field text equals 'ABC'

Best Practices:

Use Actions class for keyboard events

Use explicit waits to ensure elements are interactable

Use By.id locator for the input field

Close the browser after test execution

Automated Solution

Selenium Java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class KeyboardActionsTest {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        WebDriver driver = new ChromeDriver();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        try {
            driver.get("http://example.com/keyboard-test");

            WebElement inputBox = wait.until(ExpectedConditions.elementToBeClickable(By.id("input-box")));
            inputBox.click();

            Actions actions = new Actions(driver);
            actions.keyDown(inputBox, org.openqa.selenium.Keys.SHIFT)
                   .sendKeys(inputBox, "abc")
                   .keyUp(inputBox, org.openqa.selenium.Keys.SHIFT)
                   .perform();

            String enteredText = inputBox.getAttribute("value");
            assertEquals("ABC", enteredText, "Input text should be uppercase 'ABC'");
        } finally {
            driver.quit();
        }
    }
}

This test script uses Selenium WebDriver with Java to automate keyboard actions.

First, it opens the browser and navigates to the test page.

It waits explicitly for the input field with id 'input-box' to be clickable, then clicks it to focus.

Using the Actions class, it presses and holds the SHIFT key (keyDown), types 'abc', then releases the SHIFT key (keyUp).

This simulates typing uppercase letters because SHIFT is held down.

Finally, it retrieves the input field's value and asserts it equals 'ABC'.

The browser closes after the test to clean up.

Common Mistakes - 4 Pitfalls

Using Thread.sleep instead of explicit waits

Not focusing the input field before sending keys

{'mistake': 'Using sendKeys without keyDown and keyUp for SHIFT', 'why_bad': "Typing 'abc' without SHIFT keyDown will input lowercase letters, not uppercase.", 'correct_approach': 'Use Actions.keyDown(Keys.SHIFT) before sendKeys and keyUp(Keys.SHIFT) after to simulate holding SHIFT.'}

Using incorrect locator strategies like XPath with absolute paths

Bonus Challenge

Now add data-driven testing with 3 different input strings: 'abc', 'def', 'ghi' to verify uppercase conversion.

Show Hint

Practice

1. What does the keyDown method do in Selenium keyboard actions?

easy

A. Types text into an input field

B. Releases a specified key

C. Presses and holds down a specified key

D. Clicks on a web element

Solution

1. Step 1: Understand the purpose of keyDown

   The keyDown method simulates pressing and holding a key on the keyboard.

2. Step 2: Differentiate from keyUp

   keyUp releases the key, so it is not the same as keyDown.

3. Final Answer:

   Presses and holds down a specified key -> Option C

4. Quick Check:

   keyDown = press and hold key [OK]

Hint: Remember: keyDown = press and hold key [OK]

Common Mistakes:

• Confusing keyDown with keyUp
• Thinking keyDown types text
• Assuming keyDown clicks elements

2. Which of the following is the correct syntax to press and hold the SHIFT key using Selenium Actions in Java?

easy

A. actions.keyDown(Keys.SHIFT).perform();

B. actions.keyUp(Keys.SHIFT).perform();

C. actions.pressKey(Keys.SHIFT).perform();

D. actions.holdKey(Keys.SHIFT).perform();

Solution

1. Step 1: Recall the correct method name

   The method to press and hold a key is keyDown, not keyUp or others.

2. Step 2: Check method chaining and parameters

   The syntax actions.keyDown(Keys.SHIFT).perform(); correctly presses and holds SHIFT key.

3. Final Answer:

   actions.keyDown(Keys.SHIFT).perform(); -> Option A

4. Quick Check:

   keyDown + perform() = press and hold key [OK]

Hint: Use keyDown(Keys.KEY).perform() to hold keys [OK]

Common Mistakes:

• Using keyUp instead of keyDown to press key
• Using non-existent methods like pressKey or holdKey
• Forgetting to call perform() to execute action

3. What will be the effect of the following Selenium Java code snippet?

Actions actions = new Actions(driver);
actions.keyDown(Keys.CONTROL).sendKeys("a").keyUp(Keys.CONTROL).perform();

medium

A. Releases the CONTROL key before pressing 'a'

B. Types the letter 'a' without any modifier

C. Throws a runtime exception due to wrong method order

D. Selects all text on the active element

Solution

1. Step 1: Analyze the keyDown and sendKeys sequence

   The code presses and holds CONTROL, then sends 'a', then releases CONTROL.

2. Step 2: Understand the effect of CONTROL + 'a'

   CONTROL + 'a' is the common shortcut to select all text in many applications.

3. Final Answer:

   Selects all text on the active element -> Option D

4. Quick Check:

   CONTROL + a = select all [OK]

Hint: CONTROL + a usually means select all text [OK]

Common Mistakes:

• Thinking it types 'a' without CONTROL
• Assuming method order causes error
• Ignoring keyUp releases key after sendKeys

4. Identify the error in this Selenium Java code snippet:

Actions actions = new Actions(driver);
actions.keyUp(Keys.SHIFT).sendKeys("hello").perform();

medium

A. sendKeys cannot be chained after keyUp

B. keyUp is called without a preceding keyDown for SHIFT

C. perform() is missing at the end

D. Keys.SHIFT is not a valid key constant

Solution

1. Step 1: Understand keyUp usage

   keyUp releases a key that must have been pressed before with keyDown.

2. Step 2: Check the code sequence

   The code calls keyUp(Keys.SHIFT) without pressing SHIFT first, which is incorrect.

3. Final Answer:

   keyUp is called without a preceding keyDown for SHIFT -> Option B

4. Quick Check:

   keyUp needs prior keyDown [OK]

Hint: Always press keyDown before keyUp for same key [OK]

Common Mistakes:

• Calling keyUp without keyDown first
• Assuming sendKeys can't follow keyUp
• Forgetting perform() call

5. You want to simulate typing uppercase text "HELLO" in an input box using Selenium Actions. Which code snippet correctly achieves this using keyDown and keyUp?

hard

A. actions.keyDown(Keys.SHIFT).sendKeys("hello").keyUp(Keys.SHIFT).perform();

B. actions.sendKeys("HELLO").perform();

C. actions.keyDown(Keys.SHIFT).sendKeys("HELLO").keyUp(Keys.SHIFT).perform();

D. actions.keyUp(Keys.SHIFT).sendKeys("hello").keyDown(Keys.SHIFT).perform();

Solution

1. Step 1: Understand how to type uppercase with SHIFT

   Holding SHIFT and typing lowercase letters results in uppercase letters.

2. Step 2: Analyze each option

   actions.keyDown(Keys.SHIFT).sendKeys("hello").keyUp(Keys.SHIFT).perform(); holds SHIFT, types "hello" (lowercase), then releases SHIFT, producing "HELLO". actions.sendKeys("HELLO").perform(); types "HELLO" directly but does not use keyDown/keyUp. actions.keyDown(Keys.SHIFT).sendKeys("HELLO").keyUp(Keys.SHIFT).perform(); holds SHIFT and types "HELLO" which results in double shift effect (may cause unexpected input). actions.keyUp(Keys.SHIFT).sendKeys("hello").keyDown(Keys.SHIFT).perform(); releases SHIFT before typing, which is incorrect.

3. Final Answer:

   actions.keyDown(Keys.SHIFT).sendKeys("hello").keyUp(Keys.SHIFT).perform(); -> Option A

4. Quick Check:

   Hold SHIFT + lowercase = uppercase letters [OK]

Hint: Hold SHIFT and type lowercase to get uppercase [OK]

Common Mistakes:

• Typing uppercase letters while holding SHIFT
• Releasing SHIFT before typing
• Not using keyDown/keyUp for SHIFT