SeleniumTesting

Selenium is a test automation tool that automates browsers.  Selenium grid is built on the traditional set up of Selenium. It takes advantage of the following properties.

-      The Selenium test, the application under test and the remote control/browser pair can communicate through HTTP, so they do not need to be collocated.

-      The Selenium RC and the browser are never tied up to a specific application and hence, they can be easily shared through multiple applications and multiple projects.

The Selenium Grid transparently distributes tests across multiple physical and virtual locations so that they can be run in parallel. This speeds up the testing process, giving back quick and accurate feedback. Through Selenium Grid, the existing computer infrastructure can be leveraged. It enables running multiple tests in parallel, on multiple nodes/clients in a heterogenous environment of OS and browser support.

The Selenium Grid allows running of multiple parallel instances of WebDriver or Selenium RC. It makes all nodes appear as a single instance and so the tests do not need to understand the actual infrastructure. To run the grid the Selenium Server Standalone package includes

-      The Hub

-      The Web Driver

-      The Selenium RC

The Selenium exposes an external interface similar to the traditional Remote Control. It acts like a central point which receives the entire test request and distributes it to the right nodes. It is responsible for

-      Allocating a selenium RC to a specific test

-      Limiting the number of concurrent test runs on each Remote Control

-      Shielding the tests from the actual grid infrastructure.

Testing Practices with Selenium Grid

-      Download the latest Selenium Server standalone JAR file. Here we are referring to version 2.25.0

-      Use the following command to launch the Selenium Server. It will start the Selenium Server Hub role.

-      java -jar selenium-server-standalone-2.25.0.jar -port 4444 -role hub -nodeTimeout 600

-      On launching Selenium Standalone in the Hub role, it starts listening to nodes and Selenium testing. By default, the Hub provides 5 sessions on the server.

-      For running the tests with Selenium Grid, the Selenium WebDriver tests use the  class instances of RemoteWebDriver and DesiredCapabilites in order to define the browser, version and platform in which the tests will be executed on. Based on the preferences in the DesiredCapabilities, the Hub will redirect the test to the node matching the preferences. These preferences are set using the methods of DesiredCapabilities class. They are

-      setBrowserName()

-      setVersion()

-      setPlatform()

In order to refine the number of available browsers, an additional browser parameter can be specified. This can also be used for specifying more than one browser as well.

The command will look like this:

java -jar selenium-server-standalone-2.42.0.jar -role node -browser browserName=safari -browser browserName=chrome -browser browserName=firefox -hub http://localhost:4444/grid/register

For setting up Selenium Grid to work with Internet Explorer or Chrome, additional configuration may be required for each. It is recommended to check out the browser driver documentation for this.

When using Selenium Grid, confusions can occur from time to time. Using Selenium Extras helps to clear these confusions and helps to fix issues which come up outside of the web browser. Some of its cleanup tasks are:

-      After a complete test run it kills any remaining or crashed instances of the browser used.

-      It modifies he browser settings on launch for a hassle free test execution.

-      It periodically starts grid nodes to clear up memory leaks.

-      It automatically records a video of the running test session at the OS level which helps to review the test failure more effectively.

Furthermore, restarting the whole OS after a certain amount of test runs allows to clear up any remaining crashed items. Restarting the entire machine after every 10 to 20 test runs gives a huge boost in stability.

Conclusion

Organizations have become more aware of the crucial role of testing in software development life cycle and in delivering high quality software products. As the competition in the IT industry grows stiffer, the pressure to deliver high quality products with fewer resources and limited time is intensifying.

Automation testing helps to overcome these criteria and also addresses the challenges presented by manual testing. Automated tests can be executed can be executed multiple times and much faster than manual tests. They help to find defects and issues which are more often overlooked in Manual testing. Automation helps in automating repetitive tasks and help to focus on high risk projects.

Identifying the right automation tool is critical to ensure success of a testing project. A detailed analysis needs to be conducted before selecting a tool. The selection of a tool depends on:

