Tutorial On Handling Keyboard Actions In Selenium WebDriver [With Example]

Keyboard actions in Selenium using Actions Class

Action Class in Selenium is used for low-level interactive automation involving input devices like keyboard, mouse, etc. When using Selenium automation testing, it is recommended that Actions Class is used rather than using the input devices (e.g., keyboard, mouse) directly. Before an interaction is performed with the web element, the element should be a part of the DOM; else, the interaction might not be successful.

Watch this video to learn what the Actions Class is in Selenium and how to use it.

Some of the commonly used keyboard actions are KeyUp, KeyDown, and sendKeys(). Keyboard actions can also be used in combination with Mouse actions, e.g., Mouse Hover to a particular menu on the page and perform a combination of KeyUp & KeyDown on that menu. To perform keyboard actions in Selenium WebDriver, the Selenium ActionChains/Actions class should be imported into the source code.

Shown below is the definition of Selenium ActionChains class:

class selenium.webdriver.common.action_chains.ActionChains(driver)
    driver   - WebDriver instance which performs the user actions.

Since the Selenium ActionChains class is used to automate low-level mouse & keyboard interactions, it needs to queue the corresponding requests and execute those requests on a priority basis. For that purpose, the methods defined for actions on the ActionChains object are queued in the ActionChains object. For example, to refresh contents of the webpage, you can make use of the combination of (KeyUp + KeyDown) actions along with (CONTROL + F5) keys. The sample implementation is shown below.

ActionChains(driver)         .key_down(Keys.CONTROL)         .send_keys(Keys.F5)         .key_up(Keys.CONTROL)         .perform()

As seen in the snippet shown above, the actions are queued in the ActionChains object and a perform() is finally used to fire the actions that were queued in the object. A chain-based approach can also be used instead of a queue-based approach. Irrespective of the approach being used, the actions are fired in the order in which they were queued (like a FIFO).

Commonly used Keyboard events

Keyboard events can be used appropriately when Selenium is performed on the test web page/web application. Shown below are some of the commonly used keyboard events provided by the ActionChains class:

To use ActionChains for performing keyboard actions in Selenium WebDriver, you need to first import the ActionChains module.

Keyboard Actions – Demonstration

Now that we have looked at the basics of Keyboard actions, ActionChains class, and operations that can be performed using the keyboard, let’s look at examples that demonstrate its usage.

Keyboard Actions (send_keys)

To demonstrate Keyboard actions in Selenium automation testing, we use a simple example where search term, e.g., TestMu AI, is passed to the DuckDuckGo search engine. The inspect tool in Chrome (browser on which testing is performed) is used to get details about the web element.

Once the details of the web element, i.e., search_form_input_homepage in the DuckDuckGo web page, are identified, we make use of the send_keys action to input the search term. For simplification, we have not used Selenium WebDriverWait that ensures the loading of web elements with ID seach_form_input_homepage is completed before the subsequent set of operations can be executed.

FileName – 1-send_keys-example.py

# Demonstration of send_keys using search on DuckDuckGo
     
    import unittest
    from selenium import webdriver
    import time
    from time import sleep
     
    # Import the ActionChains class
    from selenium.webdriver.common.action_chains import ActionChains
     
    class SeachTest(unittest.TestCase):
        def setUp(self):
            # Creation of Opera WebDriver instance
            self.driver = webdriver.Chrome()
     
        def test_Search(self):
            driver = self.driver
            driver.maximize_window()
            driver.get("https://duckduckgo.com/")
     
            # Send search keyboard to the Text Box element on DuckDuckGo
     
            driver.find_element_by_id("search_form_input_homepage")
            ActionChains(driver)                 .send_keys("Lambdatest")                 .perform()
     
            sleep(5)
     
        def tearDown(self):
            # Close the browser.
            self.driver.close()
     
    if __name__ == '__main__':
        unittest.main()

To execute the code, use the command python <file-name.py> on the shell/terminal.The standard pytest test framework is used for demonstration where the operations for initialization & de-initialization being performed in setUp() & tearDown() methods. As shown in the example, send_keys action (with input-value = TestMu AI) is performed on the search box (ID = search_form_input_homepage). Since send_keys is the only action that has to be queued in the ActionChains object, perform action is fired after the same.

Keyboard Actions (key_up & key_down)

To demonstrate the usage of key_down and key_up actions, we perform a button click on TestMu AI homepage where the link-text is ‘Start Free Testing’. The Keyboard Actions in Selenium WebDriver, which are used in this particular scenario, are key_down & key_up along with .click() on the matching web element.

To start with, we use the Inspect Tool to get the XPATH of the web element with the text ‘Start Free Testing’ on the TestMu AI homepage.

Once we have located the element, the next step in this usecase that demonstrates Selenium testing is to perform CONTROL + CLICK on ‘Start Free Testing’ button so that the TestMu AI Dashboard opens in a new tab. Using the switch_to.window() method with the window handle of the newly opened tab, we switch the focus to that window.

FileName – 2-key-up-example.py

import time
    from time import sleep
    from selenium import webdriver
    from selenium.webdriver.common.action_chains import ActionChains
    from selenium.webdriver.common.keys import Keys
     
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    from selenium.webdriver.common.by import By
    from selenium.common.exceptions import TimeoutException
     
    # XPATH of the button with link text = Start Free Testing
    sign_up_xpath = "//*[@id='bs-example-navbar-collapse-1']/ul/li[7]/a"
     
    driver = webdriver.Chrome()
    driver.maximize_window()
    driver.get('http://lambdatest.com')
     
    delay = 5 # Delay in seconds
     
    try:
        myElem = WebDriverWait(driver, delay).until(EC.presence_of_element_located((By.XPATH, sign_up_xpath)))
        print("LambdaTest page is loaded")
    except TimeoutException:
        print("[Error] - TimeOut occured")
        driver.quit()
     
    element = driver.find_element_by_link_text('Start Free Testing')
     
    ActionChains(driver)         .key_down(Keys.CONTROL)         .click(element)         .key_up(Keys.CONTROL)         .perform()
     
    child_window = driver.window_handles[1]
            
    #The Parent window will go in the background
    #Child window comes to Foreground
    driver.switch_to.window(child_window)
    title2 = driver.title
    print(title2)
     
    time.sleep(5) # Pause to allow you to inspect the browser.
     
    driver.quit()

Once the webpage is loaded, we search for the element with the link text as ‘Start Free Testing’

element = driver.find_element_by_link_text('Start Free Testing')

Next step is to add necessary actions to the ActionChains object. In this scenario, the actions that are queued to the ActionChains object are:

• key_down(keys.CONTROL)
• .click(element)
• key_up(keys.CONTROL)

The intention of these combination of actions is to perform CONTROL + CLICK on the button with the matching link-text. The .perform() method is fired to execute these actions.

ActionChains(driver)         .key_down(Keys.CONTROL)         .click(element)         .key_up(Keys.CONTROL)         .perform()

For more information about window_handles and switch_to.window(), please refer to the blog where we have discussed tips & tricks for Selenium automation testing.