Absolutely! Let’s continue enhancing your automation framework by integrating Selenium Grid. In today’s session, we’ll delve into understanding Selenium Grid, setting it up in both Standalone and Distributed modes, and modifying your automation scripts to execute tests on the Grid environment. This will enable you to run your test cases across multiple browsers and operating systems seamlessly.

Table of Contents

1. Introduction to Selenium Grid

Selenium Grid is a powerful tool that allows you to run your Selenium tests on different machines and browsers simultaneously. This facilitates parallel execution of test cases, significantly reducing the overall test execution time and ensuring your application works flawlessly across various environments.

Key Benefits:

  • Parallel Execution: Run multiple tests simultaneously across different browsers and operating systems.
  • Cross-Browser Testing: Ensure your application functions correctly on all supported browsers.
  • Scalability: Easily add more nodes to handle increased test loads.
  • Resource Optimization: Efficiently utilize multiple machines without manual intervention.

2. Understanding Grid Components

Selenium Grid operates on a Hub and Node architecture:

  • Hub:
    • Acts as the central point to control test scripts.
    • Manages and distributes test cases to different nodes.
    • Responsible for maintaining the status of all nodes.
  • Node:
    • Machines where the tests are executed.
    • Can run multiple browsers simultaneously based on configuration.
    • Registers with the Hub to receive test execution requests.

Visual Representation:

+----------------+        +----------------+        +----------------+
|                |        |                |        |                |
|     Hub        | <----> |     Node 1     |        |     Node 2     |
| (Controller)   |        | (Remote Machine)|        | (Remote Machine)|
|                |        |                |        |                |
+----------------+        +----------------+        +----------------+

3. Selenium Grid Setup Modes

There are two primary modes to set up Selenium Grid:

3.1. Standalone Setup

Standalone Setup is ideal for environments where you want a single machine to act both as a Hub and a Node. This is particularly useful for practice purposes or small-scale testing.