-      The application and its technology stack to be tested.

-      Detailed testing requirements.

-      Available skill sets in the organization.

-      The investment required.

-      Ease of adoption

-      Ease of scripting and reporting capabilities

-      Usage of tools

Selenium is for automating web browsers for testing purposes. It is  a free, open source tool with a different set of tools, which support test automation through different approaches. As it is an open source technology, it requires a development experience to make the automation tools available. Let us review the most important factors which affect the adoption of Selenium test automation tool.

-      Scope of the project: It is extremely important to have a very clear vision of the framework and the expectations.

-      Complexity of the application: The size of the application needs to be determined based on the number of tests that has to be automated. This definition may differ from the perspective of a group or an individual.

-      Supporting tools and technologies required: Once the automation framework is identified, based on the requirements, the required tools need to be identified. Further the dependencies and implications need to be understood. Selenium alone is not sufficient to complete test automation. There are other related tasks like reporting and log tracking, etc. For these separate tools are required, which need to be integrated with the framework.

-      Implementation of the Framework: In addition to just scripting, there are many other requirements like reading data, tracking and  reporting results, tracking logs, triggering scripts based on input conditions etc., which needs a framework in place. Web applications are not simple and involve a lot of tools and technology. Selenium may not be strong enough to build a strong framework based on the third party tools required for completing the testing requirements.

-      Learning and Training: Implementing any new software requires sufficient time for learning and training purposes. Selenium testing involves learning a programming language. The time involved, the resources available, the investment required in this phase is a deciding factor in the adoption of  Selenium

-      Environment Setup: This deals with set up the code in the test environment and production environment, writing scripts and creating property files for tracking the environment and credentials.

Conclusion

Continuous delivery is an approach which ensures that any version of the system is releasable at any given time without panic. It aims at frequently and  faster delivery. The concept of continuous delivery is tightly related to continuous integration. It is a software development practice by which the team members integrate their working modules more frequently, resulting into multiple integrations per day. The goal here is to put the customers in control of the software releases.

Continuous delivery can be achieved by

- establishing a collaborative work culture among all the people involved in the delivery process

- and by automating all the possible phases of the delivery process.

One such important phase of a continuous delivery process is continuous testing. Continuous testing can be considered as the bottle neck for continuous delivery. It involves applying the methods and practices of agile development into the testing process.

Automating this phase of testing has its own advantages, which improves the efficiency of the software in the long run.

There are some major advantages of automated testing mainly related to continuous reuse of the test scripts. Selenium is one of the most widely used open source automated testing solution. It provides a suite of tools by which web browsers can be automated across many platforms. It can be used in conjunction with continuous integration for automated testing of the web application via test scripts. It provides the following features:

- Continuous regression testing - Faster feedback to developers. - Unlimited iterations of test case execution - Supports Agile and other extreme development methodologies. - Defect reporting

The entire Selenium testing suite is a rich set of test functions, which are highly flexible, providing the ability to compare expected test results with the actual behavior of the application. By integrating Selenium scripts for testing, development team can achieve end-to-end software testing.  As it supports a number of programming languages, it can be easily integrated into the existing IDEs for the continuous delivery process. Tests can be run in parallel, user activities can be recorded which can be played back later. They can also be saved as exportable files for later use.

The implementation of Selenium in a development process can vary and follow different pathways to ensure that the best user experience is delivered. It starts within the development process where developers use it to test the functionality of their code. Once these codes are ready for pre production, dedicated teams for Quality Assurance use these test scripts and modify the parameters as required. In the production environment, the operations team can reuse these tests for acceptance testing and other post production monitoring. Thus, Selenium provides an effective test strategy incorporating all elements of test optimization further accelerating continuous integration, delivery and deployment.

Conclusion

Jason Huggins created Selenium in 2004. He was an engineer in Thoughtworks. There he was working on a web application which required regular testing. Realizing the inefficiency of repeated manual testing, he created 'JavaScriptTestRunner', a program in JavaScript which could control the browser actions. He made it open source considering that more web applications could be automated using this program.

The Name:

Another framework for automated testing popular during those days was QTP, by the company Mercury Interactive. As Selenium is an antidote for Mercury, 'JavaScriptTestRunner' was hence renamed Selenium, as a competitor for Mercury Interactive, on pure grounds of wit.

Apart from being an open source tool, another factor that makes it popular is the multiple programming languages supported by it. It supports, Java, C#, PHP, Python, Perl and Ruby. Most of the popular browser vendors have also initiated processes to make their browsers compatible to it.

The Components:

Selenium is a combination of the following tools:

1.   Selenium IDE(Integrated Development Environment): Shinya Kasatani from Japan developed this IDE and donated it to the Selenium project on 2006. It is a Firefox Extension which automates the browser using a record and playback feature. It records user actions and then saves them as a reusable script in one of the programming languages. This exported file can be later on executed repeatedly.

2.  Selenium RC(Remote Control) also known as Selenium 1: Testers who were using Selenium Core required to install the whole application and the web server in their local setup.  To overcome this, Paul Hammant created Selenium RC, which acted as HTTP proxy which made the browser believe that the Selenium Core and the webserver come from the same domain.

3.  Selenium Web Driver: In 2006, the browsers and web applications were becoming more restrictive with running Javascript programs. Simon Stewart then created Selenium Web Driver which was the first cross platform testing framework. It could control the browser from the Operating System level. In 2008, Selenium RC was merged with Web Driver to form Selenium 2. WebDriver supports HTMLUnitbrowser which is generally used for functional testing.

4.  Selenium Grid: Patrick Lightbody developed Selenium Grid to minimize the time required for test execution. It captured browser screenshots and performed parallel tests on multiple browsers on multiple machines. It controlled multiple environment from a central location.  Thus, for a large test suite, or a slow running test suite, Selenium Grid divides the test suit and runs different tests on different machines at the same time. This parallel processing greatly minimizes the time required to execute the entire test suite.

Basic Concept:

Selenium works on a Page Object Model  which is an object oriented library that brings object oriented programming into test scripts. Here, web pages are the classes and its elements are assumed as  its variables. All the user interactions are treated as methods in this class. Page Factory in Selenium is an extension to  the Page Object Model. It initializes the web elements in the web page classes. The elements can be used only after their initialization.

Conclusion:

Selenium is an open source automated tool for testing web applications. It provides an extensive library of test functions. It interacts with web browsers using programming languages such as PHP, Java, .Net, C#, Ruby, Perl etc. Tests in Selenium can be scripted in HTML tables or using these programming languages. Selenium helps to locate UI elements. It defines the methods of comparing pre-calculated test results with the actual real time application functions. It supports almost all of the major web browsers and can be deployed on Linux, Windows and Macintosh. Selenium is mainly preferred for User Acceptance Testing.

Components of Selenium:

There are four components of Selenium. They can be used individually or combined with each other to create automated testing solutions for web applications. These four components can be defined as follows:

- Selenium IDE: Selenium Integrated Development Environment is a plugin for Firefox that record the user interactions in the applications for formulating test cases.

- Selenium Remote Control: Creates test cases using the supported programming languages. - Selenium WebDriver: It is an extension of Selenium RC. It executes the commands directly in the browser and generates results.

- Selenium Grid: This tool helps to run test cases across multiple browsers and operating systems simultaneously minimizing the test execution time. Challenges of Selenium Script Execution:

- Selenium is unable to record the pop-ups which causes issues in executing Selenium scripts. This is handled by applying a getAlert() function. Before running a test script, a WebDriver script that can handle alerts needs to be imported. This script defines the following commands:

void  accept(), void dismiss(), getText(), void sendKeys(String stringToSend)

- Events are not triggered when values change: Selenium is unable to trigger events automatically with changing values. Hence the command: Selenium.FireEvent(cmbCategory, “onchange”); is used where, cmbCategory is the object on which the event is fired; onchange is the event name.