Steps to Set Up Standalone Grid:

  1. Download Selenium Server Jar:
  2. Run Selenium Grid as Standalone:
    • Open the command prompt (Windows) or terminal (Mac/Linux).
    • Navigate to the directory where the jar file is located.
    • Execute the following command:
    java -jar selenium-server-.jar standalone

    Example:

    java -jar selenium-server-4.4.0.jar standalone
    • Upon successful execution, Selenium Grid will start, and you’ll receive a Grid URL (e.g., http://192.168.1.6:4444).
  3. Verify Grid Dashboard:
    • Open the provided Grid URL in your browser.
    • You should see the Grid Console displaying available browsers and platforms.

Key Points:

  • The same machine acts as both Hub and Node.
  • Ideal for local and small-scale testing.
  • Simplifies setup without the need for multiple machines.

3.2. Distributed Setup

Distributed Setup involves configuring a separate Hub and multiple Nodes, potentially on different machines or virtual environments. This setup is essential for large-scale testing across various platforms and browsers.

Steps to Set Up Distributed Grid:

  1. Download Selenium Server Jar on All Machines:
    • Ensure both Hub and Node machines have the selenium-server-.jar file downloaded.
  2. Start the Hub:
    • On the Hub machine, open the command prompt or terminal.
    • Navigate to the directory containing the jar file.
    • Execute the following command to start the Hub:
    java -jar selenium-server-.jar hub
  3. Configure Nodes:
    • On each Node machine, open the command prompt or terminal.
    • Navigate to the directory containing the jar file.
    • Execute the following command to register the Node with the Hub:
    java -jar selenium-server-.jar node --hub http://:4444/grid/register

    Example:

    java -jar selenium-server-4.4.0.jar node --hub http://192.168.1.6:4444/grid/register
    • The Node will now register with the Hub and display available browsers and platforms.
  4. Verify Grid Dashboard:
    • On the Hub machine, refresh the Grid URL in your browser.
    • Ensure all Nodes are listed with their respective browsers and platforms.

Key Points:

  • Hub and Nodes on Separate Machines: Allows for true parallel and distributed testing.
  • Scalability: Easily add more Nodes to increase testing capacity.
  • Cross-Platform Testing: Supports multiple operating systems and browsers.

4. Configuring Your Automation Framework for Grid Execution

To enable your existing automation framework to execute tests on Selenium Grid, you’ll need to make specific modifications. This involves parameterizing the execution environment and adjusting the WebDriver initialization logic.

4.1. Updating the Properties File

Add a new parameter to control the execution environment (Local or Remote).

  1. Open config.properties File:
    • Navigate to src/test/resources/config/config.properties.
  2. Add Execution Environment Parameter: 
    execution_environment=local
# execution_environment=remote

    Explanation:

    • execution_environment: Determines where tests will run.
      • local: Executes tests on the local machine.
      • remote: Executes tests on the Selenium Grid.
    • Usage:
      • To run tests locally: Ensure execution_environment=local is uncommented.
      • To run tests on Grid: Comment out local and uncomment remote.

4.2. Modifying the Base Class

Adjust the WebDriver setup to handle both local and remote executions based on the execution_environment parameter.

  1. Open BaseTest.java:
    • Navigate to src/test/java/com/opencart/base/BaseTest.java.
  2. Import Necessary Classes: 
    import org.openqa.selenium.Platform;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import java.net.MalformedURLException;
import java.net.URL;
  3. Update the setUp Method: 
    package com.opencart.base;

import org.openqa.selenium.Platform;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.edge.EdgeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;

import java.net.MalformedURLException;
import java.net.URL;

public class BaseTest {
    protected static WebDriver driver;
    private String executionEnvironment;
    private String operatingSystem;
    private String browser;

    @BeforeClass(groups = {"sanity", "regression", "master", "dataDriven"})
    public void setUp() throws MalformedURLException {
        // Read parameters from properties and XML files
        executionEnvironment = ConfigReader.getProperty("execution_environment");
        operatingSystem = ConfigReader.getProperty("os");
        browser = ConfigReader.getProperty("browser");

        if (executionEnvironment.equalsIgnoreCase("remote")) {
            // Set DesiredCapabilities
            DesiredCapabilities capabilities = new DesiredCapabilities();

            // Set Platform
            if (operatingSystem.equalsIgnoreCase("Windows")) {
                capabilities.setPlatform(Platform.WINDOWS);
            } else if (operatingSystem.equalsIgnoreCase("Mac")) {
                capabilities.setPlatform(Platform.MAC);
            } else if (operatingSystem.equalsIgnoreCase("Linux")) {
                capabilities.setPlatform(Platform.LINUX);
            } else {
                System.out.println("No matching OS found!");
                return;
            }

            // Set Browser
            switch (browser.toLowerCase()) {
                case "chrome":
                    capabilities.setBrowserName("chrome");
                    break;
                case "firefox":
                    capabilities.setBrowserName("firefox");
                    break;
                case "edge":
                    capabilities.setBrowserName("edge");
                    break;
                default:
                    System.out.println("No matching browser found!");
                    return;
            }

            // Initialize RemoteWebDriver
            driver = new RemoteWebDriver(new URL("http://:4444/wd/hub"), capabilities);
        } else if (executionEnvironment.equalsIgnoreCase("local")) {
            // Local Execution
            switch (browser.toLowerCase()) {
                case "chrome":
                    System.setProperty("webdriver.chrome.driver", "path_to_chromedriver");
                    driver = new ChromeDriver();
                    break;
                case "firefox":
                    System.setProperty("webdriver.gecko.driver", "path_to_geckodriver");
                    driver = new FirefoxDriver();
                    break;
                case "edge":
                    System.setProperty("webdriver.edge.driver", "path_to_edgedriver");
                    driver = new EdgeDriver();
                    break;
                default:
                    System.out.println("No matching browser found!");
                    return;
            }
        } else {
            System.out.println("Invalid execution environment specified!");
            return;
        }

        // Maximize and navigate to the application URL
        driver.manage().window().maximize();
        driver.get(ConfigReader.getProperty("app_url"));
    }

    @AfterClass(groups = {"sanity", "regression", "master", "dataDriven"})
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }

    /**
     * Captures a screenshot of the current browser window.
     *
     * @param testMethodName The name of the test method.
     * @return The path to the captured screenshot.
     */
    public String captureScreen(String testMethodName) {
        // Generate timestamp
        String timeStamp = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss").format(new Date());

        // Define screenshot file name and path
        String screenshotName = testMethodName + "_" + timeStamp + ".png";
        String screenshotPath = System.getProperty("user.dir") + "/screenshots/" + screenshotName;

        // Capture screenshot
        File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
        File dest = new File(screenshotPath);

        try {
            FileUtils.copyFile(src, dest);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return screenshotPath;
    }
}

    Explanation:

    • Parameters:
      • executionEnvironment: Determines if tests run locally or on Grid.
      • operatingSystem & browser: Specifies the OS and browser for test execution, sourced from the XML file.
    • Remote Execution:
      • DesiredCapabilities: Defines the platform and browser.
      • RemoteWebDriver: Initializes the driver with the Grid’s Hub URL and capabilities.
    • Local Execution:
      • Initializes the WebDriver based on the specified browser.
      • Note: Replace "path_to_chromedriver", "path_to_geckodriver", and "path_to_edgedriver" with the actual paths to your WebDriver executables.
    • Error Handling:
      • Prints messages if no matching OS or browser is found and exits the setup.

5. Running Tests on Selenium Grid

With Selenium Grid set up and your framework configured, you can now execute your tests either locally or on the Grid.

5.1. Executing Locally

  1. Ensure Grid is Not Running:
    • If you have the Grid (Hub) running in Standalone mode, stop it by closing the command prompt or terminal window.
  2. Set Execution Environment to Local:
    • In config.properties, ensure:
    execution_environment=local
# execution_environment=remote
  3. Run TestNG Suite:
    • Right-click on your TestNG XML file (e.g., master.xml) and select Run As > TestNG Suite.
    • Tests will execute on your local machine using the specified browser.

5.2. Executing on Selenium Grid (Remote Execution)

  1. Start Selenium Grid:
    • Standalone Mode:
        • Open command prompt or terminal.
        • Navigate to the directory containing selenium-server-.jar.
        • Run:
      java -jar selenium-server-.jar standalone
    • Distributed Mode:
      • On Hub Machine:
          • Run:
        java -jar selenium-server-.jar hub
      • On Each Node Machine:
          • Ensure the Hub’s Grid URL is accessible.
          • Run:
        java -jar selenium-server-.jar node --hub http://:4444/grid/register
  2. Set Execution Environment to Remote:
    • In config.properties, ensure:
    # execution_environment=local
execution_environment=remote
  3. Update TestNG XML File:
    • Ensure your TestNG XML file specifies the desired OS and browser.
    • Example (master.xml):
    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="MasterSuite" parallel="tests" thread-count="5">

    <listeners>
        <listener class-name="com.opencart.utilities.ExtentReportManager"/>
    </listeners>

    <test name="WindowsChromeTests">
        <parameter name="os" value="Windows"/>
        <parameter name="browser" value="chrome"/>
        <classes>
            <class name="com.opencart.tests.LoginTest"/>
            <class name="com.opencart.tests.AccountRegistrationTest"/>
        </classes>
    </test>

    <test name="WindowsEdgeTests">
        <parameter name="os" value="Windows"/>
        <parameter name="browser" value="edge"/>
        <classes>
            <class name="com.opencart.tests.LoginTest"/>
            <class name="com.opencart.tests.AccountRegistrationTest"/>
        </classes>
    </test>

    <test name="WindowsFirefoxTests">
        <parameter name="os" value="Windows"/>
        <parameter name="browser" value="firefox"/>
        <classes>
            <class name="com.opencart.tests.LoginTest"/>
            <class name="com.opencart.tests.AccountRegistrationTest"/>
        </classes>
    </test>

    

</suite>
  4. Run TestNG Suite:
    • Right-click on master.xml and select Run As > TestNG Suite.
    • Tests will execute on the Selenium Grid based on the specified parameters.
  5. Monitor Test Execution:
    • Open the Grid Dashboard URL in your browser (e.g., http://192.168.1.6:4444).
    • Navigate to the Sessions tab to monitor active and completed test sessions.
  6. Note: Ensure that all Node machines have the necessary browsers installed and are properly registered with the Hub.

6. Best Practices

To ensure a smooth and efficient Selenium Grid setup and integration, adhere to the following best practices:

  1. Consistent Configuration:
    • Maintain consistent versions of Selenium Server and WebDriver executables across all machines.
  2. Network Stability:
    • Ensure all Hub and Node machines are on the same network or can communicate with each other reliably.
  3. Resource Allocation:
    • Allocate sufficient resources (CPU, memory) to Hub and Node machines to handle parallel executions without performance degradation.
  4. Dynamic Grid Management:
    • Automate the addition and removal of Nodes to accommodate fluctuating test loads.
  5. Use Docker for Scalability:
    • Leverage Docker containers to simplify Node setup and enhance scalability.
  6. Centralized Logging:
    • Implement centralized logging to capture test execution details across all Nodes.
  7. Security Measures:
    • Secure your Grid by restricting access to authorized users and using firewalls to protect against unauthorized access.
  8. Regular Maintenance:
    • Regularly update browsers, WebDrivers, and Selenium Server to their latest versions to avoid compatibility issues.
  9. Parallel Test Design:
    • Design tests to be independent and stateless to maximize parallel execution efficiency.

7. Conclusion

Integrating Selenium Grid into your automation framework empowers you to execute tests across multiple browsers and operating systems efficiently. By understanding the Hub and Node architecture, setting up both Standalone and Distributed modes, and configuring your framework accordingly, you can achieve scalable and robust test executions.

Key Takeaways:

  • Selenium Grid facilitates parallel and cross-platform testing.
  • Standalone Setup is ideal for local and small-scale testing.
  • Distributed Setup is essential for large-scale, cross-environment testing.
  • Framework Configuration: Parameterizing execution environments ensures flexibility without altering the core codebase.
  • Best Practices enhance the reliability and efficiency of your Grid setup.

Next Steps:

  1. Explore Docker Integration:
    • Learn how to use Docker containers to streamline Node setup and management.
  2. Advanced Grid Configurations:
    • Implement advanced Grid features like Grid Capacity, Node Constraints, and Selenium Grid Extras.
  3. Continuous Integration (CI) Integration:
    • Integrate Selenium Grid with CI tools like Jenkins for automated and scheduled test executions.
  4. Monitoring and Reporting:
    • Enhance monitoring using tools like Selenium Grid Dashboard or integrate with reporting tools for comprehensive test insights.

Happy Testing! 🚀


Last Post


Next Post