- Synchronization issues lead to timeouts: To solve this issue, a function needs to be created to check the presence of the element. This will need to take the object locator as the parameter and return true if the object is found. The following function can be used: IsElementPresent(locator) Thread.Sleep

- SSL Issues: Selenium Tests may face issues with Secure Socket Layer(SSL). This issue can be solved by trustAllSSLCertificates.

For browsers excluding firefox: C: > java -jar c:\Selenium\selenium-server2.14.0.jar. –trustAllSSLCertificates For firefox: C:> java -jar c:\Selenium\selenium-server2.14.0.jar. -firefoxProfileTemplate /C:\Selenium\ Profile

- Flash App Testing: Flex Monkium can be used for automation of flash apps. The source code of the application is created by Flex Monkium and compiled with swc files. The app and the IDE are then connected and the tests are recorded with the IDE.  

- Internet Explorer Launch Error: The zoom level in the browser should be 100% by default.

- Error occurs when Selenium Webdriver is run on a new Windows machine. This can be solved by setting the following parameters:

DesiredCapabilities caps = DesiredCapabilities.internetExplorer(); caps.setCapability(InternetExplorerDriver.INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS,true); WebDriver driver = new InternetExplorerDriver(caps);

Some additional issues

1. With change in the application design, the verification code also changes. 2. Sometimes the application stops before the verification code is executed. When the verification code is rerun, the new verification code is rejected and the script fails to execute. 3. Compatibility issues occur between Selenium and components of Java. 4. The Element-ID of the data in the submitted application changes regularly.

The various components in designing Selenium test cases are as follows:

- Page Object Model - Log4jLogging - Parameterizing using Excel - Exception Handling - Multi Browser testing - Capture videos - Capture Screenshots.

Conclusion:

Selenium is one of the most trending tools currently in the market for automated cross browser testing of web applications. There is no specific guideline for implementing Selenium, however, there are several methodologies that can be followed to successfully leverage the features of Selenium.

Evaluate the Standards of the Organization:

For implementing a new software practice in an organization, the new software tool needs to be tested in terms economic and technical feasibility for the organization.

Before implementing Selenium, its pros and cons should be well evaluated against the organization’s requirements.

Selenium is only used to test web applications. The entire coverage provided by Selenium testing should be documented and well communicated to the team who will be using it.

Selenium supports a large set of popular programming languages. However, if the implementation team uses a programming language that is not supported by Selenium, they will experience difficulties in the transition.

Implementing a Framework

The most naive way to use Selenium is to code a script for each test. This may seem as a very potential way of achieving full test coverage. But this same methodology may lead to future standstills due to a number of reasons.  Tests should stable, consistent, easily understandable and that which can be changed easily. This requires a framework to be in place. While implementing a framework can be time consuming, it will pay off enormously in the future.

Code Standardization

Conforming to an existing naming and documentation convention is an important aspect of any automation process. It is equally important to develop codes that can be reused. It can be a constructive initiative to train the automation developers on the fundamentals of software development techniques.

Externalization of the Configuration

The most common failure in software automation is when a new software build is released, the already developed automation scripts fail to test them successfully. To avoid such inconsistencies, the automated tests should be consistent and adaptable.

This can be achieved in the following ways:

- Making the automation self-aware by anticipating dynamic functionalities and accommodating them whenever possible.

- Configurable values should be exposed whenever possible. A majority of the maintenance issues is caused by tweaking object identification. This is because Selenium provides no object identification strategy at all.

- The naming conventions and the other coding standards should be strictly followed.  A failure to adhere to these conventions may lead to hours of debugging efforts.

- Hard coding can seem easy and is mainly practiced by the ignorant or novice programmers. Specifying fixed values which are potentially configurable in the future, call for changes in the code for maintenance in the future.

Logging and Reporting

Logs and reports help to determine the pass or failure of tests, determine test coverage, debug test scripts, collect the debug report and access screen captures as well. Selenium lacks in logging and reporting. Without results and reports, test automation is of no use.

While implementing these features, the best approach is to separate the concept of logging and reporting. Logging should be reserved for technical details while reports serve better as HTML or other portable readable format. Reports should also contain the execution details of the test cases and the environment in which they were run.

The client will always ask for the test report and it should be ensured that the test automation serves its purpose for which it was implemented in the first place.

Conclusion:

Selenium is an open-source automated testing tool designed for cross-browser application testing. According to SeleniumHQ -  'Selenium automates browsers'. How we harness this power completely depends on our strategies. Selenium automates web browsers as well as the web-based administration tasks.  There is a high probability that Selenium will be a native component of most of the popular browsers in the near future.

Knowing about Selenium

The initial release of Selenium had four main components. It is referred to as SeleniumRC

- Selenium Integrated Development Environment(IDE) - Selenium Remote Control - Selenium(RC) - Web Driver - Selenium Grid

Later, the component Selenium(RC) and WebDriver were merged to form Selenium 2, also known as Selenium WebDriver. Selenium RC has been officially deprecated.

Selenium IDE: It can be implemented as Firefox extension. It allows us to record, edit and debug tests.  It is a complete Integrated Development Environment for Selenium scripts. It is an ideal environment for Selenium tests with its autocomplete support, optional recording capability and editable test scripts.

Selenium WebDriver: It is the primary feature of Selenium2. It is the first cross platform testing framework which could control the web browser from the operating system level.  It is a simple and more concise Object Oriented programming interface. Selenium WebDriver was developed to provide enhanced support to dynamic webpages where elements and contents of a page change without reloading the page.  Here, tests need to be written in Java. The implementing classes used are listed as follows:

- AndroidDriver - CromeDriverFirefoxDriver - InternetExplorerDriver - SafariDriver   - HtmlUnitDriver - EventFiringWebDriver - RemoteWebDriver - PhantomJSDriver

Selenium Grid: Selenium Grid was developed to minimize the testing execution time as much as possible. It captured browser screen shots and sent out Selenium commands to different machines simultaneously. It works on the hub-nodes concept.  The hub acting as the main source of Selenium, commands to each connected node.

Pros and Cons of Selenium Automated Testing

The advantages of using Selenium are as follows:

- Low Cost Tool – Since it is an open source tool it can be easily downloaded and programmers can easily use the tools to automate the web application testing in any scripting language.

- Browser Compatibility Testing : Applications can be easily tested across multiple web browsers

- Supports multiple programming languages: The Selenium client languages can be easily imported into popular languages such as Net Beans, .net, Eclipse etc.

- Multiple Testing Frameworks: It supports a variety of testing frameworks such as JUnit, PHPUnit and TestNg

- Easy Integration with the Eco system: It can be integrated with various kinds of test suites such as Selenium Grid, Ometry, Saucelabs etc.

- AJAX Support: It supports for ajax functionalities and helps to monitor changes in content without page reload.

- Open for Enhancement: Since it is open source, developers are free to expand the Selenium functionalities for more complex testing.

- Enables Comprehensive Testing: It can be used for Functional, Regression, Usability and UAT Testing.

- Test Driven Development: It is mainly used in the Agile and Extreme Programming community areas.

The various disadvantages of Selenium Testing are as follows:

- Testing Roadblocks: It may show erratic or unpredictable behavior after injection of Selenium code into HTML source files for testing.

- Finding Locators: Common attributes like Names, IDs, XPATH, DOM need to be located using firebug.

- Limited support from browsers: To run test scripts on multiple browsers, they need to be written on Selenium IDE with Selenium core. Otherwise, the testing can only be carried out on Mozilla. Data Driven Tests are not supported by this framework.  

- Implementation difference may slow down the performance of certain methods.

Selenium is at the core of many browser automation tools, APIs and frameworks. Recently, HP has enhanced its Unified Functional Testing(HP UFT) Tool and released LeanFT(Lean Functional Tool) which integrates the open-source Selenium features with that of its UFT Tool features.

Conclusion: